getgenv().

GG = {
Language = {
CheckboxEnabled = "Enabled",
CheckboxDisabled = "Disabled",
SliderValue = "Value",
DropdownSelect = "Select",
DropdownNone = "None",
DropdownSelected = "Selected",
ButtonClick = "Click",
TextboxEnter = "Enter",
ModuleEnabled = "Enabled",
ModuleDisabled = "Disabled",
TabGeneral = "General",
TabSettings = "Settings",
Loading = "Loading...",
Error = "Error",
Success = "Success"
}
}

-- Replace the SelectedLanguage with a reference to GG.Language

local SelectedLanguage = GG.Language

function convertStringToTable(inputString)
local result = {}
for value in string.gmatch(inputString, "([^,]+)") do
local trimmedValue = value:match("^%s*(.-)%s*$")
table.insert(result, trimmedValue)
end
return result
end

function convertTableToString(inputTable)
return table.concat(inputTable, ", ")
end

local UserInputService = game:GetService('UserInputService')

local ContentProvider = game:GetService('ContentProvider')
local TweenService = game:GetService('TweenService')
local HttpService = game:GetService('HttpService')
local TextService = game:GetService('TextService')
local RunService = game:GetService('RunService')
local Lighting = game:GetService('Lighting')
local Players = game:GetService('Players')
local CoreGui = game:GetService('CoreGui')
local Debris = game:GetService('Debris')
local VirtualInputManager = game:GetService('VirtualInputManager')

-----------------------------------------------------------
-- AUTO PARRY AND SPAM SYSTEM INTEGRATION
-----------------------------------------------------------
local LocalPlayer = Players.LocalPlayer
local Character = LocalPlayer.Character or LocalPlayer.CharacterAdded:Wait()
local Humanoid = Character:FindFirstChildOfClass("Humanoid")
local Workspace = game:GetService("Workspace")
local ServerStatsItem = game:GetService("Stats").Network.ServerStatsItem
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Aerodynamic = false
local Aerodynamic_Time = tick()
local Last_Input = UserInputService:GetLastInputType()
local Alive = workspace.Alive
local Vector2_Mouse_Location = nil
local Grab_Parry = nil
local pingBased = true
local Remotes = {}
local Parry_Key = nil
local Spamming = false
local SpamSpeed = 7
local InfinityD, TimeHoleD, SingularityD, SOFD, Abil, CDP, Phantom = false, false,
false, false, false, false, false
local EffectClasses = {ParticleEmitter=true, Beam=true, Trail=true, Explosion=true}
local Connections_Manager = {}
local Parried = false
local Last_Parry = 0
local NoRender = nil
local Xurr = (0.7 + (8 - 1) * (0.35 / 99))
local Closest_Entity = nil
local strafeEnabled, autoClaimRewards, CameraFOVEnabled = false, false, false
local StrafeSpeed, CameraFOV = 36, 70

-- Find remote keys

