AI MADED Open source Esp and grab all loot

 Library = (:())()
 (Library) ~=  
	


 (Library.Folders) ==  
	Library.Folders.Directory = 
	Library.Folders.Configs = 
	Library.Folders.Themes = 
	Library.Folders.Assets = 


 Players = :()
 Workspace = :()
 ReplicatedStorage = :()
 ReplicatedFirst = :()
 ScriptContext = :()
 RunService = :()
 UserInputService = :()
 LocalPlayer = Players.LocalPlayer

 Window = Library:({
	Logo = ,
	FadeTime = ,
	Size = .(, , , ),
	Draggable = ,
	Resizeable = ,
})

 Watermark = Library:()
 KeybindList = Library:()

Window:({ Name = , Columns =  })
Window:({ Name = , Columns =  })
 VisualPage = Window:({ Name = , Columns =  })
 ItemsPage = Window:({ Name = , Columns =  })
Window:({ Name = , Columns =  })
Window:({ Name = , Columns =  })
Library:(Window, Watermark, KeybindList)

  (v, fallback, minV, maxV)
	 n = (v)
	 (n) ~=   n ~= n  n == .huge  n == -.huge 
		n = fallback
	
	 minV 
		n = .(minV, n)
	
	 maxV 
		n = .(maxV, n)
	
	 n


 CHAMS_MATERIAL_OPTIONS = { , , ,  }
 CHAMS_MATERIAL_ENUM_BY_LABEL = {
	ForceField = .Material.ForceField,
	SmoothPlastic = .Material.SmoothPlastic,
	Neon = .Material.Neon,
	Glass = .Material.Glass,
}

  (label, fallback)
	 CHAMS_MATERIAL_ENUM_BY_LABEL[(label  )]  fallback  .Material.ForceField


  (value)
	 .(((value  ):(, )))


  (parent, wanted)
	  parent 
		 
	
	 wn = (wanted)
	 _, child  (parent:()) 
		 (child.Name) == wn 
			 child
		
	
	 


  ()
	 chunking = ReplicatedStorage:()
		 ReplicatedStorage:()
		 (ReplicatedStorage, )
	  chunking 
		 
	
	 chunking:()
		 chunking:()
		 chunking:()
		 (chunking, )
			 (chunking, )


 FrameworkCache = {
	Entities = ,
	Network = ,
	Initialized = ,
}

  ()
	 FrameworkCache.Entities 
		 FrameworkCache.Entities
	
	 frameworkModule = ReplicatedFirst:()
	  frameworkModule 
		 
	
	 ok, framework = (, frameworkModule)
	  ok  (framework) ~=  
		 
	
	  FrameworkCache.Initialized  (framework.WaitForLoaded) ==  
		(()
			framework:()
		)
	
	FrameworkCache.Initialized = 
	 entities = framework.Libraries  framework.Libraries.Entities
	 entities 
		FrameworkCache.Entities = entities
	
	 FrameworkCache.Entities


  ()
	 FrameworkCache.Network 
		 FrameworkCache.Network
	
	 frameworkModule = ReplicatedFirst:()
	  frameworkModule 
		 
	
	 ok, framework = (, frameworkModule)
	  ok  (framework) ~=  
		 
	
	  FrameworkCache.Initialized  (framework.WaitForLoaded) ==  
		(()
			framework:()
		)
	
	FrameworkCache.Initialized = 
	 network = framework.Libraries  framework.Libraries.Network
	 network 
		FrameworkCache.Network = network
	
	 FrameworkCache.Network


  ()
	 Workspace:()  Workspace:()


  ()
	 Workspace.CurrentCamera


  (model)
	  model 
		 
	
	 hum = model:()
	 hum  hum:() 
		 hum
	
	 model:()


  (model)
	  model 
		 
	
	 model:()
		 model:()
		 model:()


  (model)
	  model 
		 
	
	 animator = model:()  model:()  model:()
	  animator 
		 
	
	 equipped = animator:()  animator:()
	  (equipped  equipped:()) 
		 
	
	 raw = (equipped.Value  )
	 raw ==  
		 
	
	 name = raw:()
		 raw:()
		 raw:()
		 raw:()
	 (name) ==   name ~=  
		 name
	
	 


 BODY_PART_CORE = {
	Head = ,
	HumanoidRootPart = ,
	UpperTorso = ,
	LowerTorso = ,
	Torso = ,
	LeftUpperArm = ,
	LeftLowerArm = ,
	LeftHand = ,
	RightUpperArm = ,
	RightLowerArm = ,
	RightHand = ,
	LeftUpperLeg = ,
	LeftLowerLeg = ,
	LeftFoot = ,
	RightUpperLeg = ,
	RightLowerLeg = ,
	RightFoot = ,
	[] = ,
	[] = ,
	[] = ,
	[] = ,
}

  (config)
	 cam = ()
	  cam 
		 {}
	
	 camPos = cam.CFrame.Position
	 out = {}
	 root = ()
	  root 
		 out
	

	 localTeam = (LocalPlayer.Team  LocalPlayer.Team.Name)  LocalPlayer:()
	 _, model  (root:()) 
		 model:()  .(model.Name) ==   model ~= LocalPlayer.Character 
			 hum = (model)
			 rootPart = (model)
			 hum  rootPart 
				 team = model:()
				  (config.TeamCheck  localTeam  team  (localTeam) == (team)) 
					 distance = (camPos - rootPart.Position).Magnitude
					 distance <= config.ESPDistance 
						.(out, {
							Key = model,
							Character = model,
							Humanoid = hum,
							Root = rootPart,
							Distance = distance,
							WeaponName = (model),
						})
					
				
			
		
	
	 out


 ESP = {
	Config = {
		TeamCheck = ,
		ESPDistance = ,
		BoxColor = .(, , ),
		BoxGradientEnabled = ,
		BoxGradientColor1 = .(, , ),
		BoxGradientColor2 = .(, , ),
		BoxFillTransparency = ,
		RotateSpeed = ,
		BoxOutlineEnabled = ,
		BoxOutlineColor = .(, , ),
		SkeletonColor = .(, , ),
		TracerOrigin = ,
		TracerColor = .(, , ),
		ChamsColor = .(, , ),
		ChamsFillTransparency = ,
		ChamsMaterial = .Material.ForceField,
		RingColor = .(, , ),
		ScanSpeed = ,
		ScanHeight = ,
		RingRadius = ,
	},
	State = {
		BoxEnabled = ,
		WeaponEnabled = ,
		DistanceEnabled = ,
		SkeletonEnabled = ,
		TracerEnabled = ,
		ChamsEnabled = ,
		RingEnabled = ,
	},
	Caches = {
		Box = {},
		Skeleton = {},
		Tracer = {},
		Chams = {},
		Ring = {},
	},
}

 ItemESP = {
	State = {
		Enabled = ,
	},
	Config = {
		Distance = ,
	},
	Caches = {
		Text = {},
	},
	Runtime = {
		Nodes = {},
		LastRefresh = ,
	},
}

 LootBoxESP = {
	State = {
		Enabled = ,
	},
	Config = {
		Distance = ,
	},
	Caches = {
		Text = {},
	},
	Runtime = {
		Entries = {},
		LastRefresh = ,
	},
}

  (obj)
	  obj 
		
	
	 (obj) ==  
		(()
			obj:()
		)
		
	
	(()
		obj:()
	)


  ()
	 t = {
		Box = .(),
		Outline = .(),
		Fill = .(),
		Weapon = .(),
		Distance = .(),
	}
	t.Box.Filled = 
	t.Box.Thickness = 
	t.Box.Transparency = 
	t.Outline.Filled = 
	t.Outline.Thickness = 
	t.Outline.Transparency = 
	t.Fill.Filled = 
	t.Fill.Thickness = 
	t.Distance.Size = 
	t.Distance.Font = 
	t.Distance.Outline = 
	t.Distance.Center = 
	t.Weapon.Size = 
	t.Weapon.Font = 
	t.Weapon.Outline = 
	t.Weapon.Center = 
	 t


  (c)
	(c.Box)
	(c.Outline)
	(c.Fill)
	(c.Weapon)
	(c.Distance)


  (c)
	c.Box.Visible = 
	c.Outline.Visible = 
	c.Fill.Visible = 
	c.Weapon.Visible = 
	c.Distance.Visible = 


  (model)
	 isR6 = model:()   model:()
	 lines = {}
	 isR6 
		lines.Map = {
			{ ,  },
			{ ,  },
			{ ,  },
			{ ,  },
			{ ,  },
		}
	
		lines.Map = {
			{ ,  },
			{ ,  },
			{ ,  },
			{ ,  },
			{ ,  },
			{ ,  },
			{ ,  },
			{ ,  },
			{ ,  },
			{ ,  },
			{ ,  },
			{ ,  },
			{ ,  },
			{ ,  },
		}
	
	lines.Draw = {}
	 i = , #lines.Map 
		 l = .()
		l.Thickness = 
		l.Visible = 
		lines.Draw[i] = l
	
	 lines


  ()
	 l = .()
	l.Thickness = 
	l.Visible = 
	 l


  ()
	 t = .()
	t.Size = 
	t.Font = 
	t.Outline = 
	t.Center = 
	t.Color = .(, , )
	t.Visible = 
	 t


  ()
	 () - ItemESP.Runtime.LastRefresh <  
		
	
	ItemESP.Runtime.LastRefresh = ()
	 chunkData = ()
	 nodes = {}
	 chunkData 
		 _, obj  (chunkData:()) 
			 obj.Name ==   obj:() 
				nodes[obj] = 
			
		
	
	 map = Workspace:()
	 elements = map  map:()
	 elements 
		 _, element  (elements:()) 
			 detail = element:(, )
			 detail 
				 _, instance  (detail:()) 
					 instance:()  instance.Name ==  
						nodes[instance] = 
					
				
			
		
	
	ItemESP.Runtime.Nodes = nodes


  (instance, sourceType)
	  (instance  instance.Parent) 
		 
	
	 sourceType ==  
		 instance:()  (instance.Value) ==  
			 instance.Value.Position
		
		 
	
	 sourceType ==  
		 instance:() 
			 okPivot, pivot = (()
				 instance:()
			)
			 okPivot  (pivot) ==  
				 pivot.Position
			
		
		 
	
	 


  (instance)
	  (instance  instance.Parent) 
		 
	
	 instance:() 
		 instance.Position
	
	 instance:() 
		 instance.WorldPosition
	
	 instance:() 
		 instance.Value.Position
	
	 instance:() 
		 primary = instance.PrimaryPart  instance:(, )
		 primary 
			 primary.Position
		
		 okPivot, pivot = (()
			 instance:()
		)
		 okPivot  (pivot) ==  
			 pivot.Position
		
	
	 ancestorPart = instance:()
	 ancestorPart 
		 ancestorPart.Position
	
	 ancestorModel = instance:()
	 ancestorModel 
		 primary = ancestorModel.PrimaryPart  ancestorModel:(, )
		 primary 
			 primary.Position
		
		 okPivot, pivot = (()
			 ancestorModel:()
		)
		 okPivot  (pivot) ==  
			 pivot.Position
		
	
	 


  ()
	 () - LootBoxESP.Runtime.LastRefresh <  
		
	
	LootBoxESP.Runtime.LastRefresh = ()
	 entries = {}
	 entities = ()
	 map = Workspace:()
	 elements = map  map:()
	  (entities  (entities.Search) ==   elements) 
		LootBoxESP.Runtime.Entries = entries
		
	
	 _, element  (elements:()) 
		 detail = element:(, )
		 detail 
			 _, instance  (detail:()) 
				 ok, entity = (()
					 entities:(instance)
				)
				 ok  entity  entity.Type ==  
					entries[instance] = {
						 = instance,
						Id = entity.Id,
					}
				
			
		
	
	LootBoxESP.Runtime.Entries = entries


 GrabAllRuntime = {
	Running = ,
	HoldActive = ,
	LastRunAt = ,
	MinInterval = ,
	ErrorHooksSuppressed = ,
}

  ()
	 GrabAllRuntime.ErrorHooksSuppressed 
		
	
	GrabAllRuntime.ErrorHooksSuppressed = 
	.(()
		 ok, err = (()
			 (getconnections) ~=  
				
			
			 connections = (ScriptContext.Error)
			 (connections) ~=  
				
			
			 _, connection  (connections) 
				 connection  (connection.Disconnect) ==  
					connection:()
				
			
		)
		  ok 
			(err)
		
	)


  ()
	 now = ()
	 GrabAllRuntime.Running 
		
	
	 (now - GrabAllRuntime.LastRunAt) < GrabAllRuntime.MinInterval 
		
	
	GrabAllRuntime.Running = 
	GrabAllRuntime.LastRunAt = now
	.(()
		 ok, err = (()
			()
			 entities = ()
			 network = ()
			 map = Workspace:()
			 elements = map  map:()
			  (entities  network  elements) 
				
			
			 (entities.Search) ~=   (network.Send) ~=  
				
			
			 sentIds = {}
			 ops = 
			 _, element  (elements:()) 
				 detail = element:(, )
				 detail 
					 _, instance  (detail:()) 
						 okSearch, entity = (()
							 entities:(instance)
						)
						 okSearch  entity  entity.Type ==   entity.Id   sentIds[entity.Id] 
							sentIds[entity.Id] = 
							(()
								network:(, entity.Id)
							)
						
						ops = ops + 
						 ops %  ==  
							.()
						
					
				
			
		)
		GrabAllRuntime.Running = 
		  ok 
			(err)
		
	)


  ()
	 holder = .()
	holder.Transparency = 
	holder.Anchored = 
	holder.CanCollide = 
	holder.CanTouch = 
	holder.CanQuery = 
	holder.Parent = Workspace
	 ring = .()
	ring.Adornee = holder
	ring.AlwaysOnTop = 
	ring.ZIndex = 
	ring.Height = 
	ring.CFrame = .(.(), , )
	ring.Parent = holder
	ring.Visible = 
	 { Holder = holder, Ring = ring, Root =  }


  (model, rootPart, cam)
	 minX, minY = .huge, .huge
	 maxX, maxY = -.huge, -.huge
	 any = 
	 _, part  (model:()) 
		 part:()  BODY_PART_CORE[part.Name] 
			 p, on = cam:(part.Position)
			 p.Z >  
				minX = .(minX, p.X)
				maxX = .(maxX, p.X)
				minY = .(minY, p.Y)
				maxY = .(maxY, p.Y)
				 on 
					any = 
				
			
		
	
	 minX == .huge 
		 p, on = cam:(rootPart.Position)
		 p.Z <=  
			 
		
		minX, maxX, minY, maxY, any = p.X - , p.X + , p.Y - , p.Y + , on
	
	 (maxX - minX) <   (maxY - minY) <  
		 
	
	 minX, minY, maxX, maxY, any


  ()
	 { Parts = {} }


  (cache, part, mat, col, alpha)
	  cache.Parts[part] 
		cache.Parts[part] = {
			Material = part.Material,
			Color = part.Color,
			LocalTransparencyModifier = part.LocalTransparencyModifier,
			Reflectance = part.Reflectance,
		}
	
	part.Material = mat
	part.Color = col
	part.Reflectance = 
	part.LocalTransparencyModifier = alpha


  (cache, part)
	 prev = cache.Parts[part]
	 prev  part  part.Parent 
		part.Material = prev.Material
		part.Color = prev.Color
		part.LocalTransparencyModifier = prev.LocalTransparencyModifier
		part.Reflectance = prev.Reflectance
	
	cache.Parts[part] = 


 rotation = 
