[OPEN SOURCE] SA - SILENT+TRIGGERBOT+DEVICE SPOOF [NO XENO]

 StarterGui = :()

  (title, message, duration)
	 details = {
		Title = title,
		Text = message,
		Duration = duration,
		Button1 = ,
	}

	 _ = ,  
		 (StarterGui.SetCore, StarterGui, , details) 
			
		
		.()
	
	(title ..  .. message)


 environmentGetter = 
 executorDebug = debug
 missing = {}

 (environmentGetter) ~=  
	.(missing, )

 _, name  { , ,  } 
	 (executorDebug) ~=   (executorDebug[name]) ~=  
		.(missing,  .. name)
	


 #missing >  
	(,  .. .(missing, ), )
	


 environmentOk, environment = (()
	 ()
)
  environmentOk 
	(,  .. (environment), )
	

 (environment) ~=  
	(, , )
	


 upvalues = executorDebug.getupvalues
 getupvalue = executorDebug.getupvalue
 setupvalue = executorDebug.setupvalue

 previous = environment.__aimSession
 previous 
	((previous.unload) == , )
	 success, reason = (previous.unload, )
	(success  environment.__aimSession ~= previous,
		 .. (reason))


 ReplicatedStorage = :()
 UserInputService = :()
 RunService = :()
 TweenService = :()
 Players = :()
 GuiService = :()

 ClientShootable = (ReplicatedStorage.Client.CombatController.ClientComponent.ClientShootableComponent)
 CombatController = (ReplicatedStorage.Client.CombatController)
 CommonWeapon = (ReplicatedStorage.Common.CombatService.CommonWeapon)
 Entities = (ReplicatedStorage.Remote.EntityService)
 HumanoidEntity = (ReplicatedStorage.Remote.EntityService.Entity.HumanoidEntity)
 Collision = (ReplicatedStorage.Constant).Collision
 Combat = (ReplicatedStorage.Config.Config).Combat

 originalShoot = ClientShootable.Shoot
 localShoot = ClientShootable.LocalShoot
((originalShoot) ==   (localShoot) == ,
	)

 originIndex, originalOrigin
 index, value  (originalShoot) 
	 (value) ==  
		(originIndex == , )
		originIndex, originalOrigin = index, value
	

(originIndex ~= , )

 localOriginMatches = 
 _, value  (localShoot) 
	 value == originalOrigin 
		localOriginMatches += 
	

(localOriginMatches == , )

 CONE_DOT = .(.())
 FIRE_INPUT = 
 rayParams = RaycastParams.()