task.spawn(function()
for _, Value in pairs(getgc()) do
if ((type(Value) == "function") and islclosure(Value)) then
if debug.getupvalues(Value) then
local Protos = debug.getprotos(Value)
local Upvalues = debug.getupvalues(Value)
local Constants = debug.getconstants(Value)
if ((#Protos == 4) and (#Upvalues == 24) and (#Constants == 104))
then
Remotes[debug.getupvalue(Value, 16)] = debug.getconstant(Value,
62)
Parry_Key = debug.getupvalue(Value, 17)
Remotes[debug.getupvalue(Value, 18)] = debug.getconstant(Value,
64)
Remotes[debug.getupvalue(Value, 19)] = debug.getconstant(Value,
65)
break
end
end
end
end
end)

local Key = Parry_Key

local Parries = 0
local Selected_Parry_Type = "Straight"

local StarX = {}

StarX.FetchBalls = function()
local folder =
workspace:FindFirstChild(workspace.Alive:FindFirstChild(tostring(LocalPlayer)) and
"Balls" or "TrainingBalls")
if not folder then return {} end

local balls = {}
 for _, ball in ipairs(folder:GetChildren()) do
if ball:GetAttribute("realBall") then
ball.CanCollide = false
balls[#balls + 1] = ball
end
end
return balls
end

StarX.FetchBall = function()
local folder =
workspace:FindFirstChild(workspace.Alive:FindFirstChild(tostring(LocalPlayer)) and
"Balls" or "TrainingBalls")
if not folder then return end

for _, ball in ipairs(folder:GetChildren()) do

if ball:GetAttribute("realBall") then
ball.CanCollide = false
return ball
end
end
end

StarX.Parry_Data = function()
local cam, char = workspace.CurrentCamera, LocalPlayer.Character
if not cam then return {0, CFrame.new(), {}, {0, 0}} end
local hrp = char and char:FindFirstChild("HumanoidRootPart")
if not hrp then return {0, CFrame.new(), {}, {0, 0}} end

local ccf, cpos, look, right, up = cam.CFrame, cam.CFrame.Position,

cam.CFrame.LookVector, cam.CFrame.RightVector, cam.CFrame.UpVector
local vs = cam.ViewportSize
local mouse = (Last_Input == Enum.UserInputType.MouseButton1 or Last_Input ==
Enum.UserInputType.MouseButton2 or Last_Input == Enum.UserInputType.Keyboard)
and UserInputService:GetMouseLocation() or Vector2.new(vs.X * 0.5, vs.Y *
0.5)
Vector2_Mouse_Location = {mouse.X, mouse.Y}

local events = {}
for _, v in ipairs(workspace.Alive:GetChildren()) do
local pp = v.PrimaryPart
if pp then events[tostring(v)] = cam:WorldToScreenPoint(pp.Position) end
end

local dirCF
if Selected_Parry_Type == "Straight" then
local closest, dist, mv = nil, math.huge, Vector2.new(mouse.X, mouse.Y)
for _, v in ipairs(workspace.Alive:GetChildren()) do
if v ~= char and v.PrimaryPart then
local pos, onScreen =
cam:WorldToScreenPoint(v.PrimaryPart.Position)
if onScreen then
local d = (mv - Vector2.new(pos.X, pos.Y)).Magnitude
if d < dist then dist, closest = d, v end
end
end
end
local target = closest or StarX.Get_Closest()
dirCF = CFrame.new(hrp.Position, (target and target.PrimaryPart and
target.PrimaryPart.Position) or (hrp.Position + look * 100))
else
local dirs = {
Custom = ccf,
Random = CFrame.new(cpos, Vector3.new(math.random(-3e3, 3e3),
math.random(-3e3, 3e3), math.random(-3e3, 3e3))),
Backwards = CFrame.new(cpos, cpos - look * 1e3),
Up = CFrame.new(cpos, cpos + up * 1e3),
Right = CFrame.new(cpos, cpos + right * 1e3),
Left = CFrame.new(cpos, cpos - right * 1e3)
}
dirCF = dirs[Selected_Parry_Type] or ccf
end

return {0, dirCF, events, Vector2_Mouse_Location}

end

StarX.Parry = function()
local data = StarX.Parry_Data()
for r, a in pairs(Remotes) do
r:FireServer(a, Key, data[1], data[2], data[3], data[4])
end
if Parries > 7 then return false end
Parries = Parries + 1
task.delay(0.6, function() if Parries > 0 then Parries = Parries - 1 end end)
end

local Runtime = workspace:FindFirstChild("Runtime")

local Tornado_Time = tick()
local LR, VelHist, LastWarp, LastCurve = 0, {}, tick(), tick()

StarX.Lerp = function(a, b, t) return a + (b - a) * t end

local Angle = function(a, b) return math.deg(math.acos(math.clamp(a:Dot(b), -1,

1))) end

function StarX.Curved()
local b = StarX.FetchBall()
if not b or not b:FindFirstChild('zoomies') then return false end

local z, v = b.zoomies, b.zoomies.VectorVelocity

local s, d = v.Magnitude, v.Unit
local r = LocalPlayer.Character and LocalPlayer.Character.PrimaryPart
if not r then return false end

local p, bp = r.Position, b.Position

local dir, dist = (p - bp).Unit, (p - bp).Magnitude
local dot = dir:Dot(d)
local ping = ServerStatsItem["Data Ping"]:GetValue()

if ping > 150 then

ping = ping * 1.1
elseif ping > 200 then
ping = ping * 1.25
end

table.insert(VelHist, v)
if #VelHist > 4 then table.remove(VelHist, 1) end
 local rt = dist / s - ping / 985
local dT = 15 - math.min(dist / 1000, 15) + math.min(s / 100, 40)

if b:FindFirstChild("AeroDynamicSlashVFX") then
Debris:AddItem(b.AeroDynamicSlashVFX, 0)
Tornado_Time = tick()
end

if Runtime:FindFirstChild("Tornado") and (tick() - Tornado_Time) <

((Runtime.Tornado:GetAttribute("TornadoTime") or 1) + 0.314159) then
return true
end

if s > 160 and rt > ping / 9.85 then

local adjust = s < 300 and 15 or s < 600 and 16 or s < 1000 and 17 or s <
1500 and 19 or 20
dT = math.max(dT - adjust, adjust)
end

if dist < dT then return false end

local curve_time = s < 300 and rt / 1.2 or s < 450 and rt / 1.21 or s < 600 and
rt / 1.335 or rt / 1.5
if (tick() - LastCurve) < curve_time then return true end

local dth = 0.485 - ping / 985

local diff = dir:Dot((d - v.Unit).Unit)
if (dot - diff) < dth then return true end

local rad = math.deg(math.asin(math.clamp(dot, -1, 1)))

LR = StarX.Lerp(LR, rad, 0.8)

local warp_time = s < 300 and rt / 1.185 or rt / 1.5

local warp_thres = s < 300 and 0.0205 or 0.018
if LR < warp_thres then LastWarp = tick() end
if (tick() - LastWarp) < warp_time then return true end

if #VelHist == 4 then
local dv = function(i) return dir:Dot((d - VelHist[i].Unit).Unit) end
if dot - dv(1) < dth or dot - dv(2) < dth then return true end
end

local hp = Vector3.new(p.X - bp.X, 0, p.Z - bp.Z).Unit

local bd = Vector3.new(d.X, 0, d.Z).Unit
if hp.Magnitude > 0 and bd.Magnitude > 0 then
local back = math.deg(math.acos(math.clamp((-hp):Dot(bd), -1, 1)))
if back < 90 - ping / 25 then return true end
end

return dot < dth

end

StarX.Get_Closest = function()
local Max_Distance = math.huge
for _, Entity in pairs(workspace.Alive:GetChildren()) do
if (tostring(Entity) ~= tostring(LocalPlayer)) then
local Distance =
LocalPlayer:DistanceFromCharacter(Entity.PrimaryPart.Position)
if (Distance < Max_Distance) then
 Max_Distance = Distance
Closest_Entity = Entity
end
end
end
return Closest_Entity
end

local mouse = Players.LocalPlayer:GetMouse()

local old_March = CoreGui:FindFirstChild('March')

if old_March then
Debris:AddItem(old_March, 0)
end

if not isfolder("March") then

makefolder("March")
end

local Connections = setmetatable({

disconnect = function(self, connection)
if not self[connection] then
return
end
self[connection]:Disconnect()
self[connection] = nil
end,
disconnect_all = function(self)
for _, value in self do
if typeof(value) == 'function' then
continue
end
value:Disconnect()
end
end
}, Connections)

local Util = setmetatable({

map = function(self: any, value: number, in_minimum: number, in_maximum:
number, out_minimum: number, out_maximum: number)
return (value - in_minimum) * (out_maximum - out_minimum) / (in_maximum -
in_minimum) + out_minimum
end,
viewport_point_to_world = function(self: any, location: any, distance: number)
local unit_ray = workspace.CurrentCamera:ScreenPointToRay(location.X,
location.Y)
return unit_ray.Origin + unit_ray.Direction * distance
end,
get_offset = function(self: any)
local viewport_size_Y = workspace.CurrentCamera.ViewportSize.Y
return self:map(viewport_size_Y, 0, 2560, 8, 56)
end
}, Util)

local Config = setmetatable({

save = function(self: any, file_name: any, config: any)
local success_save, result = pcall(function()
local flags = HttpService:JSONEncode(config)
writefile('March/'..file_name..'.json', flags)
 end)
if not success_save then
warn('failed to save config', result)
end
end,
load = function(self: any, file_name: any, config: any)
local success_load, result = pcall(function()
if not isfile('March/'..file_name..'.json') then
self:save(file_name, config)
return
end
local flags = readfile('March/'..file_name..'.json')
if not flags then
self:save(file_name, config)
return
end
return HttpService:JSONDecode(flags)
end)
if not success_load then
warn('failed to load config', result)
end
if not result then
result = {
_flags = {},
_keybinds = {},
_library = {}
}
end
return result
end
}, Config)

local Library = {
_config = Config:load(game.GameId),
_choosing_keybind = false,
_device = nil,
_ui_open = true,
_ui_scale = 1,
_ui_loaded = false,
_ui = nil,
_dragging = false,
_drag_start = nil,
_container_position = nil
}
Library.__index = Library

function Library.new()
local self = setmetatable({
_loaded = false,
_tab = 0,
}, Library)
self:create_ui()
return self
end

-- Create Notification Container

local NotificationContainer = Instance.new("Frame")
NotificationContainer.Name = "RobloxCoreGuis"
NotificationContainer.Size = UDim2.new(0, 300, 0, 0)
NotificationContainer.Position = UDim2.new(0.8, 0, 0, 10)
NotificationContainer.BackgroundTransparency = 1
NotificationContainer.ClipsDescendants = false
NotificationContainer.Parent =
game:GetService("CoreGui").RobloxGui:FindFirstChild("RobloxCoreGuis") or
Instance.new("ScreenGui", game:GetService("CoreGui").RobloxGui)
NotificationContainer.AutomaticSize = Enum.AutomaticSize.Y

-- UIListLayout to arrange notifications vertically

local UIListLayout = Instance.new("UIListLayout")
UIListLayout.FillDirection = Enum.FillDirection.Vertical
UIListLayout.SortOrder = Enum.SortOrder.LayoutOrder
UIListLayout.Padding = UDim.new(0, 10)
UIListLayout.Parent = NotificationContainer

-- Function to create notifications

function Library.SendNotification(settings)
-- Create the notification frame
local Notification = Instance.new("Frame")
Notification.Size = UDim2.new(1, 0, 0, 60)
Notification.BackgroundTransparency = 1
Notification.BorderSizePixel = 0
Notification.Name = "Notification"
Notification.Parent = NotificationContainer
Notification.AutomaticSize = Enum.AutomaticSize.Y

-- Add rounded corners to outer frame

local UICorner = Instance.new("UICorner")
UICorner.CornerRadius = UDim.new(0, 4)
UICorner.Parent = Notification

-- Create the inner frame for the notification's content

local InnerFrame = Instance.new("Frame")
InnerFrame.Size = UDim2.new(1, 0, 0, 60)
InnerFrame.Position = UDim2.new(0, 0, 0, 0)
InnerFrame.BackgroundColor3 = Color3.fromRGB(32, 38, 51)
InnerFrame.BackgroundTransparency = 0.1
InnerFrame.BorderSizePixel = 0
InnerFrame.Name = "InnerFrame"
InnerFrame.Parent = Notification
InnerFrame.AutomaticSize = Enum.AutomaticSize.Y

-- Add rounded corners to the inner frame

local InnerUICorner = Instance.new("UICorner")
InnerUICorner.CornerRadius = UDim.new(0, 4)
InnerUICorner.Parent = InnerFrame

-- Title Label (with automatic size support)

local Title = Instance.new("TextLabel")
Title.Text = settings.title or "Notification Title"
Title.TextColor3 = Color3.fromRGB(210, 210, 210)
Title.FontFace = Font.new('rbxasset://fonts/families/GothamSSm.json',
Enum.FontWeight.SemiBold, Enum.FontStyle.Normal)
Title.TextSize = 14
Title.Size = UDim2.new(1, -10, 0, 20)
Title.Position = UDim2.new(0, 5, 0, 5)
Title.BackgroundTransparency = 1
Title.TextXAlignment = Enum.TextXAlignment.Left
Title.TextYAlignment = Enum.TextYAlignment.Center
 Title.TextWrapped = true
Title.AutomaticSize = Enum.AutomaticSize.Y
Title.Parent = InnerFrame

-- Body Text (with automatic size support)

local Body = Instance.new("TextLabel")
Body.Text = settings.text or "This is the body of the notification."
Body.TextColor3 = Color3.fromRGB(180, 180, 180)
Body.FontFace = Font.new('rbxasset://fonts/families/GothamSSm.json',
Enum.FontWeight.Regular, Enum.FontStyle.Normal)
Body.TextSize = 12
Body.Size = UDim2.new(1, -10, 0, 30)
Body.Position = UDim2.new(0, 5, 0, 25)
Body.BackgroundTransparency = 1
Body.TextXAlignment = Enum.TextXAlignment.Left
Body.TextYAlignment = Enum.TextYAlignment.Top
Body.TextWrapped = true
Body.AutomaticSize = Enum.AutomaticSize.Y
Body.Parent = InnerFrame

-- Force the size to adjust after the text is fully loaded and wrapped
task.spawn(function()
wait(0.1)
local totalHeight = Title.TextBounds.Y + Body.TextBounds.Y + 10
InnerFrame.Size = UDim2.new(1, 0, 0, totalHeight)
end)

-- Use task.spawn to ensure the notification tweening happens asynchronously

task.spawn(function()
-- Tween In the Notification (inner frame)
local tweenIn = TweenService:Create(InnerFrame, TweenInfo.new(0.5,
Enum.EasingStyle.Quint, Enum.EasingDirection.Out), {
Position = UDim2.new(0, 0, 0, 10 + NotificationContainer.Size.Y.Offset)
})
tweenIn:Play()

-- Wait for the duration before tweening out

local duration = settings.duration or 5
wait(duration)

-- Tween Out the Notification (inner frame) to the right side of the screen
local tweenOut = TweenService:Create(InnerFrame, TweenInfo.new(0.5,
Enum.EasingStyle.Quint, Enum.EasingDirection.In), {
Position = UDim2.new(1, 310, 0, 10 +
NotificationContainer.Size.Y.Offset)
})
tweenOut:Play()

-- Remove the notification after it is done tweening out

tweenOut.Completed:Connect(function()
Notification:Destroy()
end)
end)
end

function Library:get_screen_scale()
local viewport_size_x = workspace.CurrentCamera.ViewportSize.X
self._ui_scale = viewport_size_x / 1400
end
function Library:get_device()
local device = 'Unknown'
if not UserInputService.TouchEnabled and UserInputService.KeyboardEnabled and
UserInputService.MouseEnabled then
device = 'PC'
elseif UserInputService.TouchEnabled then
device = 'Mobile'
elseif UserInputService.GamepadEnabled then
device = 'Console'
end
self._device = device
end

function Library:removed(action: any)

self._ui.AncestryChanged:Once(action)
end

function Library:flag_type(flag: any, flag_type: any)

if not Library._config._flags[flag] then
return
end
return typeof(Library._config._flags[flag]) == flag_type
end

function Library:remove_table_value(__table: any, table_value: string)

for index, value in __table do
if value ~= table_value then
continue
end
table.remove(__table, index)
end
end

function Library:create_ui()
local old_March = CoreGui:FindFirstChild('March')
if old_March then
Debris:AddItem(old_March, 0)
end

local March = Instance.new('ScreenGui')

March.ResetOnSpawn = false
March.Name = 'ikorz'
March.ZIndexBehavior = Enum.ZIndexBehavior.Sibling
March.Parent = CoreGui

local Container = Instance.new('Frame')

Container.ClipsDescendants = true
Container.BorderColor3 = Color3.fromRGB(0, 0, 0)
Container.AnchorPoint = Vector2.new(0.5, 0.5)
Container.Name = 'Container'
Container.BackgroundTransparency = 0.05000000074505806
Container.BackgroundColor3 = Color3.fromRGB(12, 13, 15)
Container.Position = UDim2.new(0.5, 0, 0.5, 0)
Container.Size = UDim2.new(0, 0, 0, 0)
Container.Active = true
Container.BorderSizePixel = 0
Container.Parent = March
 local UICorner = Instance.new('UICorner')
UICorner.CornerRadius = UDim.new(0, 10)
UICorner.Parent = Container

local UIStroke = Instance.new('UIStroke')

UIStroke.Color = Color3.fromRGB(52, 66, 89)
UIStroke.Transparency = 0.5
UIStroke.ApplyStrokeMode = Enum.ApplyStrokeMode.Border
UIStroke.Parent = Container

local Handler = Instance.new('Frame')

Handler.BackgroundTransparency = 1
Handler.Name = 'Handler'
Handler.BorderColor3 = Color3.fromRGB(0, 0, 0)
Handler.Size = UDim2.new(0, 698, 0, 479)
Handler.BorderSizePixel = 0
Handler.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
Handler.Parent = Container

local Tabs = Instance.new('ScrollingFrame')

Tabs.ScrollBarImageTransparency = 1
Tabs.ScrollBarThickness = 0
Tabs.Name = 'Tabs'
Tabs.Size = UDim2.new(0, 129, 0, 401)
Tabs.Selectable = false
Tabs.AutomaticCanvasSize = Enum.AutomaticSize.XY
Tabs.BackgroundTransparency = 1
Tabs.Position = UDim2.new(0.026097271591424942, 0, 0.1111111119389534, 0)
Tabs.BorderColor3 = Color3.fromRGB(0, 0, 0)
Tabs.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
Tabs.BorderSizePixel = 0
Tabs.CanvasSize = UDim2.new(0, 0, 0.5, 0)
Tabs.Parent = Handler

local UIListLayout = Instance.new('UIListLayout')

UIListLayout.Padding = UDim.new(0, 4)
UIListLayout.SortOrder = Enum.SortOrder.LayoutOrder
UIListLayout.Parent = Tabs

local ClientName = Instance.new('TextLabel')

ClientName.FontFace = Font.new('rbxasset://fonts/families/GothamSSm.json',
Enum.FontWeight.SemiBold, Enum.FontStyle.Normal)
ClientName.TextColor3 = Color3.fromRGB(152, 181, 255)
ClientName.TextTransparency = 0.20000000298023224
ClientName.Text = 'ikorz'
ClientName.Name = 'ClientName'
ClientName.Size = UDim2.new(0, 31, 0, 13)
ClientName.AnchorPoint = Vector2.new(0, 0.5)
ClientName.Position = UDim2.new(0.0560000017285347, 0, 0.054999999701976776, 0)
ClientName.BackgroundTransparency = 1
ClientName.TextXAlignment = Enum.TextXAlignment.Left
ClientName.BorderSizePixel = 0
ClientName.BorderColor3 = Color3.fromRGB(0, 0, 0)
ClientName.TextSize = 13
ClientName.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
ClientName.Parent = Handler

local UIGradient = Instance.new('UIGradient')

UIGradient.Color = ColorSequence.new{
 ColorSequenceKeypoint.new(0, Color3.fromRGB(155, 155, 155)),
ColorSequenceKeypoint.new(1, Color3.fromRGB(255, 255, 255))
}
UIGradient.Parent = ClientName

local Pin = Instance.new('Frame')

Pin.Name = 'Pin'
Pin.Position = UDim2.new(0.026000000536441803, 0, 0.13600000739097595, 0)
Pin.BorderColor3 = Color3.fromRGB(0, 0, 0)
Pin.Size = UDim2.new(0, 2, 0, 16)
Pin.BorderSizePixel = 0
Pin.BackgroundColor3 = Color3.fromRGB(152, 181, 255)
Pin.Parent = Handler

local UICorner = Instance.new('UICorner')

UICorner.CornerRadius = UDim.new(1, 0)
UICorner.Parent = Pin

local Icon = Instance.new('ImageLabel')

Icon.ImageColor3 = Color3.fromRGB(152, 181, 255)
Icon.ScaleType = Enum.ScaleType.Fit
Icon.BorderColor3 = Color3.fromRGB(0, 0, 0)
Icon.AnchorPoint = Vector2.new(0, 0.5)
Icon.Image = 'rbxassetid://107819132007001'
Icon.BackgroundTransparency = 1
Icon.Position = UDim2.new(0.02500000037252903, 0, 0.054999999701976776, 0)
Icon.Name = 'Icon'
Icon.Size = UDim2.new(0, 18, 0, 18)
Pin.BorderSizePixel = 0
Icon.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
Icon.Parent = Handler

local Divider = Instance.new('Frame')

Divider.Name = 'Divider'
Divider.BackgroundTransparency = 0.5
Divider.Position = UDim2.new(0.23499999940395355, 0, 0, 0)
Divider.BorderColor3 = Color3.fromRGB(0, 0, 0)
Divider.Size = UDim2.new(0, 1, 0, 479)
Divider.BorderSizePixel = 0
Divider.BackgroundColor3 = Color3.fromRGB(52, 66, 89)
Divider.Parent = Handler

local Sections = Instance.new('Folder')

Sections.Name = 'Sections'
Sections.Parent = Handler

local Minimize = Instance.new('TextButton')

Minimize.FontFace = Font.new('rbxasset://fonts/families/SourceSansPro.json',
Enum.FontWeight.Regular, Enum.FontStyle.Normal)
Minimize.TextColor3 = Color3.fromRGB(0, 0, 0)
Minimize.BorderColor3 = Color3.fromRGB(0, 0, 0)
Minimize.Text = ''
Minimize.AutoButtonColor = false
Minimize.Name = 'Minimize'
Minimize.BackgroundTransparency = 1
Minimize.Position = UDim2.new(0.020057305693626404, 0, 0.02922755666077137, 0)
Minimize.Size = UDim2.new(0, 24, 0, 24)
Minimize.BorderSizePixel = 0
Minimize.TextSize = 14
 Minimize.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
Minimize.Parent = Handler

local UIScale = Instance.new('UIScale')

UIScale.Parent = Container

self._ui = March

local function on_drag(input: InputObject, process: boolean)

if input.UserInputType == Enum.UserInputType.MouseButton1 or
input.UserInputType == Enum.UserInputType.Touch then
self._dragging = true
self._drag_start = input.Position
self._container_position = Container.Position

Connections['container_input_ended'] = input.Changed:Connect(function()
if input.UserInputState ~= Enum.UserInputState.End then
return
end
Connections:disconnect('container_input_ended')
self._dragging = false
end)
end
end

local function update_drag(input: any)

local delta = input.Position - self._drag_start
local position = UDim2.new(self._container_position.X.Scale,
self._container_position.X.Offset + delta.X, self._container_position.Y.Scale,
self._container_position.Y.Offset + delta.Y)
TweenService:Create(Container, TweenInfo.new(0.2), {
Position = position
}):Play()
end

local function drag(input: InputObject, process: boolean)

if not self._dragging then
return
end
if input.UserInputType == Enum.UserInputType.MouseMovement or
input.UserInputType == Enum.UserInputType.Touch then
update_drag(input)
end
end

Connections['container_input_began'] = Container.InputBegan:Connect(on_drag)
Connections['input_changed'] = UserInputService.InputChanged:Connect(drag)

self:removed(function()
self._ui = nil
Connections:disconnect_all()
end)

function self:Update1Run(a)
if a == "nil" then
Container.BackgroundTransparency = 0.05000000074505806;
else
pcall(function()
Container.BackgroundTransparency = tonumber(a);
 end);
end;
end;

function self:UIVisiblity()
March.Enabled = not March.Enabled;
end;

function self:change_visiblity(state: boolean)

if state then
TweenService:Create(Container, TweenInfo.new(0.5,
Enum.EasingStyle.Quint, Enum.EasingDirection.Out), {
Size = UDim2.fromOffset(698, 479)
}):Play()
else
TweenService:Create(Container, TweenInfo.new(0.5,
Enum.EasingStyle.Quint, Enum.EasingDirection.Out), {
Size = UDim2.fromOffset(104.5, 52)
}):Play()
end
end

function self:load()
local content = {}
for _, object in March:GetDescendants() do
if not object:IsA('ImageLabel') then
continue
end
table.insert(content, object)
end
ContentProvider:PreloadAsync(content)
self:get_device()

if self._device == 'Mobile' or self._device == 'Unknown' then

self:get_screen_scale()
UIScale.Scale = self._ui_scale
Connections['ui_scale'] =
workspace.CurrentCamera:GetPropertyChangedSignal('ViewportSize'):Connect(function()
self:get_screen_scale()
UIScale.Scale = self._ui_scale
end)
end
TweenService:Create(Container, TweenInfo.new(0.5, Enum.EasingStyle.Quint,
Enum.EasingDirection.Out), {
Size = UDim2.fromOffset(698, 479)
}):Play()
self._ui_loaded = true
end

function self:update_tabs(tab: TextButton)

for index, object in Tabs:GetChildren() do
if object.Name ~= 'Tab' then
continue
end
if object == tab then
if object.BackgroundTransparency ~= 0.5 then
local offset = object.LayoutOrder * (0.113 / 1.3)
TweenService:Create(Pin, TweenInfo.new(0.5,
Enum.EasingStyle.Quint, Enum.EasingDirection.Out), {
 Position = UDim2.fromScale(0.026, 0.135 + offset)
}):Play()
TweenService:Create(object, TweenInfo.new(0.5,
Enum.EasingStyle.Quint, Enum.EasingDirection.Out), {
BackgroundTransparency = 0.5
}):Play()
TweenService:Create(object.TextLabel, TweenInfo.new(0.5,
Enum.EasingStyle.Quint, Enum.EasingDirection.Out), {
TextTransparency = 0.2,
TextColor3 = Color3.fromRGB(152, 181, 255)
}):Play()
TweenService:Create(object.TextLabel.UIGradient,
TweenInfo.new(0.5, Enum.EasingStyle.Quint, Enum.EasingDirection.Out), {
Offset = Vector2.new(1, 0)
}):Play()
TweenService:Create(object.Icon, TweenInfo.new(0.5,
Enum.EasingStyle.Quint, Enum.EasingDirection.Out), {
ImageTransparency = 0.2,
ImageColor3 = Color3.fromRGB(152, 181, 255)
}):Play()
end
continue
end
if object.BackgroundTransparency ~= 1 then
TweenService:Create(object, TweenInfo.new(0.5,
Enum.EasingStyle.Quint, Enum.EasingDirection.Out), {
BackgroundTransparency = 1
}):Play()
TweenService:Create(object.TextLabel, TweenInfo.new(0.5,
Enum.EasingStyle.Quint, Enum.EasingDirection.Out), {
TextTransparency = 0.7,
TextColor3 = Color3.fromRGB(255, 255, 255)
}):Play()
TweenService:Create(object.TextLabel.UIGradient, TweenInfo.new(0.5,
Enum.EasingStyle.Quint, Enum.EasingDirection.Out), {
Offset = Vector2.new(0, 0)
}):Play()
TweenService:Create(object.Icon, TweenInfo.new(0.5,
Enum.EasingStyle.Quint, Enum.EasingDirection.Out), {
ImageTransparency = 0.8,
ImageColor3 = Color3.fromRGB(255, 255, 255)
}):Play()
end
end
end

function self:update_sections(left_section: ScrollingFrame, right_section:

ScrollingFrame)
for _, object in Sections:GetChildren() do
if object == left_section or object == right_section then
object.Visible = true
continue
end
object.Visible = false
end
end

function self:create_tab(title: string, icon: string)

local TabManager = {}
 local LayoutOrder = 0;
local font_params = Instance.new('GetTextBoundsParams')
font_params.Text = title
font_params.Font = Font.new('rbxasset://fonts/families/GothamSSm.json',
Enum.FontWeight.SemiBold, Enum.FontStyle.Normal)
font_params.Size = 13
font_params.Width = 10000
local font_size = TextService:GetTextBoundsAsync(font_params)
local first_tab = not Tabs:FindFirstChild('Tab')

local Tab = Instance.new('TextButton')

Tab.FontFace = Font.new('rbxasset://fonts/families/SourceSansPro.json',
Enum.FontWeight.Regular, Enum.FontStyle.Normal)
Tab.TextColor3 = Color3.fromRGB(0, 0, 0)
Tab.BorderColor3 = Color3.fromRGB(0, 0, 0)
Tab.Text = ''
Tab.AutoButtonColor = false
Tab.BackgroundTransparency = 1
Tab.Name = 'Tab'
Tab.Size = UDim2.new(0, 129, 0, 38)
Tab.BorderSizePixel = 0
Tab.TextSize = 14
Tab.BackgroundColor3 = Color3.fromRGB(22, 28, 38)
Tab.Parent = Tabs
Tab.LayoutOrder = self._tab

local UICorner = Instance.new('UICorner')

UICorner.CornerRadius = UDim.new(0, 5)
UICorner.Parent = Tab

local TextLabel = Instance.new('TextLabel')

TextLabel.FontFace = Font.new('rbxasset://fonts/families/GothamSSm.json',
Enum.FontWeight.SemiBold, Enum.FontStyle.Normal)
TextLabel.TextColor3 = Color3.fromRGB(255, 255, 255)
TextLabel.TextTransparency = 0.7
TextLabel.Text = title
TextLabel.Size = UDim2.new(0, font_size.X, 0, 16)
TextLabel.AnchorPoint = Vector2.new(0, 0.5)
TextLabel.Position = UDim2.new(0.2400001734495163, 0, 0.5, 0)
TextLabel.BackgroundTransparency = 1
TextLabel.TextXAlignment = Enum.TextXAlignment.Left
TextLabel.BorderSizePixel = 0
TextLabel.BorderColor3 = Color3.fromRGB(0, 0, 0)
TextLabel.TextSize = 13
TextLabel.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
TextLabel.Parent = Tab

local UIGradient = Instance.new('UIGradient')

UIGradient.Color = ColorSequence.new{
ColorSequenceKeypoint.new(0, Color3.fromRGB(255, 255, 255)),
ColorSequenceKeypoint.new(0.7, Color3.fromRGB(155, 155, 155)),
ColorSequenceKeypoint.new(1, Color3.fromRGB(58, 58, 58))
}
UIGradient.Parent = TextLabel

local Icon = Instance.new('ImageLabel')

Icon.ScaleType = Enum.ScaleType.Fit
Icon.ImageTransparency = 0.800000011920929
Icon.BorderColor3 = Color3.fromRGB(0, 0, 0)
Icon.AnchorPoint = Vector2.new(0, 0.5)
Icon.BackgroundTransparency = 1
Icon.Position = UDim2.new(0.10000000149011612, 0, 0.5, 0)
Icon.Name = 'Icon'
Icon.Image = icon
Icon.Size = UDim2.new(0, 12, 0, 12)
Icon.BorderSizePixel = 0
Icon.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
Icon.Parent = Tab

local LeftSection = Instance.new('ScrollingFrame')

LeftSection.Name = 'LeftSection'
LeftSection.AutomaticCanvasSize = Enum.AutomaticSize.XY
LeftSection.ScrollBarThickness = 0
LeftSection.Size = UDim2.new(0, 243, 0, 445)
LeftSection.Selectable = false
LeftSection.AnchorPoint = Vector2.new(0, 0.5)
LeftSection.ScrollBarImageTransparency = 1
LeftSection.BackgroundTransparency = 1
LeftSection.Position = UDim2.new(0.2594326436519623, 0, 0.5, 0)
LeftSection.BorderColor3 = Color3.fromRGB(0, 0, 0)
LeftSection.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
LeftSection.BorderSizePixel = 0
LeftSection.CanvasSize = UDim2.new(0, 0, 0.5, 0)
LeftSection.Visible = false
LeftSection.Parent = Sections

local UIListLayout = Instance.new('UIListLayout')

UIListLayout.Padding = UDim.new(0, 11)
UIListLayout.HorizontalAlignment = Enum.HorizontalAlignment.Center
UIListLayout.SortOrder = Enum.SortOrder.LayoutOrder
UIListLayout.Parent = LeftSection

local UIPadding = Instance.new('UIPadding')

UIPadding.PaddingTop = UDim.new(0, 1)
UIPadding.Parent = LeftSection

local RightSection = Instance.new('ScrollingFrame')

RightSection.Name = 'RightSection'
RightSection.AutomaticCanvasSize = Enum.AutomaticSize.XY
RightSection.ScrollBarThickness = 0
RightSection.Size = UDim2.new(0, 243, 0, 445)
RightSection.Selectable = false
RightSection.AnchorPoint = Vector2.new(0, 0.5)
RightSection.ScrollBarImageTransparency = 1
RightSection.BackgroundTransparency = 1
RightSection.Position = UDim2.new(0.6290000081062317, 0, 0.5, 0)
RightSection.BorderColor3 = Color3.fromRGB(0, 0, 0)
RightSection.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
RightSection.BorderSizePixel = 0
RightSection.CanvasSize = UDim2.new(0, 0, 0.5, 0)
RightSection.Visible = false
RightSection.Parent = Sections

local UIListLayout = Instance.new('UIListLayout')

UIListLayout.Padding = UDim.new(0, 11)
UIListLayout.HorizontalAlignment = Enum.HorizontalAlignment.Center
UIListLayout.SortOrder = Enum.SortOrder.LayoutOrder
UIListLayout.Parent = RightSection
 local UIPadding = Instance.new('UIPadding')
UIPadding.PaddingTop = UDim.new(0, 1)
UIPadding.Parent = RightSection

self._tab += 1
if first_tab then
self:update_tabs(Tab, LeftSection, RightSection)
self:update_sections(LeftSection, RightSection)
end

Tab.MouseButton1Click:Connect(function()
self:update_tabs(Tab, LeftSection, RightSection)
self:update_sections(LeftSection, RightSection)
end)

function TabManager:create_module(settings: any)

local LayoutOrderModule = 0;
local ModuleManager = {
_state = false,
_size = 0,
_multiplier = 0
}
if settings.section == 'right' then
settings.section = RightSection
else
settings.section = LeftSection
end

local Module = Instance.new('Frame')

Module.ClipsDescendants = true
Module.BorderColor3 = Color3.fromRGB(0, 0, 0)
Module.BackgroundTransparency = 0.5
Module.Position = UDim2.new(0.004115226212888956, 0, 0, 0)
Module.Name = 'Module'
Module.Size = UDim2.new(0, 241, 0, 93)
Module.BorderSizePixel = 0
Module.BackgroundColor3 = Color3.fromRGB(22, 28, 38)
Module.Parent = settings.section

local UIListLayout = Instance.new('UIListLayout')

UIListLayout.SortOrder = Enum.SortOrder.LayoutOrder
UIListLayout.Parent = Module

local UICorner = Instance.new('UICorner')

UICorner.CornerRadius = UDim.new(0, 5)
UICorner.Parent = Module

local UIStroke = Instance.new('UIStroke')

UIStroke.Color = Color3.fromRGB(52, 66, 89)
UIStroke.Transparency = 0.5
UIStroke.ApplyStrokeMode = Enum.ApplyStrokeMode.Border
UIStroke.Parent = Module

local Header = Instance.new('TextButton')

Header.FontFace = Font.new('rbxasset://fonts/families/SourceSansPro.json',
Enum.FontWeight.Regular, Enum.FontStyle.Normal)
Header.TextColor3 = Color3.fromRGB(0, 0, 0)
Header.BorderColor3 = Color3.fromRGB(0, 0, 0)
 Header.Text = ''
Header.AutoButtonColor = false
Header.BackgroundTransparency = 1
Header.Name = 'Header'
Header.Size = UDim2.new(0, 241, 0, 93)
Header.BorderSizePixel = 0
Header.TextSize = 14
Header.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
Header.Parent = Module

local Icon = Instance.new('ImageLabel')

Icon.ImageColor3 = Color3.fromRGB(152, 181, 255)
Icon.ScaleType = Enum.ScaleType.Fit
Icon.ImageTransparency = 0.699999988079071
Icon.BorderColor3 = Color3.fromRGB(0, 0, 0)
Icon.AnchorPoint = Vector2.new(0, 0.5)
Icon.Image = 'rbxassetid://79095934438045'
Icon.BackgroundTransparency = 1
Icon.Position = UDim2.new(0.07100000232458115, 0, 0.8199999928474426, 0)
Icon.Name = 'Icon'
Icon.Size = UDim2.new(0, 15, 0, 15)
Icon.BorderSizePixel = 0
Icon.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
Icon.Parent = Header

local ModuleName = Instance.new('TextLabel')

ModuleName.FontFace = Font.new('rbxasset://fonts/families/GothamSSm.json',
Enum.FontWeight.SemiBold, Enum.FontStyle.Normal)
ModuleName.TextColor3 = Color3.fromRGB(152, 181, 255)
ModuleName.TextTransparency = 0.20000000298023224
if not settings.rich then
ModuleName.Text = settings.title or "Skibidi"
else
ModuleName.RichText = true
ModuleName.Text = settings.richtext or "<font
color='rgb(255,0,0)'>March</font> user"
end;
ModuleName.Name = 'ModuleName'
ModuleName.Size = UDim2.new(0, 205, 0, 13)
ModuleName.AnchorPoint = Vector2.new(0, 0.5)
ModuleName.Position = UDim2.new(0.0729999989271164, 0, 0.23999999463558197,
0)
ModuleName.BackgroundTransparency = 1
ModuleName.TextXAlignment = Enum.TextXAlignment.Left
ModuleName.BorderSizePixel = 0
ModuleName.BorderColor3 = Color3.fromRGB(0, 0, 0)
ModuleName.TextSize = 13
ModuleName.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
ModuleName.Parent = Header

local Description = Instance.new('TextLabel')

Description.FontFace = Font.new('rbxasset://fonts/families/GothamSSm.json',
Enum.FontWeight.SemiBold, Enum.FontStyle.Normal)
Description.TextColor3 = Color3.fromRGB(152, 181, 255)
Description.TextTransparency = 0.699999988079071
Description.Text = settings.description
Description.Name = 'Description'
Description.Size = UDim2.new(0, 205, 0, 13)
Description.AnchorPoint = Vector2.new(0, 0.5)
 Description.Position = UDim2.new(0.0729999989271164, 0,
0.41999998688697815, 0)
Description.BackgroundTransparency = 1
Description.TextXAlignment = Enum.TextXAlignment.Left
Description.BorderSizePixel = 0
Description.BorderColor3 = Color3.fromRGB(0, 0, 0)
Description.TextSize = 10
Description.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
Description.Parent = Header

local Toggle = Instance.new('Frame')

Toggle.Name = 'Toggle'
Toggle.BackgroundTransparency = 0.699999988079071
Toggle.Position = UDim2.new(0.8199999928474426, 0, 0.7570000290870667, 0)
Toggle.BorderColor3 = Color3.fromRGB(0, 0, 0)
Toggle.Size = UDim2.new(0, 25, 0, 12)
Toggle.BorderSizePixel = 0
Toggle.BackgroundColor3 = Color3.fromRGB(0, 0, 0)
Toggle.Parent = Header

local UICorner = Instance.new('UICorner')

UICorner.CornerRadius = UDim.new(1, 0)
UICorner.Parent = Toggle

local Circle = Instance.new('Frame')

Circle.BorderColor3 = Color3.fromRGB(0, 0, 0)
Circle.AnchorPoint = Vector2.new(0, 0.5)
Circle.BackgroundTransparency = 0.20000000298023224
Circle.Position = UDim2.new(0, 0, 0.5, 0)
Circle.Name = 'Circle'
Circle.Size = UDim2.new(0, 12, 0, 12)
Circle.BorderSizePixel = 0
Circle.BackgroundColor3 = Color3.fromRGB(66, 80, 115)
Circle.Parent = Toggle

local UICorner = Instance.new('UICorner')

UICorner.CornerRadius = UDim.new(1, 0)
UICorner.Parent = Circle

local Keybind = Instance.new('Frame')

Keybind.Name = 'Keybind'
Keybind.BackgroundTransparency = 0.699999988079071
Keybind.Position = UDim2.new(0.15000000596046448, 0, 0.7350000143051147, 0)
Keybind.BorderColor3 = Color3.fromRGB(0, 0, 0)
Keybind.Size = UDim2.new(0, 33, 0, 15)
Keybind.BorderSizePixel = 0
Keybind.BackgroundColor3 = Color3.fromRGB(152, 181, 255)
Keybind.Parent = Header

local UICorner = Instance.new('UICorner')

UICorner.CornerRadius = UDim.new(0, 3)
UICorner.Parent = Keybind

local TextLabel = Instance.new('TextLabel')

TextLabel.FontFace = Font.new('rbxasset://fonts/families/GothamSSm.json',
Enum.FontWeight.SemiBold, Enum.FontStyle.Normal)
TextLabel.TextColor3 = Color3.fromRGB(209, 222, 255)
TextLabel.BorderColor3 = Color3.fromRGB(0, 0, 0)
TextLabel.Text = 'None'
 TextLabel.AnchorPoint = Vector2.new(0.5, 0.5)
TextLabel.Size = UDim2.new(0, 25, 0, 13)
TextLabel.BackgroundTransparency = 1
TextLabel.TextXAlignment = Enum.TextXAlignment.Left
TextLabel.Position = UDim2.new(0.5, 0, 0.5, 0)
TextLabel.BorderSizePixel = 0
TextLabel.TextSize = 10
TextLabel.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
TextLabel.Parent = Keybind

local Divider = Instance.new('Frame')

Divider.BorderColor3 = Color3.fromRGB(0, 0, 0)
Divider.AnchorPoint = Vector2.new(0.5, 0)
Divider.BackgroundTransparency = 0.5
Divider.Position = UDim2.new(0.5, 0, 0.6200000047683716, 0)
Divider.Name = 'Divider'
Divider.Size = UDim2.new(0, 241, 0, 1)
Divider.BorderSizePixel = 0
Divider.BackgroundColor3 = Color3.fromRGB(52, 66, 89)
Divider.Parent = Header

local Divider = Instance.new('Frame')

Divider.BorderColor3 = Color3.fromRGB(0, 0, 0)
Divider.AnchorPoint = Vector2.new(0.5, 0)
Divider.BackgroundTransparency = 0.5
Divider.Position = UDim2.new(0.5, 0, 1, 0)
Divider.Name = 'Divider'
Divider.Size = UDim2.new(0, 241, 0, 1)
Divider.BorderSizePixel = 0
Divider.BackgroundColor3 = Color3.fromRGB(52, 66, 89)
Divider.Parent = Header

local Options = Instance.new('Frame')

Options.Name = 'Options'
Options.BackgroundTransparency = 1
Options.Position = UDim2.new(0, 0, 1, 0)
Options.BorderColor3 = Color3.fromRGB(0, 0, 0)
Options.Size = UDim2.new(0, 241, 0, 8)
Options.BorderSizePixel = 0
Options.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
Options.Parent = Module

local UIPadding = Instance.new('UIPadding')

UIPadding.PaddingTop = UDim.new(0, 8)
UIPadding.Parent = Options

local UIListLayout = Instance.new('UIListLayout')

UIListLayout.Padding = UDim.new(0, 5)
UIListLayout.HorizontalAlignment = Enum.HorizontalAlignment.Center
UIListLayout.SortOrder = Enum.SortOrder.LayoutOrder
UIListLayout.Parent = Options

function ModuleManager:change_state(state: boolean)

self._state = state
if self._state then
TweenService:Create(Module, TweenInfo.new(0.5,
Enum.EasingStyle.Quint, Enum.EasingDirection.Out), {
Size = UDim2.fromOffset(241, 93 + self._size +
self._multiplier)
 }):Play()
TweenService:Create(Toggle, TweenInfo.new(0.5,
Enum.EasingStyle.Quint, Enum.EasingDirection.Out), {
BackgroundColor3 = Color3.fromRGB(152, 181, 255)
}):Play()
TweenService:Create(Circle, TweenInfo.new(0.5,
Enum.EasingStyle.Quint, Enum.EasingDirection.Out), {
BackgroundColor3 = Color3.fromRGB(152, 181, 255),
Position = UDim2.fromScale(0.53, 0.5)
}):Play()
else
TweenService:Create(Module, TweenInfo.new(0.5,
Enum.EasingStyle.Quint, Enum.EasingDirection.Out), {
Size = UDim2.fromOffset(241, 93)
}):Play()
TweenService:Create(Toggle, TweenInfo.new(0.5,
Enum.EasingStyle.Quint, Enum.EasingDirection.Out), {
BackgroundColor3 = Color3.fromRGB(0, 0, 0)
}):Play()
TweenService:Create(Circle, TweenInfo.new(0.5,
Enum.EasingStyle.Quint, Enum.EasingDirection.Out), {
BackgroundColor3 = Color3.fromRGB(66, 80, 115),
Position = UDim2.fromScale(0, 0.5)
}):Play()
end
Library._config._flags[settings.flag] = self._state
Config:save(game.GameId, Library._config)
settings.callback(self._state)
end

function ModuleManager:connect_keybind()
if not Library._config._keybinds[settings.flag] then
return
end
Connections[settings.flag..'_keybind'] =
UserInputService.InputBegan:Connect(function(input: InputObject, process: boolean)
if process then
return
end
if tostring(input.KeyCode) ~=
Library._config._keybinds[settings.flag] then
return
end
self:change_state(not self._state)
end)
end

function ModuleManager:scale_keybind(empty: boolean)

if Library._config._keybinds[settings.flag] and not empty then
local keybind_string =
string.gsub(tostring(Library._config._keybinds[settings.flag]), 'Enum.KeyCode.',
'')
local font_params = Instance.new('GetTextBoundsParams')
font_params.Text = keybind_string
font_params.Font =
Font.new('rbxasset://fonts/families/Montserrat.json', Enum.FontWeight.Bold)
font_params.Size = 10
font_params.Width = 10000
local font_size = TextService:GetTextBoundsAsync(font_params)
 Keybind.Size = UDim2.fromOffset(font_size.X + 6, 15)
TextLabel.Size = UDim2.fromOffset(font_size.X, 13)
else
Keybind.Size = UDim2.fromOffset(31, 15)
TextLabel.Size = UDim2.fromOffset(25, 13)
end
end

if Library:flag_type(settings.flag, 'boolean') then

ModuleManager._state = true
settings.callback(ModuleManager._state)
Toggle.BackgroundColor3 = Color3.fromRGB(152, 181, 255)
Circle.BackgroundColor3 = Color3.fromRGB(152, 181, 255)
Circle.Position = UDim2.fromScale(0.53, 0.5)
end

if Library._config._keybinds[settings.flag] then
local keybind_string =
string.gsub(tostring(Library._config._keybinds[settings.flag]), 'Enum.KeyCode.',
'')
TextLabel.Text = keybind_string
ModuleManager:connect_keybind()
ModuleManager:scale_keybind()
end

Connections[settings.flag..'_input_began'] =
Header.InputBegan:Connect(function(input: InputObject)
if Library._choosing_keybind then
return
end
if input.UserInputType ~= Enum.UserInputType.MouseButton3 then
return
end
Library._choosing_keybind = true
Connections['keybind_choose_start'] =
UserInputService.InputBegan:Connect(function(input: InputObject, process: boolean)
if process then
return
end
if input == Enum.UserInputState or input == Enum.UserInputType then
return
end
if input.KeyCode == Enum.KeyCode.Unknown then
return
end
if input.KeyCode == Enum.KeyCode.Backspace then
ModuleManager:scale_keybind(true)
Library._config._keybinds[settings.flag] = nil
Config:save(game.GameId, Library._config)
TextLabel.Text = 'None'
if Connections[settings.flag..'_keybind'] then
Connections[settings.flag..'_keybind']:Disconnect()
Connections[settings.flag..'_keybind'] = nil
end
Connections['keybind_choose_start']:Disconnect()
Connections['keybind_choose_start'] = nil
Library._choosing_keybind = false
return
end
 Connections['keybind_choose_start']:Disconnect()
Connections['keybind_choose_start'] = nil
Library._config._keybinds[settings.flag] = tostring(input.KeyCode)
Config:save(game.GameId, Library._config)
if Connections[settings.flag..'_keybind'] then
Connections[settings.flag..'_keybind']:Disconnect()
Connections[settings.flag..'_keybind'] = nil
end
ModuleManager:connect_keybind()
ModuleManager:scale_keybind()
Library._choosing_keybind = false
local keybind_string =
string.gsub(tostring(Library._config._keybinds[settings.flag]), 'Enum.KeyCode.',
'')
TextLabel.Text = keybind_string
end)
end)

Header.MouseButton1Click:Connect(function()
ModuleManager:change_state(not ModuleManager._state)
end)

function ModuleManager:create_dropdown(settings: any)

LayoutOrderModule = LayoutOrderModule + 1
local DropdownManager = {
_state = false,
_size = 0
}
if self._size == 0 then
self._size = 11
end
self._size += 44
if ModuleManager._state then
Module.Size = UDim2.fromOffset(241, 93 + self._size)
end
Options.Size = UDim2.fromOffset(241, self._size)
local Dropdown = Instance.new('TextButton')
Dropdown.FontFace =
Font.new('rbxasset://fonts/families/SourceSansPro.json', Enum.FontWeight.Regular,
Enum.FontStyle.Normal)
Dropdown.TextColor3 = Color3.fromRGB(0, 0, 0)
Dropdown.BorderColor3 = Color3.fromRGB(0, 0, 0)
Dropdown.Text = ''
Dropdown.AutoButtonColor = false
Dropdown.BackgroundTransparency = 1
Dropdown.Name = 'Dropdown'
Dropdown.Size = UDim2.new(0, 207, 0, 39)
Dropdown.BorderSizePixel = 0
Dropdown.TextSize = 14
Dropdown.BackgroundColor3 = Color3.fromRGB(0, 0, 0)
Dropdown.Parent = Options
Dropdown.LayoutOrder = LayoutOrderModule
if not Library._config._flags[settings.flag] then
Library._config._flags[settings.flag] = {}
end
local TextLabel = Instance.new('TextLabel')
TextLabel.FontFace =
Font.new('rbxasset://fonts/families/GothamSSm.json', Enum.FontWeight.SemiBold,
Enum.FontStyle.Normal)
 TextLabel.TextSize = 11
TextLabel.TextColor3 = Color3.fromRGB(255, 255, 255)
TextLabel.TextTransparency = 0.20000000298023224
TextLabel.Text = settings.title
TextLabel.Size = UDim2.new(0, 207, 0, 13)
TextLabel.BackgroundTransparency = 1
TextLabel.TextXAlignment = Enum.TextXAlignment.Left
TextLabel.BorderSizePixel = 0
TextLabel.BorderColor3 = Color3.fromRGB(0, 0, 0)
TextLabel.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
TextLabel.Parent = Dropdown
local Box = Instance.new('Frame')
Box.ClipsDescendants = true
Box.BorderColor3 = Color3.fromRGB(0, 0, 0)
Box.AnchorPoint = Vector2.new(0.5, 0)
Box.BackgroundTransparency = 0.8999999761581421
Box.Position = UDim2.new(0.5, 0, 1.2000000476837158, 0)
Box.Name = 'Box'
Box.Size = UDim2.new(0, 207, 0, 22)
Box.BorderSizePixel = 0
Box.BackgroundColor3 = Color3.fromRGB(152, 181, 255)
Box.Parent = TextLabel
local UICorner = Instance.new('UICorner', Box)
UICorner.CornerRadius = UDim.new(0, 4)
local Header = Instance.new('Frame')
Header.BorderColor3 = Color3.fromRGB(0, 0, 0)
Header.AnchorPoint = Vector2.new(0.5, 0)
Header.BackgroundTransparency = 1
Header.Position = UDim2.new(0.5, 0, 0, 0)
Header.Name = 'Header'
Header.Size = UDim2.new(0, 207, 0, 22)
Header.BorderSizePixel = 0
Header.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
Header.Parent = Box
local CurrentOption = Instance.new('TextLabel')
CurrentOption.FontFace =
Font.new('rbxasset://fonts/families/GothamSSm.json', Enum.FontWeight.SemiBold,
Enum.FontStyle.Normal)
CurrentOption.TextColor3 = Color3.fromRGB(255, 255, 255)
CurrentOption.TextTransparency = 0.20000000298023224
CurrentOption.Name = 'CurrentOption'
CurrentOption.Size = UDim2.new(0, 161, 0, 13)
CurrentOption.AnchorPoint = Vector2.new(0, 0.5)
CurrentOption.Position = UDim2.new(0.04999988153576851, 0, 0.5, 0)
CurrentOption.BackgroundTransparency = 1
CurrentOption.TextXAlignment = Enum.TextXAlignment.Left
CurrentOption.BorderSizePixel = 0
CurrentOption.BorderColor3 = Color3.fromRGB(0, 0, 0)
CurrentOption.TextSize = 10
CurrentOption.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
CurrentOption.Parent = Header
local UIGradient = Instance.new('UIGradient', CurrentOption)
UIGradient.Transparency = NumberSequence.new{
NumberSequenceKeypoint.new(0, 0),
NumberSequenceKeypoint.new(0.704, 0),
NumberSequenceKeypoint.new(0.872, 0.36250001192092896),
NumberSequenceKeypoint.new(1, 1)
}
local Arrow = Instance.new('ImageLabel')
 Arrow.BorderColor3 = Color3.fromRGB(0, 0, 0)
Arrow.AnchorPoint = Vector2.new(0, 0.5)
Arrow.Image = 'rbxassetid://84232453189324'
Arrow.BackgroundTransparency = 1
Arrow.Position = UDim2.new(0.9100000262260437, 0, 0.5, 0)
Arrow.Name = 'Arrow'
Arrow.Size = UDim2.new(0, 8, 0, 8)
Arrow.BorderSizePixel = 0
Arrow.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
Arrow.Parent = Header
local Options = Instance.new('ScrollingFrame')
Options.ScrollBarImageColor3 = Color3.fromRGB(0, 0, 0)
Options.Active = true
Options.ScrollBarImageTransparency = 1
Options.AutomaticCanvasSize = Enum.AutomaticSize.XY
Options.ScrollBarThickness = 0
Options.Name = 'Options'
Options.Size = UDim2.new(0, 207, 0, 0)
Options.BackgroundTransparency = 1
Options.Position = UDim2.new(0, 0, 1, 0)
Options.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
Options.BorderColor3 = Color3.fromRGB(0, 0, 0)
Options.BorderSizePixel = 0
Options.CanvasSize = UDim2.new(0, 0, 0.5, 0)
Options.Parent = Box
local UIListLayout = Instance.new('UIListLayout', Options)
UIListLayout.SortOrder = Enum.SortOrder.LayoutOrder
local UIPadding = Instance.new('UIPadding', Options)
UIPadding.PaddingTop = UDim.new(0, -1)
UIPadding.PaddingLeft = UDim.new(0, 10)
local UIListLayout = Instance.new('UIListLayout', Box)
UIListLayout.SortOrder = Enum.SortOrder.LayoutOrder
function DropdownManager:update(option: string)
CurrentOption.Text = (typeof(option) == "string" and option) or
option.Name
for _, object in Options:GetChildren() do
if object.Name == "Option" then
if object.Text == CurrentOption.Text then
object.TextTransparency = 0.2
else
object.TextTransparency = 0.6
end
end
end
Library._config._flags[settings.flag] = option
Config:save(game.GameId, Library._config)
settings.callback(option)
end
local CurrentDropSizeState = 0;
function DropdownManager:unfold_settings()
self._state = not self._state
if self._state then
ModuleManager._multiplier += self._size
CurrentDropSizeState = self._size;
TweenService:Create(Module, TweenInfo.new(0.5,
Enum.EasingStyle.Quint, Enum.EasingDirection.Out), {
Size = UDim2.fromOffset(241, 93 + ModuleManager._size +
ModuleManager._multiplier)
}):Play()
 TweenService:Create(Module.Options, TweenInfo.new(0.5,
Enum.EasingStyle.Quint, Enum.EasingDirection.Out), {
Size = UDim2.fromOffset(241, ModuleManager._size +
ModuleManager._multiplier)
}):Play()
TweenService:Create(Dropdown, TweenInfo.new(0.5,
Enum.EasingStyle.Quint, Enum.EasingDirection.Out), {
Size = UDim2.fromOffset(207, 39 + self._size)
}):Play()
TweenService:Create(Box, TweenInfo.new(0.5,
Enum.EasingStyle.Quint, Enum.EasingDirection.Out), {
Size = UDim2.fromOffset(207, 22 + self._size)
}):Play()
TweenService:Create(Arrow, TweenInfo.new(0.5,
Enum.EasingStyle.Quint, Enum.EasingDirection.Out), {
Rotation = 180
}):Play()
else
ModuleManager._multiplier -= self._size
CurrentDropSizeState = 0;
TweenService:Create(Module, TweenInfo.new(0.5,
Enum.EasingStyle.Quint, Enum.EasingDirection.Out), {
Size = UDim2.fromOffset(241, 93 + ModuleManager._size +
ModuleManager._multiplier)
}):Play()
TweenService:Create(Module.Options, TweenInfo.new(0.5,
Enum.EasingStyle.Quint, Enum.EasingDirection.Out), {
Size = UDim2.fromOffset(241, ModuleManager._size +
ModuleManager._multiplier)
}):Play()
TweenService:Create(Dropdown, TweenInfo.new(0.5,
Enum.EasingStyle.Quint, Enum.EasingDirection.Out), {
Size = UDim2.fromOffset(207, 39)
}):Play()
TweenService:Create(Box, TweenInfo.new(0.5,
Enum.EasingStyle.Quint, Enum.EasingDirection.Out), {
Size = UDim2.fromOffset(207, 22)
}):Play()
TweenService:Create(Arrow, TweenInfo.new(0.5,
Enum.EasingStyle.Quint, Enum.EasingDirection.Out), {
Rotation = 0
}):Play()
end
end
if #settings.options > 0 then
DropdownManager._size = 3
for index, value in settings.options do
local Option = Instance.new('TextButton')
Option.FontFace =
Font.new('rbxasset://fonts/families/GothamSSm.json', Enum.FontWeight.SemiBold,
Enum.FontStyle.Normal)
Option.Active = false
Option.TextTransparency = 0.6000000238418579
Option.AnchorPoint = Vector2.new(0, 0.5)
Option.TextSize = 10
Option.Size = UDim2.new(0, 186, 0, 16)
Option.TextColor3 = Color3.fromRGB(255, 255, 255)
Option.BorderColor3 = Color3.fromRGB(0, 0, 0)
Option.Text = (typeof(value) == "string" and value) or
value.Name;
Option.AutoButtonColor = false
Option.Name = 'Option'
Option.BackgroundTransparency = 1
Option.TextXAlignment = Enum.TextXAlignment.Left
Option.Selectable = false
Option.Position = UDim2.new(0.04999988153576851, 0,
0.34210526943206787, 0)
Option.BorderSizePixel = 0
Option.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
Option.Parent = Options
local UIGradient = Instance.new('UIGradient', Option)
UIGradient.Transparency = NumberSequence.new{
NumberSequenceKeypoint.new(0, 0),
NumberSequenceKeypoint.new(0.704, 0),
NumberSequenceKeypoint.new(0.872, 0.36250001192092896),
NumberSequenceKeypoint.new(1, 1)
}
Option.MouseButton1Click:Connect(function()
DropdownManager:update(value)
end)
if index > settings.maximum_options then
continue
end
DropdownManager._size += 16
Options.Size = UDim2.fromOffset(207, DropdownManager._size)
end
end
if Library:flag_type(settings.flag, 'string') then
DropdownManager:update(Library._config._flags[settings.flag])
else
DropdownManager:update(settings.options[1])
end
Dropdown.MouseButton1Click:Connect(function()
DropdownManager:unfold_settings()
end)
return DropdownManager
end
return ModuleManager
end
return TabManager
end

Connections['library_visiblity'] =
UserInputService.InputBegan:Connect(function(input: InputObject, process: boolean)
if input.KeyCode ~= Enum.KeyCode.Insert then
return
end
self._ui_open = not self._ui_open
self:change_visiblity(self._ui_open)
end)

self._ui.Container.Handler.Minimize.MouseButton1Click:Connect(function()
self._ui_open = not self._ui_open
self:change_visiblity(self._ui_open)
end)

return self
end
-- Main execution
local main = Library.new()
local combatTab = main:create_tab('Combat', 'rbxassetid://76499042599127')

-- Auto Parry Module

local autoParryModule = combatTab:create_module({
title = 'Auto Parry',
flag = 'Auto_Parry',
description = 'Automatically parries incoming balls',
section = 'left',
callback = function(value: boolean)
if value then
Connections_Manager['Auto Parry'] =
RunService.PreSimulation:Connect(function()
local Stats, tostringPlayer = game:GetService("Stats"),
tostring(LocalPlayer)
local char, gui = LocalPlayer.Character,
LocalPlayer:FindFirstChild("PlayerGui")
StarX.Get_Closest()
local hrp = char and char:FindFirstChild("HumanoidRootPart")
if not char or not hrp then return end
local hotbar = gui and gui:FindFirstChild("Hotbar")
local balls, oneBall = StarX.FetchBalls(), StarX.FetchBall()
local oneTarget = oneBall and oneBall:GetAttribute("target")
local statsPing = Stats.Network.ServerStatsItem["Data
Ping"]:GetValue() / 10
statsPing = statsPing > 200 and statsPing * 1.25 or statsPing > 150
and statsPing * 1.1 or statsPing

for _, ball in pairs(balls) do

local zoom = ball and ball:FindFirstChild("zoomies")
if not zoom then continue end
ball:GetAttributeChangedSignal("target"):Once(function()
Parried = false end)
if Parried then return end
local target = ball:GetAttribute("target")
local pos, vel = ball.Position, zoom.VectorVelocity
local dist, spd = (hrp.Position - pos).Magnitude, vel.Magnitude

if target == tostringPlayer and Aerodynamic and (tick() -

Aerodynamic_Time) > 0.6 then
Aerodynamic_Time, Aerodynamic = tick(), false
return
end

if oneTarget == tostringPlayer and StarX.Curved() then return

end
if Spamming then return end

local future = pos + vel * (statsPing / 1000)

if oneTarget == tostringPlayer and (hrp.Position -
future).Unit:Dot(vel.Unit) < 0 then return end

local divisor = (2.4 + math.min(math.max(spd - 9.5, 0), 820) *

0.002) * Xurr
local acc = statsPing + math.max(spd / divisor, 9.5)

if target == tostringPlayer and dist <= acc then

 StarX.Parry()
Parried = true
end

local t = tick()
repeat RunService.PreSimulation:Wait() until tick() - t >= 1 or
not Parried
Parried = false
end
end)
Library.SendNotification({
title = "Auto Parry",
text = "Auto Parry has been enabled!",
duration = 3
})
else
if Connections_Manager['Auto Parry'] then
Connections_Manager['Auto Parry']:Disconnect()
Connections_Manager['Auto Parry'] = nil
Library.SendNotification({
title = "Auto Parry",
text = "Auto Parry has been disabled!",
duration = 3
})
end
end
end
})

-- Parry Type Dropdown

local dropdown = autoParryModule:create_dropdown({
title = 'Parry Type',
flag = 'Parry_Type',
options = {'Custom', 'Random', 'Straight', 'Up', 'Backwards', 'Right', 'Left'},
maximum_options = 7,
callback = function(value: string)
Selected_Parry_Type = value
end
})

-- Auto Spam Parry Module

local autoSpamModule = combatTab:create_module({
title = 'Auto Spam Parry',
flag = 'Auto_Spam_Parry',
description = 'Automatically spam parries ball',
section = 'right',
callback = function(value: boolean)
if value then
Connections_Manager['Auto Spam'] =
RunService.PreSimulation:Connect(function(deltaTime)
local Ball = StarX.FetchBall()
if not Ball or not Ball:FindFirstChild("zoomies") then
Spamming = false
return
end

local Root = Character and

Character:FindFirstChild("HumanoidRootPart")
if not Root then
 Spamming = false
return
end

if not Closest_Entity or not Closest_Entity.PrimaryPart then

Spamming = false
return
end

local Ping = ServerStatsItem["Data Ping"]:GetValue()

Ping = Ping > 200 and Ping * 1.35 or (Ping > 150 and Ping * 1.1 or
Ping)

local FPS = 1 / deltaTime

local AdjustRate = math.max((math.max(Ping, 150) / 150) * (60 /
FPS), 0.7)
local BallVel = Ball.AssemblyLinearVelocity.Magnitude
local SpamDist = math.max((AdjustRate * 10) + math.min(BallVel / 6,
95), 17)

local RootPos = Root.Position

local BallPos = Ball.Position
local TargetPos = Closest_Entity.PrimaryPart.Position

local DistToBall = (RootPos - BallPos).Magnitude

local DistToTarget = (RootPos - TargetPos).Magnitude

if DistToBall > SpamDist * 0.77 or DistToTarget > SpamDist then

Spamming = false
return
end

Spamming = Parries > 1

if Spamming then StarX.Parry() end
end)
Library.SendNotification({
title = "Auto Spam Parry",
text = "Auto Spam Parry has been enabled!",
duration = 3
})
else
if Connections_Manager['Auto Spam'] then
Connections_Manager['Auto Spam']:Disconnect()
Connections_Manager['Auto Spam'] = nil
Spamming = false
Library.SendNotification({
title = "Auto Spam Parry",
text = "Auto Spam Parry has been disabled!",
duration = 3
})
end
end
end
})

-- Load the UI
main:load()

-- Initial notification
Library.SendNotification({
title = "ikorz Auto Parry",
text = "Script loaded successfully with full auto parry and auto spam system!",
duration = 5
})