RunService.RenderStepped:((dt)
	 cam = ()
	  cam 
		
	
	 targets = (ESP.Config)
	 active = {}
	 i = , #targets 
		active[targets[i].Key] = targets[i]
	

	 key, cache  (ESP.Caches.Box) 
		  active[key] 
			(cache)
			ESP.Caches.Box[key] = 
		
	
	 key, cache  (ESP.Caches.Skeleton) 
		  active[key] 
			 _, ln  (cache.Draw) 
				(ln)
			
			ESP.Caches.Skeleton[key] = 
		
	
	 key, cache  (ESP.Caches.Tracer) 
		  active[key] 
			(cache)
			ESP.Caches.Tracer[key] = 
		
	
	 key, cache  (ESP.Caches.Chams) 
		  active[key] 
			 part, _  (cache.Parts) 
				(cache, part)
			
			ESP.Caches.Chams[key] = 
		
	
		 key, cache  (ESP.Caches.Ring) 
			  active[key] 
				(cache.Ring)
				(cache.Holder)
				ESP.Caches.Ring[key] = 
			
		
		  ItemESP.State.Enabled 
			 key, text  (ItemESP.Caches.Text) 
				 text 
					text.Visible = 
				
				  key   key.Parent 
					(text)
					ItemESP.Caches.Text[key] = 
				
			
		
		  LootBoxESP.State.Enabled 
			 key, text  (LootBoxESP.Caches.Text) 
				 text 
					text.Visible = 
				
				  key   key.Parent 
					(text)
					LootBoxESP.Caches.Text[key] = 
				
			
		

		rotation = (rotation - ESP.Config.RotateSpeed * dt) % 

	 i = , #targets 
		 t = targets[i]
		 key, model, root, dist = t.Key, t.Character, t.Root, t.Distance
		 minX, minY, maxX, maxY = (model, root, cam)
		 boundsOk = (minX ~= )

		 box = ESP.Caches.Box[key]
		  box 
			box = ()
			ESP.Caches.Box[key] = box
		

		  boundsOk 
			(box)
		
			 w, h = (maxX - minX), (maxY - minY)
			 cx = (minX + maxX) * 
			 ESP.State.BoxEnabled 
				box.Box.Position = .(minX, minY)
				box.Box.Size = .(w, h)
				box.Box.Color = ESP.Config.BoxColor
				box.Box.Visible = 
				box.Outline.Position = .(minX, minY)
				box.Outline.Size = .(w, h)
				box.Outline.Color = ESP.Config.BoxOutlineColor
				box.Outline.Visible = ESP.Config.BoxOutlineEnabled
				 ESP.Config.BoxGradientEnabled 
					 blend = (.(.(rotation)) + ) * 
					box.Fill.Position = .(minX, minY)
					box.Fill.Size = .(w, h)
					box.Fill.Color = ESP.Config.BoxGradientColor1:(ESP.Config.BoxGradientColor2, blend)
					box.Fill.Transparency = .( - (ESP.Config.BoxFillTransparency, , , ), , )
					box.Fill.Visible = 
				
					box.Fill.Visible = 
				
			
				box.Box.Visible = 
				box.Outline.Visible = 
				box.Fill.Visible = 
			

			 textOffset = 
			 ESP.State.WeaponEnabled 
				box.Weapon.Position = .(cx, maxY + textOffset)
				box.Weapon.Text = (t.WeaponName  )
				box.Weapon.Color = .(, , )
				box.Weapon.Visible = 
				textOffset = textOffset + 
			
				box.Weapon.Visible = 
			

			 ESP.State.DistanceEnabled 
				box.Distance.Position = .(cx, maxY + textOffset)
				box.Distance.Text = (.(dist)) .. 
				box.Distance.Color = .(, , )
				box.Distance.Visible = 
			
				box.Distance.Visible = 
			
		

		 ESP.State.SkeletonEnabled 
			 sk = ESP.Caches.Skeleton[key]
			  sk 
				sk = (model)
				ESP.Caches.Skeleton[key] = sk
			
			 idx = , #sk.Map 
				 seg = sk.Map[idx]
				 a = model:(seg[])
				 b = model:(seg[])
				 line = sk.Draw[idx]
				 a  b 
					 ap, aon = cam:(a.Position)
					 bp, bon = cam:(b.Position)
					 aon  bon  ap.Z >   bp.Z >  
						line.From = .(ap.X, ap.Y)
						line.To = .(bp.X, bp.Y)
						line.Color = ESP.Config.SkeletonColor
						line.Visible = 
					
						line.Visible = 
					
				
					line.Visible = 
				
			
		 ESP.Caches.Skeleton[key] 
			 _, line  (ESP.Caches.Skeleton[key].Draw) 
				line.Visible = 
			
		

		 ESP.State.TracerEnabled 
			 tr = ESP.Caches.Tracer[key]
			  tr 
				tr = ()
				ESP.Caches.Tracer[key] = tr
			
			 target = model:()  root
			 tp, on = cam:(target.Position)
			 vps = cam.ViewportSize
			 origin = .(vps.X * , vps.Y)
			 ESP.Config.TracerOrigin ==  
				origin = UserInputService:()
			 ESP.Config.TracerOrigin ==  
				origin = .(vps.X * , )
			
			tr.From = origin
			tr.To = .(tp.X, tp.Y)
			tr.Color = ESP.Config.TracerColor
			tr.Visible = on
		 ESP.Caches.Tracer[key] 
			ESP.Caches.Tracer[key].Visible = 
		

		 ESP.State.ChamsEnabled 
			 cc = ESP.Caches.Chams[key]
			  cc 
				cc = ()
				ESP.Caches.Chams[key] = cc
			
			 touched = {}
			 mat = ESP.Config.ChamsMaterial
			 col = ESP.Config.ChamsColor
			 alpha = (ESP.Config.ChamsFillTransparency, , , )
			 _, part  (model:()) 
				 part:()   (part.Parent  part.Parent:()) 
					(cc, part, mat, col, alpha)
					touched[part] = 
				
			
			 part, _  (cc.Parts) 
				  touched[part]   part.Parent   part:(model) 
					(cc, part)
				
			
		 ESP.Caches.Chams[key] 
			 part, _  (ESP.Caches.Chams[key].Parts) 
				(ESP.Caches.Chams[key], part)
			
		

		 ESP.State.RingEnabled 
			 rc = ESP.Caches.Ring[key]
			  rc 
				rc = ()
				ESP.Caches.Ring[key] = rc
			
			rc.Root = root
			rc.Ring.Color3 = ESP.Config.RingColor
			rc.Ring.InnerRadius = ESP.Config.RingRadius - 
			rc.Ring.Radius = ESP.Config.RingRadius
			rc.Ring.Visible = 
			 bob = .(() * ESP.Config.ScanSpeed) * ESP.Config.ScanHeight
			rc.Holder.CFrame = root.CFrame * .(, bob, )
			rc.Ring.Transparency =  + (.(.(() * ESP.Config.ScanSpeed)) * )
			 ESP.Caches.Ring[key] 
				ESP.Caches.Ring[key].Ring.Visible = 
			
		

		 ItemESP.State.Enabled 
			()
			 itemActive = {}
			 camPos = cam.CFrame.Position
			 node, sourceType  (ItemESP.Runtime.Nodes) 
				 node  node.Parent 
					 worldPos = (node, sourceType)
					 worldPos 
						 dist = (camPos - worldPos).Magnitude
						 text = ItemESP.Caches.Text[node]
						  text 
							text = ()
							ItemESP.Caches.Text[node] = text
						
						 dist <= ItemESP.Config.Distance 
							 vp, onScreen = cam:(worldPos)
							 onScreen  vp.Z >  
								text.Text = 
								text.Position = .(vp.X, vp.Y)
								text.Visible = 
								itemActive[node] = 
							
								text.Visible = 
							
						
							text.Visible = 
						
					
				
			
			 node, text  (ItemESP.Caches.Text) 
				  itemActive[node] 
					text.Visible = 
				
				  node   node.Parent 
					(text)
					ItemESP.Caches.Text[node] = 
				
			
		
		 LootBoxESP.State.Enabled 
			()
			 lootActive = {}
			 camPos = cam.CFrame.Position
			 key, entry  (LootBoxESP.Runtime.Entries) 
				 instance = entry  entry.Instance
				 instance  instance.Parent 
					 worldPos = (instance)
					 worldPos 
						 dist = (camPos - worldPos).Magnitude
						 text = LootBoxESP.Caches.Text[key]
						  text 
							text = ()
							LootBoxESP.Caches.Text[key] = text
						
						 dist <= LootBoxESP.Config.Distance 
							 vp, onScreen = cam:(worldPos)
							 onScreen  vp.Z >  
								text.Text = 
								text.Position = .(vp.X, vp.Y)
								text.Visible = 
								lootActive[key] = 
							
								text.Visible = 
							
						
							text.Visible = 
						
					
				
			
			 key, text  (LootBoxESP.Caches.Text) 
				  lootActive[key] 
					text.Visible = 
				
				  key   key.Parent 
					(text)
					LootBoxESP.Caches.Text[key] = 
				
			
		
	)

  (callback)
	 ok = (callback, ESP)
	 ok


 espSection = VisualPage:({ Name = , Side =  })