rayParams.FilterType = .RaycastFilterType.Exclude
rayParams.RespectCanCollide = 

 state = {
	active = ,
	enabled = ,
	triggerbot = ,
	heldWeapon = ,
	triggerConnection = ,
	selectedEntity = ,
	selectedAt = -.huge,
	preparedShot = ,
	connections = {},
	reportedSelectionError = ,
	menuKey = .KeyCode.RightShift,
	aimKey = .KeyCode.V,
	triggerKey = .KeyCode.T,
	deviceLabel = ,
	uiVisible = ,
	lockMouse = ,
	uiSync =  :: (() -> ())?,
	uiDestroy =  :: (() -> ())?,
}

 HEAD_POINTS = {
	.(, , ),
	.(, , ),
	.(-, , ),
	.(, , ),
	.(, -, ),
	.(-, , ),
	.(, , ),
	.(-, -, ),
	.(, -, ),
}

 BODY_PARTS = {
	Body = , Torso = , UpperTorso = , LowerTorso = ,
	Arm = , LeftArm = , RightArm = ,
	LeftUpperArm = , LeftLowerArm = , LeftHand = ,
	RightUpperArm = , RightLowerArm = , RightHand = ,
	LeftLeg = , RightLeg = ,
	LeftUpperLeg = , LeftLowerLeg = , LeftFoot = ,
	RightUpperLeg = , RightLowerLeg = , RightFoot = ,
}

  (model, part, point, origin, view, headOnly)
	 offset = point - origin
	 distance = offset.Magnitude
	 distance <=   distance > Combat.BulletMaxDistance
		 view:(offset.Unit) < CONE_DOT 
		 
	

	 hit = :(origin, offset, rayParams)
	 headOnly 
		 hit  hit.Instance == part 
			 point, distance, part
		
	  hit  hit.Instance:(model) 
		 point, distance, part
	
	 


  (entity, origin, view)
	 model = entity:()
	  model   model:() 
		 
	

	 head = model:(, )
	 head  head:() 
		 frame, size = head.CFrame, head.Size
		 _, sample  HEAD_POINTS 
			 point = frame:(.(
				sample.X * size.X, sample.Y * size.Y, sample.Z * size.Z
			))
			 aimPoint, distance, part = (model, head, point, origin, view, )
			 aimPoint 
				 aimPoint, distance, part
			
		
	

	 body = entity:()
	 root = entity:()
	 _, part  { body, root } 
		 part  part ~= head  part:() 
			 aimPoint, distance, hitPart = (model, part, part.Position, origin, view, )
			 aimPoint 
				 aimPoint, distance, hitPart
			
		
	

	 _, part  model:() 
		 part:()  BODY_PARTS[part.Name]  part ~= body  part ~= root 
			 aimPoint, distance, hitPart = (model, part, part.Position, origin, view, )
			 aimPoint 
				 aimPoint, distance, hitPart
			
		
	
	 


  (origin, view)
	 self = Entities.()
	  self   self:() 
		 
	
	 group = self:(Collision.Attack)
	 (group) ~=  
		 
	

	rayParams.CollisionGroup = group
	 character = self:()
	rayParams.FilterDescendantsInstances = character  { character }  {}

	  (entity)
		 entity ~= self  HumanoidEntity:(entity)
			 entity:()   self:(entity)
	

	 state.selectedEntity  .() - state.selectedAt <= 
		 (state.selectedEntity) 
		 point, distance, part = (state.selectedEntity, origin, view)
		 point 
			 state.selectedEntity, point, distance, part
		
	

	 closestEntity, closestPoint, closestDistance, closestPart
	closestDistance = Combat.BulletMaxDistance
	 _, entity  Entities.Entity.() 
		 (entity) 
			 point, distance, part = (entity, origin, view)
			 point  distance < closestDistance 
				closestEntity, closestPoint, closestDistance, closestPart = entity, point, distance, part
			
		
	
	 closestEntity, closestPoint, closestDistance, closestPart


  (reason)
	  state.reportedSelectionError 
		state.reportedSelectionError = 
		( .. (reason))
	


  (...)
	 origin, detectedAt, cameraData = (...)
	  (state.active  state.enabled  (origin) == ) 
		 origin, detectedAt, cameraData
	

	 state.preparedShot ==  
		 origin, detectedAt, cameraData
	

	 entity, point
	 state.preparedShot 
		entity, point = state.preparedShot.entity, state.preparedShot.point
	
		 success, selected, selectedPoint = (acquireTarget, origin.Position, origin.LookVector)
		  success 
			(selected)
			 origin, detectedAt, cameraData
		
		entity, point = selected, selectedPoint
	

	  point 
		 origin, detectedAt, cameraData
	
	 offset = point - origin.Position
	 offset.Magnitude <=   origin.LookVector:(offset.Unit) < CONE_DOT 
		 origin, detectedAt, cameraData
	

	state.selectedEntity = entity
	state.selectedAt = .()
	 .(origin.Position, point), detectedAt, cameraData


  (component, start, direction, context, prepared)
	state.preparedShot = prepared
	 success, result = (originalShoot, component, start, direction, context)
	state.preparedShot = 
	  success 
		(result, )
	
	 result


  (component, start, direction, context)
	  (state.active  state.enabled) 
		 (component, start, direction, context)
	

	 success, origin = (originalOrigin)
	  success  (origin) ~=  
		 (component, start, direction, context, )
	

	 selected, entity, point, _, part = (acquireTarget, origin.Position, origin.LookVector)
	  selected 
		(entity)
		 (component, start, direction, context, )
	
	  entity   point 
		 (component, start, direction, context, )
	

	 pivot = entity:()
	 offset = point - origin.Position
	  pivot  offset.Magnitude <=   origin.LookVector:(offset.Unit) < CONE_DOT 
		 (component, start, direction, context, )
	

	 shotContext = context  {}
	shotContext.Target = entity.Instance
	shotContext.TargetPos = pivot:(point)
	shotContext.TargetHeadshot = part ~=   part.Name == 
	 (component, start, direction, shotContext, { entity = entity, point = point })


  ()
	 held = state.heldWeapon
	state.heldWeapon = 
	 held 
		 shooter = held._Shootable
		 shooter  shooter.StopShootingTimer 
			 success, reason = (shooter.StopShootingTimer, shooter, { Input = FIRE_INPUT })
			  success 
				( .. (reason))
			
		
	


  (entity, origin)
	 model = entity:()
	  model 
		 
	
	 hit = :(origin.Position, origin.LookVector * Combat.BulletMaxDistance, rayParams)
	 hit ~=   hit.Instance:(model)


  ()
	  state.active   state.triggerbot 
		()
		
	

	 UserInputService:()  UserInputService:(.UserInputType.MouseButton1) 
		()
		
	

	 weapon = CombatController.()
	 shooter = weapon  weapon._Shootable
	  (weapon  weapon.Activated  shooter   shooter.Destroyed) 
		()
		
	

	 origin = ()
	 (origin) ~=  
		()
		
	

	 entity = (origin.Position, origin.LookVector)
	  entity  ( state.enabled   (entity, origin)) 
		()
		
	

	 automatic = shooter:()
	 state.heldWeapon  (state.heldWeapon ~= weapon   automatic) 
		()
	
	 automatic 
		 state.heldWeapon 
			
		
		  (shooter:()  shooter:()) 
			
		
		 weapon:(CommonWeapon.Action.Primary) 
			 CombatController.PrimaryAction.(FIRE_INPUT) 
				state.heldWeapon = weapon
			
		
		
	

	 shooter:()  shooter:()  weapon:(CommonWeapon.Action.Primary) 
		CombatController.PrimaryAction.(FIRE_INPUT)
	


  ()
	 success, reason = (checkTrigger)
	  success 
		state.triggerbot = 
		 sync = state.uiSync
		 sync 
			()
		
		 state.triggerConnection 
			state.triggerConnection:()
			state.triggerConnection = 
		
		()
		( .. (reason))
		(,  .. (reason), )
	


  (enabled)
	state.triggerbot = enabled
	 enabled 
		  state.triggerConnection 
			state.triggerConnection = RunService.Heartbeat:(runTrigger)
		
	
		 state.triggerConnection 
			state.triggerConnection:()
			state.triggerConnection = 
		
		()
	


 deviceReport

  ()
	 saved = deviceReport
	  saved 
		
	
	deviceReport = 
	 saved.connection  saved.connection:() 

	 actualDevice = saved.input.Device
	 (actualDevice) ==   actualDevice ~= state.deviceLabel 
		 ok, reason = (()
			saved.remote:(actualDevice)
		)
		  ok 
			( .. (reason))
		
	


  ()
	 deviceReport 
		
	
	 input = (ReplicatedStorage.Client.InputHelper)
	 devices = (ReplicatedStorage.Constant).Device
	 remote = ReplicatedStorage.Remote.Any.Device
	 changed = input.Event  input.Event.DeviceChanged
	(changed  (changed.Connect) == , )
	((remote.FireServer) == , )
	((devices[state.deviceLabel]) == , )

	 saved = {
		input = input, remote = remote, devices = devices,
		warned = , report = () ,
		connection =  :: RBXScriptConnection?,
	}
	  ()
		  state.active  deviceReport ~= saved 
			
		
		 ok, reason = (()
			remote:(devices[state.deviceLabel])
		)
		  ok   saved.warned 
			saved.warned = 
			( .. (reason))
		
	
	saved.report = report
	saved.connection = changed:(report)
	deviceReport = saved
	()


  ()
	 player = Players.LocalPlayer
	 playerGui = player  player:(, )
	(playerGui, )

	 colour = {
		base = .(, , ),
		inner = .(, , ),
		raised = .(, , ),
		border = .(, , ),
		text = .(, , ),
		muted = .(, , ),
		accent = .(, , ),
		active = .(, , ),
		alert = .(, , ),
	}
	 images = {
		main = ,
		settings = ,
		minimise = ,
		power = ,
		check = ,
	}
	 controls = {}
	 bindings = {}
	 uiConnections = {}
	 activePress = 
	 capturing =  :: ?
	 dragging = 
	 pointerStart = .zero
	 popupOpen = 
	 cursor = { bound = , behavior = .MouseBehavior.Default, iconVisible =  }
	 cursorStep =  .. (player.UserId)

	  (signal, callback)
		 connection = signal:(callback)
		.(uiConnections, connection)
		 connection
	

	  (class, parent, values)
		 item = .(class)
		 key, value  values 
			item[key] = value
		
		item.Parent = parent
		 item
	

	  (parent, radius)
		(, parent, { CornerRadius = .(, radius) })
	

	  (parent, image, x, y, size, tint, z)
		 (, parent, {
			BackgroundTransparency = , Image = image, ImageColor3 = tint  colour.muted,
			Position = .(x, y), Size = .(size, size),
			ScaleType = .ScaleType.Fit, ZIndex = z  ,
		})
	

	  (parent, content, x, y, width, height, size, tint, bold)
		 (, parent, {
			BackgroundTransparency = , Text = content, TextSize = size,
			Font = bold  .Font.GothamBold  .Font.GothamMedium,
			TextColor3 = tint  colour.text, TextXAlignment = .TextXAlignment.Left,
			TextYAlignment = .TextYAlignment.Center,
			TextTruncate = .TextTruncate.AtEnd,
			Position = .(x, y), Size = .(width, height),
		})
	

	 screen = (, playerGui, {
		Name = , ResetOnSpawn = , IgnoreGuiInset = ,
		ZIndexBehavior = .ZIndexBehavior.Sibling, DisplayOrder = ,
	})
	 uiRoot = gethui
	 (uiRoot) ==  
		 ok, root = (uiRoot)
		 ok  (root) ==  
			(() screen.Parent = root )
		
	
	 modal = (, screen, {
		Name = , Text = , BackgroundTransparency = ,
		AutoButtonColor = , Modal = , Active = , ZIndex = ,
		Size = .(, ), Visible = ,
	})
	  ()
		modal.Visible = 
		  cursor.bound   
		RunService:(cursorStep)
		cursor.bound = 
		
		  GuiService.MenuIsOpen 
			 UserInputService.MouseBehavior == .MouseBehavior.Default 
				UserInputService.MouseBehavior = cursor.behavior
			
			UserInputService.MouseIconEnabled = cursor.iconVisible
		
		cursor.behavior = .MouseBehavior.Default
		cursor.iconVisible = 
	
	  ()
		 useCursor = state.active  state.uiVisible  state.lockMouse
			  GuiService.MenuIsOpen
		  useCursor 
			()
			
		
		modal.Visible = 
		 cursor.bound   
		cursor.behavior = UserInputService.MouseBehavior
		cursor.iconVisible = UserInputService.MouseIconEnabled
		cursor.bound = 
		RunService:(cursorStep, .RenderPriority.Last.Value + , ()
			  (state.active  state.uiVisible  state.lockMouse)  GuiService.MenuIsOpen 
				
			
			UserInputService.MouseBehavior = .MouseBehavior.Default
			UserInputService.MouseIconEnabled = 
		)
		UserInputService.MouseBehavior = .MouseBehavior.Default
		UserInputService.MouseIconEnabled = 
	
	state.uiDestroy = ()
		()
		 _, connection  uiConnections  connection:() 
		state.uiSync = 
		state.uiDestroy = 
		screen:()
	
	 window = (, screen, {
		Name = , AnchorPoint = .(, ),
		Position = .(, ), Size = .(, ),
		BackgroundColor3 = colour.base, BorderSizePixel = , Active = ,
	})
	(window, )
	(, window, {
		Color = colour.border, Thickness = ,
		ApplyStrokeMode = .ApplyStrokeMode.Border,
		BorderStrokePosition = .BorderStrokePosition.Inner,
	})
	 scaler = (, window, { Scale =  })

	  ()
		 camera = .CurrentCamera
		 view = camera  camera.ViewportSize  .(, )
		scaler.Scale = .(, (view.X - ) / , (view.Y - ) / )
	
	()

	 header = (, window, {
		BackgroundTransparency = , Position = .(, ),
		Size = .(, ), Active = ,
	})
	(header, , , , , , , colour.text, )
	(header, , , , , , , colour.muted)
	 minimise = (, header, {
		Name = , Text = , AutoButtonColor = ,
		BackgroundColor3 = colour.inner, BorderSizePixel = ,
		Position = .(, ), Size = .(, ),
	})
	(minimise, )
	(minimise, images.minimise, , , , colour.text)
	(, window, {
		Position = .(, ), Size = .(, ),
		BorderSizePixel = , BackgroundColor3 = colour.raised,
	})
	(, window, {
		Position = .(, ), Size = .(, ),
		BorderSizePixel = , BackgroundColor3 = colour.raised,
	})

	 pages = {}
	 tabs = {}
	 index, name  { ,  } 
		 y =  + (index - ) * 
		 tab = (, window, {
			Name = name .. , Text = , AutoButtonColor = ,
			BackgroundColor3 = colour.base, BorderSizePixel = ,
			Position = .(, y), Size = .(, ),
		})
		(tab, )
		 marker = (, tab, {
			BackgroundColor3 = colour.accent, BorderSizePixel = ,
			Position = .(, ), Size = .(, ),
		})
		 glyph = (tab, index ==   images.main  images.settings,
			, , , colour.muted)
		 caption = (tab, name, , , , , , colour.muted, )
		 page = (, window, {
			Name = name .. , BackgroundTransparency = ,
			Position = .(, ), Size = .(, ),
			Visible = index == ,
		})
		tabs[index] = { button = tab, marker = marker, glyph = glyph, caption = caption }
		pages[index] = page
	

	 overlay = (, window, {
		Name = , BackgroundColor3 = colour.inner,
		BorderSizePixel = , Position = .(, ),
		Size = .(, ), Visible = , ZIndex = ,
	})
	(overlay, )
	(, overlay, {
		Color = colour.border, Thickness = ,
		BorderStrokePosition = .BorderStrokePosition.Inner,
	})

	  ()
		popupOpen = 
		overlay.Visible = 
	


	  (control, immediate)
		 enabled = control.preview
		 enabled ==  
			enabled = control.()
		
		 held = activePress  activePress.control == control
		 width = held    
		 x = enabled   -  - width  
		 control.motion  control.motion:() 
		 control.trackMotion  control.trackMotion:() 
		 destination = {
			Position = .(x, ), Size = .(width, ),
		}
		 fill = enabled  colour.active  colour.raised
		 immediate 
			control.thumb.Position = destination.Position
			control.thumb.Size = destination.Size
			control.track.BackgroundColor3 = fill
		
			control.motion = TweenService:(control.thumb, TweenInfo.(,
				.EasingStyle.Quart, .EasingDirection.Out), destination)
			control.trackMotion = TweenService:(control.track, TweenInfo.(,
				.EasingStyle.Quad, .EasingDirection.Out), { BackgroundColor3 = fill })
			control.motion:()
			control.trackMotion:()
		
	

	  (index)
		()
		 pressed = activePress
		activePress = 
		 pressed 
			pressed.control.preview = 
			(pressed.control, )
		
		 i, tab  tabs 
			 selected = index == i
			tab.button.BackgroundColor3 = selected  colour.inner  colour.base
			tab.marker.Visible = selected
			tab.glyph.ImageColor3 = selected  colour.accent  colour.muted
			tab.caption.TextColor3 = selected  colour.text  colour.muted
			pages[i].Visible = selected
		
	
	 index, tab  tabs 
		(tab.button.Activated, ()
			(index)
		)
	
	()

	  (control, value)
		  state.active   
		control.preview = 
		control.(value)
		 _, item  controls  (item, ) 
	

	  (y, heading, description, read, write, page)
		page = page  pages[]
		(page, heading, , y, , , , colour.text, )
		(page, description, , y + , , , , colour.muted)
		 track = (, page, {
			BackgroundColor3 = colour.raised, BorderSizePixel = ,
			Position = .(, y + ), Size = .(, ),
		})
		(track, )
		 thumb = (, track, {
			BackgroundColor3 = colour.text, BorderSizePixel = ,
			Position = .(, ), Size = .(, ),
		})
		(thumb, )
		 button = (, page, {
			Name = heading .. , Text = , AutoButtonColor = ,
			BackgroundTransparency = , Active = , ZIndex = ,
			Position = .(, y), Size = .(, ),
		})
		 control = {
			read = read, write = write, thumb = thumb, track = track, button = button,
			motion =  :: Tween?, trackMotion =  :: Tween?, preview =  :: boolean?,
		}
		.(controls, control)
		(button.InputBegan, (input)
			 activePress   state.active   
			 kind = input.UserInputType
			 kind ~= .UserInputType.MouseButton1  kind ~= .UserInputType.Touch   
			activePress = { control = control, input = input, startX = input.Position.X }
			(control, )
		)
		(button.Activated, (input)
			 input  (input.UserInputType == .UserInputType.MouseButton1
				 input.UserInputType == .UserInputType.Touch) 
				
			
			(control,  ())
		)
		(control, )
	

	(pages[], , , , , , , colour.muted, )
	(, , , ()
		 state.enabled
	, (enabled)
		state.enabled = enabled
		state.selectedEntity = 
		(, enabled    , )
	)
	(, pages[], {
		Position = .(, ), Size = .(, ),
		BackgroundColor3 = colour.raised, BorderSizePixel = ,
	})
	(, , , ()
		 state.triggerbot
	, (enabled)
		(enabled)
		(, enabled    , )
	)

	(pages[], , , , , , , colour.muted, )
	(, , , ()
		 deviceReport ~= 
	, (enabled)
		 enabled 
			 ok, reason = (enableDeviceReport)
			  ok 
				()
				( .. (reason))
				(,  .. (reason), )
			
		
			()
		
	)

	 choose = (, pages[], {
		Name = , Text = , BackgroundColor3 = colour.inner,
		BorderSizePixel = , AutoButtonColor = ,
		Position = .(, ), Size = .(, ),
	})
	(choose, )
	 choiceText = (choose, state.deviceLabel, , , , , , colour.text, )
	
	 rows = {}
	  ()
		choiceText.Text =  .. state.deviceLabel
		 name, row  rows 
			 selected = name == state.deviceLabel
			row.tick.Visible = selected
			row.box.BackgroundColor3 = selected  colour.active  colour.base
			row.button.BackgroundColor3 = selected  colour.active  colour.inner
		
	
	 index, name  { , , ,  } 
		 row = (, overlay, {
			Name = name, Text = , BackgroundColor3 = colour.inner,
			BorderSizePixel = , AutoButtonColor = , ZIndex = ,
			Position = .(,  + (index - ) * ),
			Size = .(, ),
		})
		 optionName = (row, name, , , , , , colour.text, )
		optionName.ZIndex = 
		 checkBox = (, row, {
			BackgroundColor3 = colour.base, BorderSizePixel = ,
			Position = .(, ), Size = .(, ),
			ZIndex = ,
		})
		(checkBox, )
		(, checkBox, {
			Thickness = , Color = colour.border,
			BorderStrokePosition = .BorderStrokePosition.Inner,
		})
		  = (checkBox, images.check, , , , colour.text, )
		rows[name] = { button = row,  = , box = checkBox }
		(row.Activated, ()
			state.deviceLabel = name
			 deviceReport  deviceReport.() 
			()
			()
		)
	
	()
	(choose.Activated, ()
		popupOpen =  popupOpen
		overlay.Visible = popupOpen
	)

	 settings = pages[]
	(settings, , , , , , , colour.muted, )
	 keyNotice = (settings, , , , , , , colour.muted)
	  (field)
		 field ==    state.menuKey 
		 field ==    state.aimKey 
		 state.triggerKey
	
	  (field, key)
		 field ==   state.menuKey = key
		 field ==   state.aimKey = key
		 state.triggerKey = key 
	
	  ()
		 field, button  bindings 
			 key = (field)
			button.Text = capturing == field    key.Name
			button.BackgroundColor3 = capturing == field  colour.active  colour.inner
		
	
	 index, info  {
		{ , ,  },
		{ , ,  },
		{ , ,  },
	} 
		 y =  + (index - ) * 
		(settings, info[], , y, , , , colour.text, )
		(settings, info[], , y + , , , , colour.muted)
		 button = (, settings, {
			Name = info[], Text = , AutoButtonColor = ,
			Font = .Font.GothamMedium, TextSize = , TextColor3 = colour.text,
			BackgroundColor3 = colour.inner, BorderSizePixel = ,
			Position = .(, y + ), Size = .(, ),
		})
		(button, )
		bindings[info[]] = button
		(button.Activated, ()
			capturing = info[]
			keyNotice.Text = 
			keyNotice.TextColor3 = colour.muted
			()
		)
	
	(settings, , , , , , , colour.muted, )
	(, , , ()
		 state.lockMouse
	, (enabled)
		state.lockMouse = enabled
		()
	, settings)
	 unload = (, settings, {
		Name = , Text = , AutoButtonColor = ,
		BackgroundColor3 = colour.inner, BorderSizePixel = ,
		Position = .(, ), Size = .(, ),
	})
	(unload, )
	(unload, images.power, , , , colour.alert)
	(unload, , , , , , , colour.text, )
	(unload.Activated, ()
		state.()
	)
	()

	 footer = (window, , , , , , , colour.muted)
	  ()
		footer.Text = state.menuKey.Name .. 
	
	()
	(, window, {
		Position = .(, ), Size = .(, ),
		BackgroundColor3 = colour.raised, BorderSizePixel = ,
	})

	  ()
		 pressed = activePress
		activePress = 
		 pressed 
			pressed.control.preview = 
			(pressed.control, )
		
		dragging = 
	
	 reopen = (, screen, {
		Name = , Text = , AutoButtonColor = ,
		BackgroundColor3 = colour.base, BorderSizePixel = ,
		Position = .(, , , -), Size = .(, ),
		Visible = ,
	})
	(reopen, )
	(, reopen, {
		Color = colour.border, Thickness = ,
		BorderStrokePosition = .BorderStrokePosition.Inner,
	})
	(reopen, images.main, , , , colour.accent)
	  (visible)
		state.uiVisible = visible
		window.Visible = visible
		reopen.Visible =  visible
		  visible 
			()
			capturing = 
			()
			()
		
		()
	
	(minimise.Activated, ()
		()
	)
	(reopen.Activated, ()
		()
	)
	state.uiSync = ()
		 _, control  controls  (control, ) 
	
	state.uiDestroy = ()
		()
		()
		 _, connection  uiConnections  connection:() 
		 _, control  controls 
			 control.motion  control.motion:() 
			 control.trackMotion  control.trackMotion:() 
		
		state.uiSync = 
		state.uiDestroy = 
		screen:()
	

	(UserInputService.InputBegan, (input, processed)
		 popupOpen  (input.UserInputType == .UserInputType.MouseButton1
			 input.UserInputType == .UserInputType.Touch) 
			 position = .(input.Position.X, input.Position.Y)
			  (object)
				 p, size = object.AbsolutePosition, object.AbsoluteSize
				 position.X >= p.X  position.X <= p.X + size.X
					 position.Y >= p.Y  position.Y <= p.Y + size.Y
			
			  (overlay)   (choose)  () 
		
		 input.UserInputType ~= .UserInputType.Keyboard   
		 popupOpen  input.KeyCode.Name ==  
			()
			
		
		 capturing 
			 key = input.KeyCode
			 key.Name ==  
				capturing = 
				keyNotice.Text = 
				keyNotice.TextColor3 = colour.muted
			 key.Name ==   key.Name ==  
				keyNotice.Text = 
				keyNotice.TextColor3 = colour.alert
			
				 conflict = 
				 _, field  { , ,  } 
					 field ~= capturing  (field).Name == key.Name 
						conflict = 
						
					
				
				 conflict 
					keyNotice.Text = 
					keyNotice.TextColor3 = colour.alert
				
					(capturing, key)
					capturing = 
					keyNotice.Text = 
					keyNotice.TextColor3 = colour.muted
					()
				
			
			()
			
		
		 processed  UserInputService:()   
		 input.KeyCode.Name == state.menuKey.Name 
			( state.uiVisible)
		 input.KeyCode.Name == state.aimKey.Name 
			state.enabled =  state.enabled
			state.selectedEntity = 
			 state.uiSync  state.() 
			(, state.enabled    , )
		 input.KeyCode.Name == state.triggerKey.Name 
			( state.triggerbot)
			 state.uiSync  state.() 
			(, state.triggerbot    , )
		 input.KeyCode.Name ==  
			state.()
		
	)

	(UserInputService.InputChanged, (input)
		 activePress 
			 pressed = activePress
			 touch = pressed.input.UserInputType == .UserInputType.Touch
			 (touch  input == pressed.input)  ( touch
				 input.UserInputType == .UserInputType.MouseMovement) 
				 delta = input.Position.X - pressed.startX
				 control = pressed.control
				 preview = 
				 .(delta) >=   preview = delta >  
				 control.preview ~= preview 
					control.preview = preview
					(control, )
				
			
		
		  dragging   state.uiVisible   
		 isTouch = dragging.UserInputType == .UserInputType.Touch
		 (isTouch  input ~= dragging)  ( isTouch
			 input.UserInputType ~= .UserInputType.MouseMovement)   
		 camera = .CurrentCamera
		  camera   
		 pointer = .(input.Position.X, input.Position.Y)
		 delta = pointer - pointerStart
		 size = window.AbsoluteSize
		 centre = window.AbsolutePosition + size /  + delta
		 view = camera.ViewportSize
		window.Position = .(
			.(centre.X, size.X / , .(size.X / , view.X - size.X / )),
			.(centre.Y, size.Y / , .(size.Y / , view.Y - size.Y / ))
		)
		pointerStart = pointer
	)

	(UserInputService.InputEnded, (input)
		 activePress 
			 pressed = activePress
			 touch = pressed.input.UserInputType == .UserInputType.Touch
			 (touch  pressed.input == input)  ( touch
				 input.UserInputType == .UserInputType.MouseButton1) 
				activePress = 
				 control = pressed.control
				 delta = input.Position.X - pressed.startX
				 .(delta) >=  
					(control, delta > )
				
					 p, size = control.button.AbsolutePosition, control.button.AbsoluteSize
					 x, y = input.Position.X, input.Position.Y
					 x >= p.X  x <= p.X + size.X  y >= p.Y  y <= p.Y + size.Y 
						(control,  control.())
					
						control.preview = 
						(control, )
					
				
			
		
		 dragging  (input == dragging  (dragging.UserInputType == .UserInputType.MouseButton1
			 input.UserInputType == .UserInputType.MouseButton1))  dragging =  
	)

	(GuiService.MenuOpened, updateMouse)
	(GuiService.MenuClosed, updateMouse)
	(UserInputService.WindowFocused, updateMouse)
	(UserInputService.WindowFocusReleased, ()
		()
		()
		()
		capturing = 
		keyNotice.Text = 
		keyNotice.TextColor3 = colour.muted
		()
	)

	(header.InputBegan, (input)
		 input.UserInputType == .UserInputType.MouseButton1
			 input.UserInputType == .UserInputType.Touch 
			dragging = input
			pointerStart = .(input.Position.X, input.Position.Y)
		
	)
	 camera = .CurrentCamera
	 camera  (camera:(), resize) 
	()


 state.(silent)
	  state.active 
		
	
	state.active = 
	state.enabled = 
	()
	 destroy = state.uiDestroy
	 destroy 
		()
	
	 index = #state.connections, , - 
		state.connections[index]:()
		state.connections[index] = 
	
	()

	 ClientShootable.Shoot == shootWithTarget 
		ClientShootable.Shoot = originalShoot
	
		()
	
	 (originalShoot, originIndex) == redirectedOrigin 
		(originalShoot, originIndex, originalOrigin)
	
		()
	
	 environment.__aimSession == state 
		environment.__aimSession = 
	
	  silent 
		(, , )
	


