TASability

 FPS =  
 PlaybackInputs =  
 PlaybackMouseLocation =  
 RoundDigits =  
 ReplayStartTime =  
 FrameBacktrackCount =  
 MinimumJSONFPS = / 
 BypassAntiExploit =  





 InputBlacklist = {
	[] = ;
	[] = ;
	[] = ;
	[] = ;
	[] = ;
}


 ColorCodes = {
	WaitingForInput = .(,,);
	Recording = .(,,);
	Reading = .(,,,);
	Idle = .(,,);
	Frozen = .(,,);
	
	None = .(,,);
}


 Cursors = {
	[] = {
		Icon = ;
		Size = .(,);
		Offset = .(-,);
	};
	[] = {
		Icon = ;
		Size = .(,);
		Offset = .(-,-);
	};
}




 Version = 
 UserInputService = :()
 RunService = :()
 HttpService = :()
 ContextActionService = :()
 GuiService = :()
 VirtualInputManager = :()
 Player = .Players.LocalPlayer
 Mouse = Player:()
 random = .random
 min = .min
 max = .max
 floor = .floor
 ceil = .ceil
 ReplayFileBeginning = 
 ReplayFileEnding = 
 PlayerModule = Player.PlayerScripts:()
 ShiftLockBoundKeys = PlayerModule:():():()
 ShiftLockEnabled = 
 GuiInset = GuiService:()


 ExecutionTick = ()
 PlaceId = .PlaceId

 Character = 
 Humanoid = 
 RootPart = 
 DefaultGravity = 
 DefaultJumpPower = 
 DefaultWalkSpeed = 
 Resolution = 
 ConsoleMessage = 

 Reading = 
 Writing = 
 Saving = 
 AnimateDisabled = 
 Checkpoints = {}
 RenderSteppedConnections = {}
 SteppedConnections = {}
 FolderPath = ..(PlaceId)
 ReplayPath = (FolderPath)  #(FolderPath) >=   (FolderPath)[]  FolderPath..
 AHKConnectionFolderPath = 
 AHKConnectionRequestPath = 
 ReplayTable = {} 
 RecordingTable = {} 
 ReplayTableIndex =  
 AnimationQueue = {} 
 RunSpeed =  
 ClimbSpeed =  
 HumanoidStateQueue = {} 
 InputBeganQueue = {} 
 InputEndedQueue = {} 
 Cursor = .() 
 CursorIcon =  
 CursorSize =  
 CursorOffset =  
 Dead =  
 CameraCFrame = .CurrentCamera.CFrame 
 Pressed = {} 
 IgnoreGameProcessed =  


 Frozen = 
 FreezeFrame =  
 SeekDirection =  
 SeekDirectionMultiplier =  



 InputCodes = {
	[] = ;
	[] = ;
	[] = ;
	[] = ;
	[] = ;
	[] = ;
	[] = ;
	[] = ;
	[] = ;
	[] = ;
	[] = ;
	[] = ;
	[] = ;
	[] = ;
	[] = ;
	[] = ;
	[] = ;
	[] = ;
	[] = ;
	[] = ;
	[] = ;
	[] = ;
	[] = ;
	[] = ;
	[] = ;
	[] = ;
	[] = ;
	[] = ;
	[] = ;
}