espSection:()
 chamsSection = VisualPage:({ Name = , Side =  })
 itemsSection = ItemsPage:({ Name = , Side =  })

espSection:({
	Name = ,
	Flag = ,
	Default = ,
	Callback = (v)
		((esp)
			esp.State.BoxEnabled = (v == )
		)
	,
})

espSection:({
	Name = ,
	Flag = ,
	Default = ,
	Callback = (v)
		((esp)
			esp.Config.TeamCheck = (v == )
		)
	,
})

espSection:({
	Name = ,
	Flag = ,
	Default = ,
	Callback = (_)
	,
})

espSection:():({
	Name = ,
	Flag = ,
	Default = .(, , ),
	Alpha = ,
	Callback = (v)
		ESP.Config.BoxColor = v
	,
})

espSection:({
	Name = ,
	Flag = ,
	Default = ,
	Callback = (v)
		ESP.Config.BoxGradientEnabled = (v == )
	,
})

espSection:():({
	Name = ,
	Flag = ,
	Default = .(, , ),
	Alpha = ,
	Callback = (v)
		ESP.Config.BoxGradientColor1 = v
	,
})

espSection:():({
	Name = ,
	Flag = ,
	Default = .(, , ),
	Alpha = ,
	Callback = (v)
		ESP.Config.BoxGradientColor2 = v
	,
})