(originalShoot, originIndex, redirectedOrigin)
((originalShoot, originIndex) == redirectedOrigin,
	)
ClientShootable.Shoot = shootWithTarget
environment.__aimSession = state

 taken = {}
  (field, fallback)
	 candidate = previous  previous[field]
	 (candidate) ~=   (candidate.EnumType) ~= 
		 candidate.Name ==   candidate.Name == 
		 candidate.Name ==   taken[candidate.Name] 
		candidate = fallback
	
	
	 field ==   candidate.Name ==   candidate = .KeyCode.V 
	 taken[candidate.Name] 
		 _, option  { .KeyCode.RightShift, .KeyCode.V, .KeyCode.T, .KeyCode.B } 
			  taken[option.Name] 
				candidate = option
				
			
		
	
	taken[candidate.Name] = 
	 candidate

state.menuKey = (, .KeyCode.RightShift)
state.aimKey = (, .KeyCode.V)
state.triggerKey = (, .KeyCode.T)
 priorDevice = previous  previous.deviceLabel
 priorDevice ==   priorDevice == 
	 priorDevice ==   priorDevice ==  
	state.deviceLabel = priorDevice

state.uiVisible = 
 previous  (previous.lockMouse) ==  
	state.lockMouse = previous.lockMouse


()
 reportReady, reportReason = (enableDeviceReport)
  reportReady 
	()
	( .. (reportReason))

 interfaceReady, interfaceReason = (buildPanel)
  interfaceReady 
	state.()
	( .. (interfaceReason))
	(,  .. (interfaceReason), )
	

(, state.menuKey.Name:(, ) .. 
	.. state.aimKey.Name:(, ) .. 
	.. state.triggerKey.Name:(, ) .. , )