mouse1press = mouse1press  mouse1down
mouse2press = mouse2press  mouse2down
mouse1release = mouse1release  mouse1up
mouse2release = mouse2release  mouse2up
keypress = keypress  keydown
keyrelease = keyrelease  keyup


 pose =  
 currentAnimSpeed =  


 GUIParent = Player:()
 json
 
	json = (()
																			
																			
																			
																			
																			
																			
																			
																			
																			
																			
																			
																			
																			
																			
																			
																			
																			
																			
																			
																			
																			
																			
																			

																			 json = { _version =  }
																			
																			 t = ()
																			 currentstr
																			 lasti
																			  (i)
																				 () - t > MinimumJSONFPS 
																					lasti = lasti  i
																					 i >= lasti 
																						 Type = ((currentstr) ==   )  ((currentstr) ==   )
																						 Type 
																							(Type....(i)....(#currentstr)..)
																						
																						:().Stepped:()
																						t = ()
																						lasti = i
																					
																				
																			

																			
																			
																			

																			

																			 encode

																			 escape_char_map = {
																				[  ] = ,
																				[  ] = ,
																				[  ] = ,
																				[  ] = ,
																				[  ] = ,
																				[  ] = ,
																				[  ] = ,
																			}

																			 escape_char_map_inv = { [  ] =  }
																			 k, v  (escape_char_map) 
																				escape_char_map_inv[v] = k
																			


																			  (c)
																				  .. (escape_char_map[c]  .(, c:()))
																			


																			  (val)
																				 
																			


																			  (val, stack)
																				 res = {}
																				stack = stack  {}

																				
																				 stack[val]  () 

																				stack[val] = 

																				 (val, ) ~=   (val) ==  
																					
																					 n = 
																					 k  (val) 
																						 (k) ~=  
																							()
																						
																						n = n + 
																					
																					 n ~= #val 
																						()
																					
																					
																					 i, v  (val) 
																						(i)
																						.(res, (v, stack))
																					
																					stack[val] = 
																					
																					  .. .(res, ) .. 

																				
																					
																					 i = 
																					 k, v  (val) 
																						i = i + 
																						 (k) ~=  
																							()
																						
																						(i)
																						.(res, (k, stack) ..  .. (v, stack))
																					
																					stack[val] = 
																					
																					  .. .(res, ) .. 
																				
																			


																			  (val)
																				  .. val:(, escape_char) .. 
																			


																			  (val)
																				
																				 val ~= val  val <= -.huge  val >= .huge 
																					( .. (val) .. )
																				
																				 .(, val)
																			


																			 type_func_map = {
																				[      ] = encode_nil,
																				[    ] = encode_table,
																				[   ] = encode_string,
																				[   ] = encode_number,
																				[  ] = ,
																			}


																			encode = (val, stack)
																				 t = (val)
																				 f = type_func_map[t]
																				 f 
																					t = ()
																					 (val, stack)
																				
																				( .. t .. )
																			


																			 json.(val)
																				currentstr = val
																				lasti = 
																				 ( (val) )
																			


																			
																			
																			

																			 parse

																			  (...)
																				 res = {}
																				 i = , (, ...) 
																					res[ (i, ...) ] = 
																				
																				 res
																			

																			 space_chars   = (, , , )
																			 delim_chars   = (, , , , , , )
																			 escape_chars  = (, , , , , , , , )
																			 literals      = (, , )

																			 literal_map = {
																				[   ] = ,
																				[  ] = ,
																				[   ] = ,
																			}


																			  (str, idx, set, negate)
																				 i = idx, #str 
																					 set[str:(i, i)] ~= negate 
																						 i
																					
																				
																				 #str + 
																			


																			  (str, idx, msg)
																				 line_count = 
																				 col_count = 
																				 i = , idx -  
																					col_count = col_count + 
																					 str:(i, i) ==  
																						line_count = line_count + 
																						col_count = 
																					
																				
																				( .(, msg, line_count, col_count) )
																			



																			  (n)
																				
																				 f = .floor
																				 n <=  
																					 .(n)
																				 n <=  
																					 .((n / ) + , n %  + )
																				 n <=  
																					 .((n / ) + , (n %  / ) + , n %  + )
																				 n <=  
																					 .((n / ) + , (n %  / ) + ,
																						(n %  / ) + , n %  + )
																				
																				( .(, n) )
																			


																			  (s)
																				 n1 = ( s:(, ),   )
																				 n2 = ( s:(, ),  )
																				
																				 n2 
																					 ((n1 - ) *  + (n2 - ) + )
																				
																					 (n1)
																				
																			


																			  (str, i)
																				 res = 
																				 j = i + 
																				 k = j

																				 j <= #str 
																					 x = str:(j)

																					 x <  
																						(str, j, )

																					 x ==   
																						res = res .. str:(k, j - )
																						j = j + 
																						 c = str:(j, j)
																						 c ==  
																							 hex = str:(, j + )
																								 str:(, j + )
																								 (str, j - , )
																							res = res .. (hex)
																							j = j + #hex
																						
																							  escape_chars[c] 
																								(str, j - ,  .. c .. )
																							
																							res = res .. escape_char_map_inv[c]
																						
																						k = j + 

																					 x ==   
																						res = res .. str:(k, j - )
																						 res, j + 
																					

																					j = j + 
																					(i)
																				

																				(str, i, )
																			


																			  (str, i)
																				 x = (str, i, delim_chars)
																				 s = str:(i, x - )
																				 n = (s)
																				  n 
																					(str, i,  .. s .. )
																				
																				(i)
																				 n, x
																			


																			  (str, i)
																				 x = (str, i, delim_chars)
																				 word = str:(i, x - )
																				  literals[word] 
																					(str, i,  .. word .. )
																				
																				(i)
																				 literal_map[word], x
																			


																			  (str, i)
																				 res = {}
																				 n = 
																				i = i + 
																				  
																					 x
																					i = (str, i, space_chars, )
																					
																					 str:(i, i) ==  
																						i = i + 
																						
																					
																					
																					x, i = (str, i)
																					res[n] = x
																					n = n + 
																					
																					i = (str, i, space_chars, )
																					 chr = str:(i, i)
																					i = i + 
																					(i)
																					 chr ==    
																					 chr ~=   (str, i, ) 
																				
																				 res, i
																			


																			  (str, i)
																				 res = {}
																				i = i + 
																				  
																					 key, val
																					i = (str, i, space_chars, )
																					
																					 str:(i, i) ==  
																						i = i + 
																						
																					
																					
																					 str:(i, i) ~=  
																						(str, i, )
																					
																					key, i = (str, i)
																					
																					i = (str, i, space_chars, )
																					 str:(i, i) ~=  
																						(str, i, )
																					
																					i = (str, i + , space_chars, )
																					
																					val, i = (str, i)
																					
																					res[key] = val
																					
																					i = (str, i, space_chars, )
																					 chr = str:(i, i)
																					i = i + 
																					
																					(i)
																					 chr ==    
																					 chr ~=   (str, i, ) 
																				
																				 res, i
																			


																			 char_func_map = {
																				[  ] = parse_string,
																				[  ] = parse_number,
																				[  ] = parse_number,
																				[  ] = parse_number,
																				[  ] = parse_number,
																				[  ] = parse_number,
																				[  ] = parse_number,
																				[  ] = parse_number,
																				[  ] = parse_number,
																				[  ] = parse_number,
																				[  ] = parse_number,
																				[  ] = parse_number,
																				[  ] = parse_literal,
																				[  ] = parse_literal,
																				[  ] = parse_literal,
																				[  ] = parse_array,
																				[  ] = parse_object,
																			}


																			parse = (str, idx)
																				 chr = str:(idx, idx)
																				 f = char_func_map[chr]
																				 f 
																					 (str, idx)
																				
																				(str, idx,  .. chr .. )
																			


																			 json.(str)
																				t = ()
																				currentstr = str
																				lasti = 
																				 (str) ~=  
																					( .. (str))
																				
																				 res, idx = (str, (str, , space_chars, ))
																				idx = (str, idx, space_chars, )
																				 idx <= #str 
																					(str, idx, )
																				
																				 res
																			


																			 json
	)()





  (t)
	 .(t[], t[], t[], t[], t[], t[], t[], t[], t[], t[], t[], t[])


  (t)
	 .(t[], t[], t[])


  (t)
	 .(t[], t[])

 RandomString 
 RoundNumber 
 Vector3ToTable 
 TableToVector3 
 CFrameToTable 
 TableToCFrame 
 RoundVector3 
 RoundCFrame 
 FindListIndex 
 WaitForInput 

	RandomString = ()
		 str = 
		 _ = ,(,) 
			  = (,)
			  ==  
				str = str..string.((,)) 
			  ==  
				str = str..string.((,)) 
			  ==  
				str = str..string.((,)) 
			
		
		 str
	
	RoundNumber = (Number,Digits)
		 Mult = ^((Digits)  ,)
		 (Number*Mult+)/Mult
	
	Vector3ToTable = (V3)
		 {V3.X,V3.Y,V3.Z}
	
	TableToVector3 = (Table)
		 .((Table))
	
	Vector2ToTable = (V2)
		 {V2.X,V2.Y}
	
	TableToVector2 = (Table)
		 .((Table))
	
	CFrameToTable = (CF)
		 {CF:()}
	
	TableToCFrame = (Table)
		 .((Table))
	
	RoundTable = (Table,Digits)
		 RoundedTable = {}
		 Index,Number  (Table) 
			RoundedTable[Index] = (Number,Digits)
		
		 RoundedTable
	
	FindListIndex = (Table,Search)
		 Index,Value  (Table) 
			 Value == Search 
				 Index
			
		
	
	WaitForInput = ()
		 KeyPressed = .()
		 InputBeganConnection
		InputBeganConnection = UserInputService.InputBegan:((Input)
			 Input.UserInputType == .UserInputType.Keyboard 
				RunService.RenderStepped:()
				KeyPressed:()
			
		)
		KeyPressed.Event:()
		InputBeganConnection:()
		KeyPressed:()
	



 InsertService = :()

 ReGui = (:())()
 PrefabsId =  .. ReGui.PrefabsId


ReGui:({
	Prefabs = InsertService:(PrefabsId)
})
ReGui:(, {
	Base = {
		Value = ,
		Placeholder = ,
		Label = ,
		Callback = EmptyFunction,
		MultiLine = ,
		NoAutoTag = ,
		Disabled = 
	},
	Create = (Canvas, Config: InputText): InputText
		
		 MultiLine = Config.MultiLine
		 Placeholder = Config.Placeholder
		 Label = Config.Label
		 Disabled = Config.Disabled
		 Value = Config.Value

		
		 Object = ReGui:(, Config)
		 Frame = Object.Frame
		 TextBox = Frame.Input

		 Class = ReGui:(Config, Object)

		Canvas:({
			Parent = Object,
			Text = Label,
			AutomaticSize = .AutomaticSize.X,
			Size = .(, ),
			Position = .(, ),
			LayoutOrder = 
		})

		ReGui:(TextBox, {
			PlaceholderText = Placeholder,
			MultiLine = MultiLine
		})

		  (...)
			 Func = Config.Callback
			(Class, ...)
		

		 Config:(Value: ?)
			TextBox.Text = (Value)
			self.Value = Value
			 self
		

		 Config:(Disabled: boolean)
			self.Disabled = Disabled
			Object.Interactable =  Disabled
			Canvas:({
				[Label] = Disabled    
			}, )
			 self
		

		 Config:()
			TextBox.Text = 
			 self
		

		  ()
			 Value = TextBox.Text
			Config.Value = Value
			(Value)
		

		
		TextBox.FocusLost:((enter, inputObject)
            ()
        )

		
		Config:(Disabled)
		Config:(Value)

		Canvas:({
			[TextBox] = 
		})

		 Class, Object
	,
})
 Window = ReGui:({
	Title = ..Version,
	Size = .(, , , ),
	
	
	NoScroll = 
})


 ConsoleWindow = ReGui:({
    Title = ,
    Size = .(, , , ),
    
    
    NoScroll = 
})
 console = ConsoleWindow:({
    Enabled = ,
    ReadOnly = ,
})
 ConsoleInput = ConsoleWindow:({
    Label = ,
})
ConsoleWindow:()



 menubar = Window:()
 Menu = menubar:({
    Text = 
})
 CreateFile = Menu:({
    Text = ,
    Callback = ()
         popup = Window:({
            Title = 
        })
        popup:({
            Text = ,
            Placeholder = ,
            Callback = (_,name)
                 #name >  
                    (FolderPath....name.., )
                    ReplayTable = {}
                    ReplayPath = FolderPath....name..
                
            
        })
        popup:({
            Text = ,
            Callback = ()
                popup:()
            
        })
    
})
 SaveToFileButton = Menu:({
    Text = ,
    Callback = ()
	    ()
     
})
 LoadFileButton = Menu:({
    Text = ,
    Callback = ()
         popup = Window:({
            Title = 
        })
        popup:({
            Text = ,
            Placeholder = ,
            GetItems = ()  (FolderPath) ,
            Callback = (_,path)
                (path)
                ReplayPath = path
                ReplayTable = #() >   (())  {}
            
        })
        popup:({
            Text = ,
            Callback = ()
                popup:()
            
        })
     
})
 DeleteFileButton = Menu:({
    Text = ,
    Callback = ()
         popup = Window:({
            Title = 
        })
         filepath = popup:({
            Text = ,
            Placeholder = ,
            GetItems = ()  (FolderPath) ,
        })
        popup:({
            Text = ,
            Callback = ()
                popup:()
                 #filepath.Value >  
                    (filepath.Value)
                
            
        })
     
})
 ConsoleButton = Menu:({
    Text = ,
    Callback = ()
        ConsoleWindow:()
    
})



 InfoHeader = Window:({
    Title = 
})
RecordedFramesLabel = InfoHeader:({
    Text = 
})
 PressedKeysLabel = InfoHeader:({
    Text = 
})
 WritingPressedKeysLabel = InfoHeader:({
    Text = 
})
 ColorCodeFrame = InfoHeader:({
    Text = 
})
 CurrentFile = InfoHeader:({
    Text = 
})
.(()
     .()  (ReplayPath) == 
    (ReplayPath)
     oldfilename = ReplayPath
    CurrentFile.Text = ..string.(ReplayPath, )[]
     .() 
         ReplayPath ~= oldfilename 
            CurrentFile.Text = ..string.(ReplayPath, )[]
            oldfilename = ReplayPath
        
    
)
 ConnectedLabel = InfoHeader:({
    Text = ,
    TextColor3 = .(,,)
})
 CurrentPlaceIdButton; CurrentPlaceIdButton = InfoHeader:({
    Text = ..(PlaceId),
    Callback = ()
         .(CurrentPlaceIdButton.Text, ) 
             OldText = CurrentPlaceIdButton.Text
            ((PlaceId))
            CurrentPlaceIdButton.Text = 
            ()
            CurrentPlaceIdButton.Text = OldText
        
    
})

 ControlsHeader = Window:({
    Title = 
})
 Frozentoidlerow = ControlsHeader:()
Frozentoidlerow:({
    Text = ,
    Callback = ()
        ()
    
})
 Frozenkeybind = Frozentoidlerow:({
    Label = ,
    Value = .KeyCode.M,
})
 IgnoreGameProcessedButton_MouseButton1Click
 IgnoreGameProcessedButton = ControlsHeader:({
    Label = ,
    Callback = ()
        IgnoreGameProcessed =  IgnoreGameProcessed
    
})
 movecameraonfroze = ControlsHeader:({
    Label = 
})
 ReadButtonrow = ControlsHeader:()
ReadButtonrow:({
    Text = ,
    Callback = ()
        ()
    
})
 Readkeybind = ReadButtonrow:({
    Label = ,
    Value = .KeyCode.Z,
})
 Abortrow = ControlsHeader:()
 StopReading
Abortrow:({
    Text = ,
    Callback = ()
        ()
    
})
 Abortkeybind = Abortrow:({
    Label = ,
    Value = .KeyCode.L,
})
 Hideuikeybind = ControlsHeader:({
    Label = ,
    Value = .KeyCode.U
})
 Recordkeybind = ControlsHeader:({
    Label = ,
    Value = .KeyCode.E
})
 Goforwardkeybind = ControlsHeader:({
    Label = ,
    Value = .KeyCode.H
})
 Gobackwardskeybind = ControlsHeader:({
    Label = ,
    Value = .KeyCode.R
})
 Frameadvanceforwardkeybind = ControlsHeader:({
    Label = ,
    Value = .KeyCode.T
})
 Frameadvancebackwardskeybind = ControlsHeader:({
    Label = ,
    Value = .KeyCode.G
})
 Savekeybind = ControlsHeader:({
    Label = ,
    Value = .KeyCode.P
})





 SetColorCodeFrame 
 GetColorCodeFrame 

	ConsoleMessage = (...)
        ()
        console:(...)
	
	
	()
	SetColorCodeFrame = (Name)
		ColorCodeFrame.TextColor3 = ColorCodes[Name]  ColorCodes.None
		ColorCodeFrame.Text = ..(ColorCodes[Name]  Name  )
	
	GetColorCodeFrame = ()
		 .(ColorCodeFrame.Text, , #ColorCodeFrame.Text) 
	


 
	 
		
		
		 Players = :()
		 OldNameCall = 

		
		 plr = .Players.LocalPlayer
		OldNameCall = (, , (Self, ...)
			 NameCallMethod = ()

			  ()  Self == plr  NameCallMethod ==  
				 ().SendNotifications ==  
					:():(, {
						Title = ,
						Text = (({...})[]),
						Icon = ,
						Duration = ,
					})
				
				
				 
			
			
			 (Self, ...)
		)
	
	(() 
		.ReplicatedStorage.Remotes.Send:()
	)
	(() 
		 sendremote = .ReplicatedStorage.DefaultChatSystemChatEvents.ChannelNameColorUpdated
		 oldspawn
		oldspawn = (().spawn, (...)
			  ()  ((()) ==   (()) == ) 
				 (()
					
				)
			
			 (...)
		)
		sendremote:()
	)

	

 g = getinfo  debug.getinfo
 d = 
 h = {}

 x, y

()

 i, v  () 
     (v) ==  
         a = (v, )
         b = (v, )
    
         (a) ==    x 
            x = a
            
             o; o = (x, (c, f, n)
                 c ~=  
                     d 
                        ()
                    
                
                
                 
            )

            .(h, x)
        

         (v, )  (v, )  (b) ==    y 
            y = b
             o; o = (y, (f)
                 d 
                    ()
                
            )

            .(h, y)
        
    


 o; o = (().debug.info, ((...)
     a, f = ...

     x  a == x 
         d 
            ()
        

         .(.())
    
    
     (...)
))

()




 StopAllAnimations 
 Reanimate 

 GetAnimationFunctionFromId 
 onDied 
 onRunning 
 onJumping 
 onClimbing 
 onGettingUp 
 onFreeFall 
 onFallingDown 
 onSeated 
 onPlatformStanding 
 onSwimming 

 PlayAnimation 
 setAnimationSpeed 

	StopAllAnimations = ()
		 _,v  (Humanoid:())  
			v:()
		
	
	GetAnimationFunctionFromId = (Id)
		 ({
			[] = OnDied;
			[] = onRunning;
			[] = onJumping;
			[] = onClimbing;
			[] = onGettingUp;
			[] = onFreeFall;
			[] = onFallingDown;
			[] = onSeated;
			[] = onPlatformStanding;
			[] = onSwimming;
		})[Id]
	
	Reanimate = (Character)
		 Character:(,) 
			 _, Animate  (Character:()) 
				 Animate:()  Animate.Name ==  
					 _,Connection  ((Animate.Changed)) 
						Connection:()
					
					 BypassAntiExploit 
						Animate.Disabled = 
						 setparentinternal 
							(Animate, .Lighting)
						
							()
						
					
						Animate:()
					
				
			
		
			()
			()
		
		()
		 
								 Figure = Character
								 Torso = Figure:()
								 RightShoulder = Torso:()
								 LeftShoulder = Torso:()
								 RightHip = Torso:()
								 LeftHip = Torso:()
								 Neck = Torso:()
								 Humanoid = Figure:()

								 currentAnim = 
								 currentAnimInstance = 
								 currentAnimTrack = 
								 currentAnimKeyframeHandler = 
								
								 animTable = {}
								 animNames = { 
									idle = 	{	
												{ id = , weight =  },
												{ id = , weight =  }
											},
									walk = 	{ 	
												{ id = , weight =  } 
											}, 
									run = 	{
												{ id = , weight =  } 
											}, 
									jump = 	{
												{ id = , weight =  } 
											}, 
									fall = 	{
												{ id = , weight =  } 
											}, 
									climb = {
												{ id = , weight =  } 
											}, 
									sit = 	{
												{ id = , weight =  } 
											},	
									toolnone = {
												{ id = , weight =  } 
											},
									toolslash = {
												{ id = , weight =  } 
								
											},
									toollunge = {
												{ id = , weight =  } 
											},
									wave = {
												{ id = , weight =  } 
											},
									point = {
												{ id = , weight =  } 
											},
									dance1 = {
												{ id = , weight =  }, 
												{ id = , weight =  }, 
												{ id = , weight =  } 
											},
									dance2 = {
												{ id = , weight =  }, 
												{ id = , weight =  }, 
												{ id = , weight =  } 
											},
									dance3 = {
												{ id = , weight =  }, 
												{ id = , weight =  }, 
												{ id = , weight =  } 
											},
									laugh = {
												{ id = , weight =  } 
											},
									cheer = {
												{ id = , weight =  } 
											},
								}
								 dances = {, , }

								
								 emoteNames = { wave = , point = , dance1 = , dance2 = , dance3 = , laugh = , cheer = }

								 (name, fileList)
									 (animTable[name] ~= ) 
										 _, connection  (animTable[name].connections) 
											connection:()
										
									
									animTable[name] = {}
									animTable[name].count = 
									animTable[name].totalWeight = 	
									animTable[name].connections = {}

									

									
									 (animTable[name].count <= ) 
										 idx, anim  (fileList) 
											animTable[name][idx] = {}
											animTable[name][idx].anim = .()
											animTable[name][idx].anim.Name = name
											animTable[name][idx].anim.AnimationId = anim.id
											animTable[name][idx].weight = anim.weight
											animTable[name].count = animTable[name].count + 
											animTable[name].totalWeight = animTable[name].totalWeight + anim.weight
								
										
									
								

								

								
								
								 animator = Humanoid  Humanoid:()  
								 animator 
									 animTracks = animator:()
									 i,track  (animTracks) 
										track:()
										track:()
									
								


								 name, fileList  (animNames)  
									(name, fileList)
									

								

								
								 toolAnim = 
								 toolAnimTime = 

								 jumpAnimTime = 
								 jumpAnimDuration = 

								 toolTransitionTime = 
								 fallTransitionTime = 
								 jumpMaxLimbVelocity = 

								

								 ()
									 oldAnim = currentAnim

									
									 (emoteNames[oldAnim] ~=   emoteNames[oldAnim] == ) 
										oldAnim = 
									

									currentAnim = 
									currentAnimInstance = 
									 (currentAnimKeyframeHandler ~= ) 
										currentAnimKeyframeHandler:()
									

									 (currentAnimTrack ~= ) 
										currentAnimTrack:()
										currentAnimTrack:()
										currentAnimTrack = 
									
									 oldAnim
								

								setAnimationSpeed = (speed)
									 speed ~= currentAnimSpeed 
										currentAnimSpeed = speed
										currentAnimTrack:(currentAnimSpeed)
									
								

								 (frameName)
									 (frameName == ) 

										 repeatAnim = currentAnim
										
										 (emoteNames[repeatAnim] ~=   emoteNames[repeatAnim] == ) 
											repeatAnim = 
										
										
										 animSpeed = currentAnimSpeed
										(repeatAnim, , Humanoid)
										(animSpeed)
									
								

								
								playAnimation = (animName, transitionTime, humanoid, bypassAnimateDisabled) 
									
									(()
									 AnimateDisabled   bypassAnimateDisabled 
										
									
									
									.(AnimationQueue,{animName,transitionTime})
									
									 roll = .(, animTable[animName].totalWeight) 
									 origRoll = roll
									 idx = 
									 (roll > animTable[animName][idx].weight) 
										roll = roll - animTable[animName][idx].weight
										idx = idx + 
									
								
									 anim = animTable[animName][idx].anim

									
									 (anim ~= currentAnimInstance) 
										
										 (currentAnimTrack ~= ) 
											currentAnimTrack:(transitionTime)
											currentAnimTrack:()
										

										currentAnimSpeed = 
									
										
										currentAnimTrack = humanoid:(anim)
										currentAnimTrack.Priority = .AnimationPriority.Core
										 
										
										currentAnimTrack:(transitionTime)
										currentAnim = animName
										currentAnimInstance = anim

										
										 (currentAnimKeyframeHandler ~= ) 
											currentAnimKeyframeHandler:()
										
										currentAnimKeyframeHandler = currentAnimTrack.KeyframeReached:(keyFrameReachedFunc)
										
									
								)

								

								
								

								 toolAnimName = 
								 toolAnimTrack = 
								 toolAnimInstance = 
								 currentToolAnimKeyframeHandler = 

								 (frameName)
									 (frameName == ) 
								
										(toolAnimName, , Humanoid)
									
								


								 (animName, transitionTime, humanoid, priority)	 
										
										 roll = .(, animTable[animName].totalWeight) 
										 origRoll = roll
										 idx = 
										 (roll > animTable[animName][idx].weight) 
											roll = roll - animTable[animName][idx].weight
											idx = idx + 
										
								
										 anim = animTable[animName][idx].anim

										 (toolAnimInstance ~= anim) 
											
											 (toolAnimTrack ~= ) 
												toolAnimTrack:()
												toolAnimTrack:()
												transitionTime = 
											
													
											
											toolAnimTrack = humanoid:(anim)
											 priority 
												toolAnimTrack.Priority = priority
											
											 
											
											toolAnimTrack:(transitionTime)
											toolAnimName = animName
											toolAnimInstance = anim

											currentToolAnimKeyframeHandler = toolAnimTrack.KeyframeReached:(toolKeyFrameReachedFunc)
										
								

								 ()
									 oldAnim = toolAnimName

									 (currentToolAnimKeyframeHandler ~= ) 
										currentToolAnimKeyframeHandler:()
									

									toolAnimName = 
									toolAnimInstance = 
									 (toolAnimTrack ~= ) 
										toolAnimTrack:()
										toolAnimTrack:()
										toolAnimTrack = 
									


									 oldAnim
								

								
								


								onRunning = (speed)
									 speed >  
										(, , Humanoid)
										 currentAnimInstance  currentAnimInstance.AnimationId ==  
											(speed / )
										
										pose = 
									
										 emoteNames[currentAnim] ==  
											(, , Humanoid)
											pose = 
										
									
								

								onDied = ()
									pose = 
								

								onJumping = ()
									(, , Humanoid)
									jumpAnimTime = jumpAnimDuration
									pose = 
								

								onClimbing = (speed)
									(, , Humanoid)
									(speed / )
									pose = 
								

								onGettingUp = ()
									pose = 
								

								onFreeFall = ()
									 (jumpAnimTime <= ) 
										(, fallTransitionTime, Humanoid)
									
									pose = 
								

								onFallingDown = ()
									pose = 
								

								onSeated = ()
									pose = 
								

								onPlatformStanding = ()
									pose = 
								

								onSwimming = (speed)
									 speed >  
										pose = 
									
										pose = 
									
								

								 ()	
									 _, kid  (Figure:()) 
										 kid.className ==    kid 
									
									 
								

								 (tool)
									 _, c  (tool:()) 
										 c.Name ==   c.className ==  
											 c
										
									
									 
								

								 ()
									
									 (toolAnim == ) 
										(, toolTransitionTime, Humanoid, .AnimationPriority.Idle)
										
									

									 (toolAnim == ) 
										(, , Humanoid, .AnimationPriority.Action)
										
									

									 (toolAnim == ) 
										(, , Humanoid, .AnimationPriority.Action)
										
									
								

								 ()
									RightShoulder.MaxVelocity = 
									LeftShoulder.MaxVelocity = 
									RightShoulder:( /)
									LeftShoulder:(- /)
									RightHip:( /)
									LeftHip:(- /)
								

								 lastTick = 

								 (time)
									 AnimateDisabled 
										
									
									
									 amplitude = 
									 frequency = 
									 deltaTime = time - lastTick
									lastTick = time

									 climbFudge = 
									 setAngles = 

									 (jumpAnimTime > ) 
										jumpAnimTime = jumpAnimTime - deltaTime
									

									 (pose ==   jumpAnimTime <= ) 
										(, fallTransitionTime, Humanoid)
									 (pose == ) 
										(, , Humanoid)
										
									 (pose == ) 
										(, , Humanoid)
									 (pose ==   pose ==   pose ==   pose ==   pose == ) 
								
										()
										amplitude = 
										frequency = 
										setAngles = 
									

									 (setAngles) 
										 desiredAngle = amplitude * .(time * frequency)

										RightShoulder:(desiredAngle + climbFudge)
										LeftShoulder:(desiredAngle - climbFudge)
										RightHip:(-desiredAngle)
										LeftHip:(-desiredAngle)
									

									
									 tool = ()
									 tool  tool:() 
									
										 animStringValueObject = (tool)

										 animStringValueObject 
											toolAnim = animStringValueObject.Value
											
											animStringValueObject.Parent = 
											toolAnimTime = time + 
										

										 time > toolAnimTime 
											toolAnimTime = 
											toolAnim = 
										

										()		
									
										()
										toolAnim = 
										toolAnimInstance = 
										toolAnimTime = 
									
								

								
								Humanoid.Died:((...)
									 AnimateDisabled 
										
									
									
									(...)
								)
								Humanoid.Running:((Speed)
									 AnimateDisabled 
										
									
									
									
									(Speed)
								)
								Humanoid.Jumping:(onJumping)
								Humanoid.Climbing:((Speed)
									 AnimateDisabled 
										
									
									
									
									(Speed)
								)
								Humanoid.GettingUp:((...)
									 AnimateDisabled 
										
									
									
									(...)
								)
								Humanoid.FreeFalling:((...)
									 AnimateDisabled 
										
									
									
									(...)
								)
								Humanoid.FallingDown:((...)
									 AnimateDisabled 
										
									
									
									(...)
								)
								Humanoid.Seated:((...)
									 AnimateDisabled 
										
									
									
									(...)
								)
								Humanoid.PlatformStanding:((...)
									 AnimateDisabled 
										
									
									
									(...)
								)
								Humanoid.Swimming:((...)
									 AnimateDisabled 
										
									
									
									(...)
								)

								
								:().LocalPlayer.Chatted:((msg)
									 emote = 
									 msg ==  
										emote = dances[.(, #dances)]
									 (.(msg, , ) == ) 
										emote = .(msg, )
									 (.(msg, , ) == ) 
										emote = .(msg, )
									
									
									 (pose ==   emoteNames[emote] ~= ) 
										(emote, , Humanoid)
									

								)


								

								
								(, , Humanoid)
								pose = 

								(()
									 Figure.Parent ~=  
										 _, time = ()
										(time)
									
								)
		
	



 GetZoom 
 SetZoom 

 GetShiftLockEnabled 
 SetShiftLockEnabled 

 SetCameraCFrame 

 BlockInputs 
 UnlockInputs 

 SetCursorIcon 
 SetCursorSize 
 SetCursorOffset ffset) -> nil
local SetCursor -- SetCursorIcon(CursorName) -> nil
do
	-- Load mouse lock action
	VirtualInputManager:SendKeyEvent(true, 304, false, workspace)
	wait()
	VirtualInputManager:SendKeyEvent(true, 304, false, workspace)
	wait()
	
	local ZoomControllers = {}
	
	do -- Get ZoomControllers from getgc
		for _,Table in pairs(getgc(true)) do
			if type(Table) == "table" then
				pcall(function()
					if type(Table.SetCameraToSubjectDistance) == "function"
					and type(Table.GetCameraToSubjectDistance) == "function"
					and Table.FIRST_PERSON_DISTANCE_THRESHOLD
					and Table.lastCameraTransform then
						table.insert(ZoomControllers,Table)
					end
				end)
			end
		end
		ConsoleMessage(tostring(#ZoomControllers).." ZoomController"..(#ZoomControllers == 1 and "" or "s"))
	end
	GetZoom = function()
		for _,ZoomController in pairs(ZoomControllers) do
			local Zoom = ZoomController:GetCameraToSubjectDistance()
			if Zoom and Zoom ~= 12.5 then -- Sometimes a ZoomController returns 12.5 so check if theres any other zoom levels before picking 12.5
				return Zoom
			end
		end
		return 12.5
	end
	SetZoom = function(Zoom)
		for _,ZoomController in pairs(ZoomControllers) do
			pcall(function() -- Sometimes a ZoomController errors and breaks the whole script
				ZoomController:SetCameraToSubjectDistance(Zoom)
			end)
		end
	end
	
	-- from original replayability
	-- from original replayability (optimized)
GetShiftLockEnabled = function()
	return ShiftLockEnabled
end

-- Cache the mouse lock controller to avoid searching every time
local cachedMouseLockController = nil
local function getMouseLockController()
	if cachedMouseLockController and cachedMouseLockController.DoMouseLockSwitch then
		return cachedMouseLockController
	end
	
	-- Only search if cache is invalid
	for _, obj in getgc(true) do 
		if type(obj) == "table" and rawget(obj, "activeMouseLockController") then 
			cachedMouseLockController = obj.activeMouseLockController
			return cachedMouseLockController
		end
	end
	return nil
end

function shiftLock(active)
	local mouseLockController = getMouseLockController()
	if not mouseLockController then return end
	
	local isLocked = mouseLockController:GetIsMouseLocked()
	if (active and not isLocked) or (not active and isLocked) then
		mouseLockController:DoMouseLockSwitch("MouseLockSwitchAction", Enum.UserInputState.Begin, game)
	end
end

SetShiftLockEnabled = function(Enabled)
	if ShiftLockEnabled ~= Enabled then
		ShiftLockEnabled = Enabled
		if Enabled then
			SetCursor("MouseLockedCursor")
		else
			SetCursor("ArrowFarCursor")
		end
		shiftLock(Enabled)
	end
end
	
	SetCameraCFrame = function(NewCFrame)
		CameraCFrame = NewCFrame
		workspace.CurrentCamera.CFrame = NewCFrame
	end
	
	local BlockGui = Instance.new("ScreenGui")
	local BlockFrame = Instance.new("TextButton")
	BlockFrame.Text = ""
	BlockFrame.BackgroundTransparency = 1
	BlockFrame.Size = UDim2.fromScale(1,1)
	BlockFrame.Selectable = false
	BlockFrame.Selected = false
	BlockFrame.Parent = BlockGui
	BlockGui.Enabled = false
	BlockGui.Parent = GUIParent
	BlockInputs = function()
		BlockGui.Enabled = true
	end
	UnblockInputs = function()
		BlockGui.Enabled = false
	end
	
	local CursorHolder = Instance.new("ScreenGui")
	Cursor.BackgroundTransparency = 1
	Cursor.ZIndex = 9999
	Cursor.Parent = CursorHolder
	CursorHolder.ZIndexBehavior = Enum.ZIndexBehavior.Sibling
	CursorHolder.Parent = gethui()
    CursorHolder.DisplayOrder = 9999
	Resolution = CursorHolder.AbsoluteSize
	SetCursor = function(CursorName)
		local CursorData = Cursors[CursorName]
		CursorIcon = CursorData.Icon
		CursorSize = CursorData.Size
		CursorOffset = CursorData.Offset
	end
end

-- AHK Functions
local IsInstalled -- IsInstalled() -> bool
local SendSignal -- SendSignal(Signal) -> nil
do
	IsInstalled = function()
		return isfolder(AHKConnectionFolderPath)
	end
	SendSignal = function(Signal)
		if IsInstalled() then
			writefile(AHKConnectionRequestPath,Signal)
		else
			ConsoleMessage("AHK folder not found")
		end
	end
end



local Freeze -- Defined earlier so it can be used in replay functions


-- Replay Functions
local ReplayEncode -- ReplayEncode(Table) -> string
local RecordReplay -- RecordReplay() -> nil [Event]
local StartRecording -- StartRecording() -> nil
local StopRecording -- StopRecording() -> nil
local SaveRecording -- SaveRecording() -> nil
local DiscardRecording -- DiscardRecording() -> nil

local StartReading -- StartReading() -> nil

local GetCheckpoint -- GetCheckpoint(CheckpointNumber?) -> number
local SetCheckpoint -- SetCheckpoint(FrameIndex?) -> nil

local GotoFrame -- GotoFrame(Index) -> nil
do
	GetReplayFile = function()
		if not isfolder(string.split(FolderPath,"/")[1]) then
			makefolder(string.split(FolderPath,"/")[1])
		end
		if not isfolder(FolderPath) then
			makefolder(FolderPath)
		end
		if not isfile(ReplayPath) then
			writefile(ReplayPath,ReplayFileBeginning)
			return ReplayFileBeginning
		end
		return readfile(ReplayPath)
	end

	ReplayEncode = function(Table)
		ConsoleMessage("Encoding "..tostring(#Table).." frames")
		local StartTick = tick()
		local Encoded = json.encode(Table)
		ConsoleMessage("Done encoding in",RoundNumber(tick()-StartTick,2),"seconds")
		return ReplayFileBeginning..Encoded..ReplayFileEnding
	end
	ReplayDecode = function(String)
		if String == ReplayFileBeginning or String == ReplayFileBeginning..ReplayFileEnding then
			ConsoleMessage("Nothing to read")
			return
		end
		ConsoleMessage("Decoding "..tostring(#String).." characters")
		local StartTick = tick()
		local Decoded = json.decode(String)
		ConsoleMessage("Done decoding in",RoundNumber(tick()-StartTick,2),"seconds")
		return Decoded.Replay
	end
	
	
	RecordReplay = function()
		ConsoleMessage("Waiting for input")
		if Writing then
			ConsoleMessage("Recording stopped")
			StopRecording()
			return
		end
		SetColorCodeFrame("WaitingForInput")
		WaitForInput()
		StartRecording()
		ConsoleMessage("Recording started")
	end
	StartRecording = function()
		if not Reading then
			SetColorCodeFrame("Recording")
			Writing = true
		end
	end
	StopRecording = function()
		if not Reading then
			Writing = false
		end
	end
	
	SaveToFile = function()
		local ReplayEncoded = ReplayEncode(ReplayTable)
		writefile(ReplayPath,ReplayEncoded)
	end
	
	SaveRecording = function()
		if #RecordingTable > 0 then
			local old = #ReplayTable
			for _,Frame in pairs(RecordingTable) do
				table.insert(ReplayTable,Frame)
			end
			RecordingTable = {}
			ConsoleMessage("Saved")
		end
	end
	DiscardRecording = function()
		if #RecordingTable > 0 then
			RecordingTable = {}
			ConsoleMessage("Discarded")
		end
	end
	StartReading = function()
		if not Reading then
			SaveToFile()
			ReplayTable = ReplayDecode(GetReplayFile()) -- Decode replay from file
			if ReplayTable then
				-- Decoding successful
				Freeze(false) -- Unfreeze
				AnimateDisabled = true -- Disable fake animate script
				Workspace.Gravity = 0
				ReplayTableIndex = 1
				BlockInputs() -- Disable scrolling and clicks
				Reading = true
				SetColorCodeFrame("Reading")
				ConsoleMessage("Reading started")
				ConsoleMessage("Length: "..RoundNumber(tostring(#ReplayTable/60)).." seconds")
			else
				-- Decoding failed
				ReplayTable = {}
				SetColorCodeFrame("Idle")
			end
		else
			ConsoleMessage("You are already reading")
		end
	end
	StopReading = function()
		if Reading then
			UnblockInputs() -- Enable scrolling and clicks
			Character.Head.CanCollide = true -- Fix character collisions
			Character.Torso.CanCollide = true -- Fix character collisions
			Character.HumanoidRootPart.CanCollide = true -- Fix character collisions
			AnimateDisabled = false -- Enable fake animate script
			Reading = false
			Character.Humanoid.JumpPower = DefaultJumpPower
			Character.Humanoid.WalkSpeed = DefaultWalkSpeed
			Workspace.Gravity = DefaultGravity
			SetColorCodeFrame("Idle")
			ConsoleMessage("Reading stopped")
		else
			ConsoleMessage("You are not reading")
		end
	end
end

-- Tasability functions
--local Freeze -- Freeze(NewFrozen) -> nil
do
	Freeze = function(NewFrozen,DoNotRecord)
		if Frozen ~= NewFrozen and not Reading then
			SeekDirection = 0
			if NewFrozen then
				Frozen = true
				StopRecording()
				SaveRecording()
				FreezeFrame = #ReplayTable
				SetColorCodeFrame("Frozen")
			else
				
				--ConsoleMessage(#ReplayTable)
				--ConsoleMessage(FreezeFrame)
				
				if DoNotRecord then
					Frozen = false
					SetColorCodeFrame("Idle")
				else
					for Index = #ReplayTable,FreezeFrame,-1 do
						--ConsoleMessage(Index)
						ReplayTable[Index] = nil
					end
					Frozen = false
					StartRecording()
					SetColorCodeFrame("Recording")
				end
			end
		end
	end
end
-- Commands
local Commands = {}
do
	Commands["help"] = function(Args)
		if Args == "help" then
			ConsoleMessage("help <command>: Shows a list of all commands, or a specific command")
		else
			local Command = Args[1]
			if Command then
				Command = string.lower(Command)
				if Commands[Command] then
					Commands[Command]("help")
				else
					ConsoleMessage("Command", Command, "was not found")
				end
			else
				for _,Command in pairs(Commands) do
					Command("help")
				end
			end
		end
	end
	Commands["erase"] = function(Args)
		if Args == "help" then
			ConsoleMessage("erase: Erases all data from the folder",PlaceId)
		else
			writefile(ReplayPath,ReplayFileBeginning)
			ReplayTable = {}
			return ReplayPath.." has been erased"
		end
	end
	Commands["setsdm"] = function(Args)
		if Args == "help" then
			ConsoleMessage("setsdm <number SeekDirectionMultiplier>: Sets speed multiplier when using R and T while frozen")
		else
			local Number = tonumber(Args[1]) or 1
			if Number then
				local OldValue = SeekDirectionMultiplier
				SeekDirectionMultiplier = Number
				return "SeekDirectionMultiplier has been set from "..tostring(OldValue).." to "..tostring(Number)
			end
		end
	end
	Commands["rejoin"] = function(Args)
		if Args == "help" then
			ConsoleMessage("rejoin <bool SaveReplay>: Sets one of the configs at the top of the script (PlaybackInputs, etc)")
		else
			local SaveReplay = Args[1] and string.lower(Args[1])
			ConsoleMessage("Saving...")
			if SaveReplay == "true" or SaveReplay == "yes" or SaveReplay == "1" or SaveReplay == "save" then
				SaveToFile()
			end
			ConsoleMessage("Rejoining...")
			if #game.Players:GetPlayers() <= 1 then
				game.Players.LocalPlayer:Kick("\nRejoining...")
				wait()
				game:GetService("TeleportService"):Teleport(game.PlaceId, game.Players.LocalPlayer)
			else
				game:GetService("TeleportService"):TeleportToPlaceInstance(game.PlaceId, game.JobId, game.Players.LocalPlayer)
			end
			return "Sent request to rejoin"
		end
	end
	Commands["invite"] = function(Args)
		if Args == "help" then
			ConsoleMessage("invite: Invites you to Tasability Discord")
		else
			request({
				Url = "http://127.0.0.1:6463/rpc?v=1",
				Method = "POST",
				Headers = {
					["Content-Type"] = "application/json",
					["origin"] = "https://discord.com",
				},
				Body = game:GetService("HttpService"):JSONEncode({
					["args"] = {
						["code"] = "Shyfsc2cJ9",
					},
					["cmd"] = "INVITE_BROWSER",
					["nonce"] = "."
				})
			})
			return "Sent invite (if your exploit blocked it the invite is https://discord.gg/Shyfsc2cJ9)"
		end
	end
end

-- Connection Functions
local StateChanged
local CharacterAdded
local InputBegan
local RenderStepped
local Stepped
local CurrentCamera_Changed
do
	StateChanged = function(_,State)
		table.insert(HumanoidStateQueue,State.Value)
	end
	CharacterAdded = function(NewCharacter)
		Humanoid = NewCharacter:WaitForChild("Humanoid")
		Humanoid.StateChanged:Connect(StateChanged)
		RootPart = NewCharacter:WaitForChild("HumanoidRootPart")
		DefaultJumpPower = Humanoid.JumpPower
		DefaultWalkSpeed = Humanoid.WalkSpeed
		Reanimate(NewCharacter)
		Character = NewCharacter
		Humanoid.Died:Connect(function()
			Dead = true
		end)
		Dead = false
	end
	InputBegan = function(Input,GameProcessed)
		if IgnoreGameProcessed then
			GameProcessed = false
		end
		
		if Input.UserInputType == Enum.UserInputType.MouseButton1 then
			table.insert(InputBeganQueue,"b1")
		elseif Input.UserInputType == Enum.UserInputType.MouseButton2 then
			table.insert(InputBeganQueue,"b2")
		elseif Input.UserInputType == Enum.UserInputType.Keyboard then
			local InputName = string.split(tostring(Input.KeyCode),".")[3]
			if not InputBlacklist[InputName] then
				table.insert(InputBeganQueue,InputName)
			end
		end
		
		if Input.KeyCode == Enum.KeyCode.LeftShift and not Reading and not GameProcessed then
			SetShiftLockEnabled(not ShiftLockEnabled)
		end
		
		if Input.KeyCode == Recordkeybind.Value and not GameProcessed then
			-- Freeze/Unfreeze
			Freeze(not Frozen)
		elseif Input.KeyCode == Gobackwardskeybind.Value and not GameProcessed then
			if not Reading then
				Freeze(true)
				if SeekDirection == 0 then
					SeekDirection = -1*SeekDirectionMultiplier -- Backwards
				end
			end
		elseif Input.KeyCode == Goforwardkeybind.Value and not GameProcessed then
			-- Seek fowards
			if not Reading then
				Freeze(true)
				if SeekDirection == 0 then
					SeekDirection = 1*SeekDirectionMultiplier -- Fowards
				end
			end
		elseif Input.KeyCode == Frameadvancebackwardskeybind.Value and not GameProcessed then
			-- Go 1 frame backwards
			Freeze(true)
			if Frozen and SeekDirection == 0 then
				local NewFreezeFrame = FreezeFrame - 1
				if NewFreezeFrame > 0 and NewFreezeFrame <= #ReplayTable then
					FreezeFrame = NewFreezeFrame
				end
			end
		elseif Input.KeyCode == Frameadvanceforwardkeybind.Value and not GameProcessed then
			-- Go 1 frame fowards
			Freeze(true)
			if Frozen and SeekDirection == 0 then
				local NewFreezeFrame = FreezeFrame + 1
				if NewFreezeFrame > 0 and NewFreezeFrame <= #ReplayTable then
					FreezeFrame = NewFreezeFrame
				end
			end
		elseif Input.KeyCode == Hideuikeybind.Value and not GameProcessed then
			-- Toggle UI
			Window:ToggleVisibility()
		elseif Input.KeyCode == Abortkeybind.Value and not GameProcessed then
			-- Stop reading
			StopReading()
		elseif Input.KeyCode == Savekeybind.Value and not GameProcessed then
			-- Save to file
			SaveToFile()
		elseif Input.KeyCode == Frozenkeybind.Value and not GameProcessed then
			-- Save to file
			IdleButton_MouseButton1Click()
        elseif Input.KeyCode == Readkeybind.Value and not GameProcessed then
            ReadButton_MouseButton1Click()
		end
	end
	InputChanged = function(Input,GameProcessed)
		if Input.UserInputType == Enum.UserInputType.MouseWheel then
			if Input.Position.Z > 0 then
				table.insert(InputBeganQueue,"u")
			else
				table.insert(InputBeganQueue,"d")
			end
		end
	end
	InputEnded = function(Input,GameProcessed)
		if Input.UserInputType == Enum.UserInputType.MouseButton1 then
			table.insert(InputEndedQueue,"b1")
		elseif Input.UserInputType == Enum.UserInputType.MouseButton2 then
			table.insert(InputEndedQueue,"b2")
		elseif Input.UserInputType == Enum.UserInputType.MouseWheel then
			if Input.Position.Z > 0 then
				table.insert(InputEndedQueue,"u")
			else
				table.insert(InputEndedQueue,"d")
			end
		elseif Input.UserInputType == Enum.UserInputType.Keyboard then
			local InputName = string.split(tostring(Input.KeyCode),".")[3]
			table.insert(InputEndedQueue,InputName)
		end
		
		if Input.KeyCode == Gobackwardskeybind.Value then
			-- Stop seeking backwards
			if SeekDirection == -1*SeekDirectionMultiplier then
				SeekDirection = 0
			end
		elseif Input.KeyCode == Goforwardkeybind then
			-- Stop seeking fowards
			if SeekDirection == 1*SeekDirectionMultiplier then
				SeekDirection = 0
			end
		end
	end
	RenderStepped = function(...)
		for _,Function in pairs(RenderSteppedConnections) do
			Function(...)
		end
	end
	Stepped = function(...)
		for _,Function in pairs(SteppedConnections) do
			Function(...)
		end
	end
	ReadButton_MouseButton1Click = function()
		if ReplayStartTime >= 1 then
			for i = ReplayStartTime,1,-1 do
				ConsoleMessage("Reading in "..tostring(i).." seconds")
				wait(1)
			end
		end
		StartReading()
	end
	IdleButton_MouseButton1Click = function()
		if GetColorCodeFrame() == "Frozen" then
			Freeze(false,true)
		end
	end
	CurrentCamera_Changed = function()
		if Reading then
			workspace.CurrentCamera.CFrame = CameraCFrame
		end
	end
	ConsoleInput.Callback = function(self, value)
		local Input = value
		local InputSplit = string.split(Input," ")
		local Command = Commands[string.lower(InputSplit[1])]
		if Command then
			table.remove(InputSplit,1)
			local ReturnMessage = Command(InputSplit)
			if ReturnMessage then
				ConsoleMessage(ReturnMessage)
			end
		else
			ConsoleMessage("Command",InputSplit[1],"was not found")
		end
		self:Clear()
	end
end

-- RenderStepped/Stepped connections
do
	RenderSteppedConnections.UpdateFreezeFrame = function()
		RecordedFramesLabel.Text = "Frames: "..RoundNumber(FreezeFrame,0)
	end
	RenderSteppedConnections.SeekDirectionHandler = function()
		if Frozen then
			local NewFreezeFrame = FreezeFrame + SeekDirection
			if NewFreezeFrame < 1 then
				FreezeFrame = 1
			elseif NewFreezeFrame > #ReplayTable then
				FreezeFrame = #ReplayTable
			else
				FreezeFrame = NewFreezeFrame
			end
		end
	end
	local PressedWriting = {}
	SteppedConnections.UpdateInputPreview = function()
		for _,Input in pairs(InputBeganQueue) do
			if Input == "u" or Input == "d" then
				return
			end
			Pressed[Input] = true
		end
		for _,Input in pairs(InputEndedQueue) do
			Pressed[Input] = nil
		end
		PressedKeysLabel.Text = "Pressed keys: |"
		for Input,_ in pairs(Pressed) do
			PressedKeysLabel.Text = PressedKeysLabel.Text..Input.."|"
		end
		
		-- MOVED TO FREEZE LOOP
		--[[if Writing then
			for _,Input in pairs(InputBeganQueue) do
				if Input == "u" or Input == "d" then
					return
				end
				PressedWriting[Input] = true
			end
			for _,Input in pairs(InputEndedQueue) do
				PressedWriting[Input] = nil
			end
			WritingPressedKeysLabel.Text = "|"
			for Input,_ in pairs(PressedWriting) do
				WritingPressedKeysLabel.Text = WritingPressedKeysLabel.Text..Input.."|"
			end
		end]]
	end
end

do -- Connections
	UserInputService.InputBegan:Connect(InputBegan)
	UserInputService.InputChanged:Connect(InputChanged)
	UserInputService.InputEnded:Connect(InputEnded)
	RunService.RenderStepped:Connect(RenderStepped)
	RunService.Stepped:Connect(Stepped)
	Player.CharacterAdded:Connect(CharacterAdded)
	workspace.CurrentCamera.Changed:Connect(CurrentCamera_Changed)
end

do -- Setup
	GetReplayFile() -- Create folders and files for Replayability+ if needed
	SetCursor("ArrowFarCursor") -- Add fake cursor
	UserInputService.MouseIconEnabled = false -- Remove real cursor
	DefaultGravity = Workspace.Gravity -- Set DefaultGravity
	ShiftLockBoundKeys.Value = "" -- Remove shift lock keybinds
	CharacterAdded(Player.Character) -- Set character
	SetColorCodeFrame("Idle") -- Set color code
end

local function findAnimateScript(character)
    if not character then return nil end

    -- common names
    local names = {
        "Animate",
        "AnimationScript",
        "CharacterAnimate",
        "PlayerAnimate"
    }

    -- check common names
    for _, name in ipairs(names) do
        local s = character:FindFirstChild(name, true)
        if s and s:IsA("LocalScript") then
            return s
        end
    end

    -- smart detection
    for _, obj in ipairs(character:GetDescendants()) do
        if obj:IsA("LocalScript") then
            for _, sub in ipairs(obj:GetChildren()) do
                local n = sub.Name:lower()
                if n == "idle" or n == "walk" or n == "run" or n == "jump" or n == "fall" then
                    return obj
                end
            end
        end
    end

    return nil
end


spawn(function() -- Reading Loop lol

	local frameCache = {}
	local lastAnimations = {} 
	local currentAnimTracks = {} 
	
	while true do
		if Reading then
			local Frame = ReplayTable[ReplayTableIndex]
			
			-- Handle special frames (void/death)
			if Frame == 0 then
				Humanoid:ChangeState(15)
				for _,Descendant in pairs(Character:GetDescendants()) do
					if Descendant:IsA("BasePart") then
						Descendant:Destroy()
					end
				end
				repeat wait() until not Dead
				RunService.Heartbeat:Wait()
				ReplayTableIndex = ReplayTableIndex + 1
				continue
			elseif Frame == 1 then
				Humanoid:ChangeState(15)
				workspace.Gravity = DefaultGravity
				repeat wait() until not Dead
				RunService.Heartbeat:Wait()
				ReplayTableIndex = ReplayTableIndex + 1
				continue
			end
			
			if not Frame or typeof(Frame) == "string" then
				StopReading()
				continue
			end
			
				local animateScript = findAnimateScript(Character)
						if animateScript then
   					 animateScript.Disabled = true
				end

			AnimateDisabled = true
			workspace.Gravity = 0
			Character.Humanoid.JumpPower = 0
			Character.Humanoid.WalkSpeed = 0
			
			if not Character:FindFirstChild("HumanoidRootPart") then
				RunService.Heartbeat:Wait()
				continue
			end
			
			local HRP = Character.HumanoidRootPart
			
			
			for _,v in pairs(Character:GetChildren()) do
				if v:IsA("BasePart") then
					v.CanCollide = false
				end
			end
			
			Humanoid.PlatformStand = true
			
			-- Cache
			local cache = frameCache[ReplayTableIndex]
			if not cache then
				cache = {
					hrpCFrame = FastTableToCFrame(Frame[1]),
					camCFrame = FastTableToCFrame(Frame[7]),
					hrpVel = FastTableToVector3(Frame[5]),
					hrpRotVel = FastTableToVector3(Frame[6]),
					mouseLocation = FastTableToVector2(Frame[11])
				}
				frameCache[ReplayTableIndex] = cache
			end
			
			local Animations = Frame[2]
			local AnimationSpeed = Frame[3]
			local HumanoidState = Frame[4]
			local Zoom = Frame[8]
			local AnimatePose = Frame[9]
			local ShiftLockEnabled = (Frame[10] == 1)
			local InputBeganQueue = Frame[12][1]
			local InputEndedQueue = Frame[12][2]
			
			SetCameraCFrame(cache.camCFrame)
			SetZoom(Zoom)
			
			pose = AnimatePose

			Humanoid:ChangeState(HumanoidState)

			for _, Arguments in pairs(Animations) do
				local animName = Arguments[1]
				local transitionTime = Arguments[2]
				playAnimation(animName, transitionTime, Humanoid, true)
			end

			pcall(setAnimationSpeed, AnimationSpeed)

			if ShiftLockEnabled ~= GetShiftLockEnabled() then
				SetShiftLockEnabled(ShiftLockEnabled)
			end

			if PlaybackMouseLocation and not ShiftLockEnabled and Zoom > 0.52 then
				mousemoveabs(cache.mouseLocation.X, cache.mouseLocation.Y)
			else
				local CurrentGuiInset = GuiService:GetGuiInset()
				mousemoveabs(
					(Resolution.X/2) + CursorOffset.X - CurrentGuiInset.X,
					(Resolution.Y/2) + CursorOffset.Y - CurrentGuiInset.Y - 36
				)
			end
			
			-- Handle input playback
			if PlaybackInputs then
				local Signal = {}
				for _, Input in pairs(InputBeganQueue) do
					local Code = InputCodes[Input]
					if Code then
						keypress(Code)
					elseif Input == "b1" then
						mouse1press()
					elseif Input == "b2" then
						mouse2press()
					elseif Input == "u" or Input == "d" then
						table.insert(Signal, Input)
					end
				end
				for _, Input in pairs(InputEndedQueue) do
					local Code = InputCodes[Input]
					if Code then
						keyrelease(Code)
					elseif Input == "b1" then
						mouse1release()
					elseif Input == "b2" then
						mouse2release()
					end
				end
				if #Signal > 0 then
					SendSignal(table.concat(Signal, ","))
				end
			end
			
			local alignPos = HRP:FindFirstChild("TAS_AlignPosition")
			local alignOrient = HRP:FindFirstChild("TAS_AlignOrientation")
			local attachment = HRP:FindFirstChild("TAS_Attachment")
			
			if not attachment then
				attachment = Instance.new("Attachment")
				attachment.Name = "TAS_Attachment"
				attachment.Parent = HRP
			end
			
			if not alignPos then
				alignPos = Instance.new("AlignPosition")
				alignPos.Name = "TAS_AlignPosition"
				alignPos.Attachment0 = attachment
				alignPos.Mode = Enum.PositionAlignmentMode.OneAttachment
				alignPos.MaxForce = 9e9
				alignPos.MaxVelocity = 9e9
				alignPos.Responsiveness = 200
				alignPos.RigidityEnabled = true
				alignPos.Parent = HRP
			end
			
			if not alignOrient then
				alignOrient = Instance.new("AlignOrientation")
				alignOrient.Name = "TAS_AlignOrientation"
				alignOrient.Attachment0 = attachment
				alignOrient.Mode = Enum.OrientationAlignmentMode.OneAttachment
				alignOrient.MaxTorque = 9e9
				alignOrient.MaxAngularVelocity = 9e9
				alignOrient.Responsiveness = 200
				alignOrient.RigidityEnabled = true
				alignOrient.Parent = HRP
			end
			
			alignPos.Position = cache.hrpCFrame.Position
			alignOrient.CFrame = cache.hrpCFrame

			HRP.Velocity = cache.hrpVel
			HRP.RotVelocity = cache.hrpRotVel

			HRP.CFrame = cache.hrpCFrame
			
			ReplayTableIndex = ReplayTableIndex + 1

-- Clear old cache

			if ReplayTableIndex > 100 then
				frameCache[ReplayTableIndex - 100] = nil
				for animName, frameIndex in pairs(lastAnimations) do
					if frameIndex < ReplayTableIndex - 100 then
						lastAnimations[animName] = nil
					end
				end
			end
		else
			workspace.Gravity = DefaultGravity
			pcall(function()
				if Character and Character:FindFirstChild("HumanoidRootPart") then
					local HRP = Character.HumanoidRootPart
					if HRP:FindFirstChild("TAS_AlignPosition") then
						HRP.TAS_AlignPosition:Destroy()
					end
					if HRP:FindFirstChild("TAS_AlignOrientation") then
						HRP.TAS_AlignOrientation:Destroy()
					end
					if HRP:FindFirstChild("TAS_Attachment") then
						HRP.TAS_Attachment:Destroy()
					end
					Character.Humanoid.PlatformStand = false
				end
			end)
			frameCache = {}
			lastAnimations = {}
			currentAnimTracks = {}
		end
		
		RunService.Heartbeat:Wait()
	end
end)


spawn(function() -- Writing
	while true do
		--print(currentAnimSpeed)
		--print(GetShiftLockEnabled())
		--table.foreach(InputEndedQueue,print)
		--print(GetZoom())
		if Writing then
			if (not Character or not Character.Parent) or (not Character:FindFirstChild("HumanoidRootPart")) then
				if type(RecordingTable[#RecordingTable]) == "table" then
					table.insert(RecordingTable,0) -- Voided
				end
				RunService.RenderStepped:Wait()
				continue
			end
			if (Humanoid.Health == 0) then
				if type(RecordingTable[#RecordingTable]) == "table" then
					table.insert(RecordingTable,1) -- Dead
				end
				RunService.RenderStepped:Wait()
				continue
			end
			local Frame = {}
			Frame[1] = RoundTable(CFrameToTable(Character.HumanoidRootPart.CFrame),RoundDigits)
			Frame[2] = AnimationQueue
			Frame[3] = RoundNumber(currentAnimSpeed,RoundDigits)
			Frame[4] = Humanoid:GetState().Value
			Frame[5] = RoundTable(Vector3ToTable(Character.HumanoidRootPart.Velocity),RoundDigits)
			Frame[6] = RoundTable(Vector3ToTable(Character.HumanoidRootPart.RotVelocity),RoundDigits)
			Frame[7] = RoundTable(CFrameToTable(workspace.CurrentCamera.CFrame),RoundDigits)
			Frame[8] = RoundNumber(GetZoom(),RoundDigits)
			Frame[9] = pose
			Frame[10] = (GetShiftLockEnabled() and 1) or 0
			Frame[11] = RoundTable(Vector2ToTable(UserInputService:GetMouseLocation()),RoundDigits)
			Frame[12] = {InputBeganQueue,InputEndedQueue}
			table.insert(RecordingTable,Frame)
		end
		AnimationQueue = {}
		RunSpeed = 0
		ClimbSpeed = 0
		HumanoidStateQueue = {}
		if setfpscap then
			setfpscap(FPS)
		end
		RunService.RenderStepped:Wait()
	end
end)

-- Clear input queues
RunService.Heartbeat:Connect(function()
	InputBeganQueue = {}
	InputEndedQueue = {}
end)

spawn(function() -- Check if connected
	while true do
		wait(1)
		if not Reading then
			local Installed = IsInstalled()
			if Installed then
				ConnectedLabel.Text = "AHK folder found"
				ConnectedLabel.TextColor3 = Color3.new(0,0.8,0)
			else
				ConnectedLabel.Text = "AHK folder not found"
				ConnectedLabel.TextColor3 = Color3.new(0.8,0,0)
			end
		end
	end
end)

spawn(function() -- Update cursor
	while true do
		Cursor.Image = CursorIcon
		Cursor.Size = CursorSize
		local MouseLocation = UserInputService:GetMouseLocation()
		local CurrentGuiInset = GuiService:GetGuiInset()
		
		if ShiftLockEnabled or UserInputService.MouseBehavior == Enum.MouseBehavior.LockCenter then
			
			Cursor.Position = UDim2.fromOffset(
				(Resolution.X / 2) + CursorOffset.X - CurrentGuiInset.X,
				(Resolution.Y / 2) + CursorOffset.Y - CurrentGuiInset.Y - 36
			)
		else
			
			Cursor.Position = UDim2.fromOffset(
				MouseLocation.X + CursorOffset.X - CurrentGuiInset.X,
				MouseLocation.Y + CursorOffset.Y - CurrentGuiInset.Y - 36
			)
		end
		RunService.RenderStepped:Wait()
	end
end)

--[[local oldprint
oldprint = hookfunction(print,function(...)
	if checkcaller() then
		return oldprint(...)
	end
end)]]

spawn(function() -- Handling freezing
	while true do
		if Frozen then
			Character.HumanoidRootPart.Anchored = true
			if FreezeFrame > 0 and FreezeFrame <= #ReplayTable then
				local RoundedFreezeFrame = RoundNumber(FreezeFrame,0)
                print(FreezeFrame, RoundedFreezeFrame)
				local Frame = ReplayTable[RoundedFreezeFrame]
				
				if type(Frame) == "table" then
					
					local AnimatePose -- -2
					local Animation -- -1
					
					
					for Index = RoundedFreezeFrame,1,-1 do
						if AnimatePose and Animation then
							break
						end
						local Frame = ReplayTable[Index]
						if type(Frame) == "table" then
							AnimatePose = Frame[9]
							Animation = Frame[2][#Frame[2]]
						end
					end
					
					
					local CurrentPressedKeys = {}
					for Index = RoundedFreezeFrame-math.max(FrameBacktrackCount,0),RoundedFreezeFrame do
						local Frame = ReplayTable[Index]
						if Frame and type(Frame) == "table" then
							local BeganInputs,EndedInputs = unpack(Frame[12])
							
							for _,Key in pairs(BeganInputs) do
								if Key ~= "u" and Key ~= "d" then -- Exclude scroll inputs
									CurrentPressedKeys[Key] = true
								end
							end
							
							for _,Key in pairs(EndedInputs) do
								-- Scroll inputs don't show up in EndedInputs
								CurrentPressedKeys[Key] = nil
							end
						end
					end
					
					-- Display keys pressed on WritingPressedKeysLabel
					WritingPressedKeysLabel.Text = "Writing Pressed keys: |"
					for Input,_ in pairs(CurrentPressedKeys) do
						WritingPressedKeysLabel.Text = WritingPressedKeysLabel.Text..Input.."|"
					end
					
					local HumanoidRootPartCFrame = TableToCFrame(Frame[1]) -- 4
					local AnimationSpeed = Frame[3] -- 9
					local HumanoidState = Frame[4] -- 1
					local HumanoidRootPartVelocity = TableToVector3(Frame[5]) -- 2
					local HumanoidRootPartRotVelocity = TableToVector3(Frame[6]) -- 3
					local CameraCFrame = TableToCFrame(Frame[7]) -- 5
					local Zoom = Frame[8] -- 6
					local ShiftLockEnabled = (Frame[10] == 1 and true) or false -- 7
					local MouseLocation = TableToVector2(Frame[11]) -- 8
					
					local CurrentState = Humanoid:GetState().Value
					
					-- -1
					if Animation then
						if Animation[1] == "walk" then
							if Humanoid.FloorMaterial ~= Enum.Material.Air and CurrentState ~= 3 then
								playAnimation("walk",Animation[2],Humanoid,true)
							end
						else
							playAnimation(Animation[1],Animation[2],Humanoid,true)
						end
					end
					pcall(setAnimationSpeed,AnimationSpeed) -- 9
					pose = AnimatePose -- -2
					
					Humanoid:ChangeState(HumanoidState) -- 1
					
					Character.HumanoidRootPart.Velocity = HumanoidRootPartVelocity -- 2
					Character.HumanoidRootPart.RotVelocity = HumanoidRootPartRotVelocity -- 3
					Character.HumanoidRootPart.CFrame = HumanoidRootPartCFrame -- 4
                    if not movecameraonfroze.Value then
                        workspace.CurrentCamera.CFrame = CameraCFrame --5
                        SetZoom(Zoom) -- 6
                        if ShiftLockEnabled ~= GetShiftLockEnabled() then
                            SetShiftLockEnabled(ShiftLockEnabled) -- 7
                        end
                    end
					if PlaybackMouseLocation then
						mousemoveabs(MouseLocation.X,MouseLocation.Y) -- 8
					end
				else
					-- Frame is not a table
					RunService.RenderStepped:Wait()
				end
			else
				--ConsoleMessage("FreezeFrame is",FreezeFrame,"(not in range)")
			end
		else
			pcall(function()
				Character.HumanoidRootPart.Anchored = false
			end)
		end
		RunService.RenderStepped:Wait()
	end
end)

do -- Set checkpoint
	ConsoleMessage("Loading from file...")
	ReplayTable = ReplayDecode(GetReplayFile()) -- Decode replay from file
	if not ReplayTable then
		ReplayTable = {}
		ConsoleMessage("There is no replay folder for",PlaceId)
	end
end

ConsoleMessage("Tasability",Version,"loaded in",RoundNumber(tick()-ExecutionTick,2),"seconds")
ConsoleMessage("Type help to see all commands")