espSection:({
	Name = ,
	Flag = ,
	Min = ,
	Max = ,
	Default = ,
	Decimals = ,
	Callback = (v)
		ESP.Config.BoxFillTransparency = (v, , , )
	,
})

espSection:({
	Name = ,
	Flag = ,
	Default = ,
	Callback = (v)
		ESP.Config.BoxOutlineEnabled = (v == )
	,
})

espSection:():({
	Name = ,
	Flag = ,
	Default = .(, , ),
	Alpha = ,
	Callback = (v)
		ESP.Config.BoxOutlineColor = v
	,
})

espSection:({
	Name = ,
	Flag = ,
	Default = ,
	Callback = (v)
		ESP.State.RingEnabled = (v == )
	,
})

espSection:():({
	Name = ,
	Flag = ,
	Default = .(, , ),
	Alpha = ,
	Callback = (v)
		ESP.Config.RingColor = v
	,
})

espSection:({
	Name = ,
	Flag = ,
	Default = ,
	Callback = (v)
		ESP.State.WeaponEnabled = (v == )
	,
})

espSection:({
	Name = ,
	Flag = ,
	Default = ,
	Callback = (v)
		ESP.State.DistanceEnabled = (v == )
	,
})

espSection:({
	Name = ,
	Flag = ,
	Default = ,
	Callback = (v)
		ESP.State.SkeletonEnabled = (v == )
	,
})

espSection:():({
	Name = ,
	Flag = ,
	Default = .(, , ),
	Alpha = ,
	Callback = (v)
		ESP.Config.SkeletonColor = v
	,
})

espSection:({
	Name = ,
	Flag = ,
	Default = ,
	Callback = (v)
		ESP.State.TracerEnabled = (v == )
	,
})

espSection:():({
	Name = ,
	Flag = ,
	Default = .(, , ),
	Alpha = ,
	Callback = (v)
		ESP.Config.TracerColor = v
	,
})

espSection:({
	Name = ,
	Flag = ,
	Items = { , ,  },
	Default = ,
	Multi = ,
	Callback = (v)
		ESP.Config.TracerOrigin = (v  )
	,
})

chamsSection:({
	Name = ,
	Flag = ,
	Default = ,
	Callback = (v)
		ESP.State.ChamsEnabled = (v == )
	,
})

chamsSection:():({
	Name = ,
	Flag = ,
	Default = .(, , ),
	Alpha = ,
	Callback = (v)
		ESP.Config.ChamsColor = v
	,
})

chamsSection:({
	Name = ,
	Flag = ,
	Items = CHAMS_MATERIAL_OPTIONS,
	Default = ,
	Multi = ,
	Callback = (v)
		ESP.Config.ChamsMaterial = (v, .Material.ForceField)
	,
})

chamsSection:({
	Name = ,
	Flag = ,
	Min = ,
	Max = ,
	Default = ,
	Decimals = ,
	Callback = (v)
		ESP.Config.ChamsFillTransparency = (v, , , )
	,
})

espSection:({
	Name = ,
	Flag = ,
	Min = ,
	Max = ,
	Default = ,
	Decimals = ,
	Callback = (v)
		ESP.Config.ESPDistance = (v, , , )
	,
})

itemsSection:({
	Name = ,
	Flag = ,
	Default = ,
	Callback = (v)
		ItemESP.State.Enabled = (v == )
	,
})

itemsSection:({
	Name = ,
	Flag = ,
	Min = ,
	Max = ,
	Default = ,
	Decimals = ,
	Callback = (v)
		ItemESP.Config.Distance = (v, , , )
	,
})

itemsSection:({
	Name = ,
	Flag = ,
	Default = ,
	Callback = (v)
		LootBoxESP.State.Enabled = (v == )
	,
})

itemsSection:({
	Name = ,
	Flag = ,
	Min = ,
	Max = ,
	Default = ,
	Decimals = ,
	Callback = (v)
		LootBoxESP.Config.Distance = (v, , , )
	,
})

itemsSection:():({
	Name = ,
	Flag = ,
	Default = .KeyCode.H,
	Mode = ,
	Callback = (active)
		 active ==  
			 GrabAllRuntime.HoldActive 
				
			
			GrabAllRuntime.HoldActive = 
			()
		
			GrabAllRuntime.HoldActive = 
		
	,
})