Simple Script

local Players = game:GetService("Players")
local LocalPlayer = Players.LocalPlayer
local Camera = workspace.CurrentCamera
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local GuiService = game:GetService("GuiService")

local GameName = "Arsenal"
if game.PlaceId ~= 286090429 then 
    print("This ain't Arsenal Little Fish")
    return
end

if _G.AimBotScript then
    _G.AimBotScript:Destroy() 
end

local DropLib = loadstring(game:HttpGet("https://gitlab.com/0x45.xyz/droplib/-/raw/master/drop-minified.lua"))()
if not DropLib then
    warn("Failed to load DropLib")
    return
end

local gui_config = {
    PrimaryColor = Color3.fromRGB(30, 30, 30),
    SecondaryColor = Color3.fromRGB(45, 45, 45),
    AccentColor = Color3.fromRGB(255, 100, 100),
    TextColor = Color3.new(1, 1, 1),
    Font = Enum.Font.Gotham,
    TextSize = 14
}

local gui = DropLib:Init(gui_config, game.CoreGui)

local MainCategory = gui:CreateCategory("Arsenal Script - DropLib", UDim2.new(0, 100, 0, 100))

local AimbotSection = MainCategory:CreateSection("Aimbot")
local SilentAimSection = MainCategory:CreateSection("Silent Aim") 
local VisualsSection = MainCategory:CreateSection("Visuals")
local DetectionSection = MainCategory:CreateSection("Script Detection")
local SettingsSection = MainCategory:CreateSection("Settings")

local AimbotEnabled = true
local FOVRadius = 100
local SmoothingAmount = 0.1

local SilentEnabled = false
local HitboxExpansion = 13
local HitboxAlpha = 10

local ShowFOV = true
local ShowESP = true
local esp_color = Color3.new(0, 1, 0)

local ShowOtherScriptUsers = true
local my_script_id = "ArsenalScript_" .. math.random(10000, 99999)
local detected_users = {}
local user_list_display = nil

if not Drawing then
    warn("Drawing API not available")
    return
end

local fov_circle = Drawing.new("Circle")
fov_circle.Visible = ShowFOV
fov_circle.Radius = FOVRadius
fov_circle.Color = Color3.new(1, 1, 1)
fov_circle.Thickness = 2
fov_circle.Filled = false
fov_circle.Position = Vector2.new(Camera.ViewportSize.X / 2, Camera.ViewportSize.Y / 2)

local ESP_drawings = {}

local function announce_presence()
    if not _G.ArsenalScriptUsers then
        _G.ArsenalScriptUsers = {}
    end
    
    _G.ArsenalScriptUsers[LocalPlayer.Name] = {
        identifier = my_script_id,
        timestamp = tick(),
        player = LocalPlayer
    }
end

local function refresh_detected_users()
    if not _G.ArsenalScriptUsers then return end
    
    detected_users = {}
    local current_time = tick()
    
    for player_name, user_data in pairs(_G.ArsenalScriptUsers) do
        if current_time - user_data.timestamp > 10 then
            _G.ArsenalScriptUsers[player_name] = nil
        else
            table.insert(detected_users, player_name)
        end
    end
    
    if user_list_display then
        if #detected_users > 0 then
            user_list_display.Text = "Script Users (" .. #detected_users .. "):\n" .. table.concat(detected_users, "\n")
        else
            user_list_display.Text = "No other script users detected"
        end
        user_list_display.Visible = ShowOtherScriptUsers
    end
end

local function setup_user_list_display()
    if user_list_display then return end
    
    user_list_display = Drawing.new("Text")
    user_list_display.Text = "Scanning for script users..."
    user_list_display.Size = 14
    user_list_display.Color = Color3.new(1, 1, 1)
    user_list_display.Position = Vector2.new(10, 100)
    user_list_display.Outline = true
    user_list_display.OutlineColor = Color3.new(0, 0, 0)
    user_list_display.Visible = ShowOtherScriptUsers
end

local function find_players_service()
    for _, service in pairs(game:GetChildren()) do
        if service.ClassName == "Players" then
            return service.Name
        end
    end
end

local players_service = game[find_players_service()]
local local_player = players_service.LocalPlayer

local silent_aim_connections = {}

local function start_silent_aim()
    if silent_aim_connections.transparency_loop then
        silent_aim_connections.transparency_loop:Disconnect()
    end
    if silent_aim_connections.hitbox_loop then
        silent_aim_connections.hitbox_loop:Disconnect()
    end
    
    silent_aim_connections.transparency_loop = coroutine.wrap(function()
        while SilentEnabled do
            for _, player in pairs(players_service:GetPlayers()) do
                if player ~= local_player and player.Character then
                    for _, part_name in pairs({"RightUpperLeg", "LeftUpperLeg", "HeadHB", "HumanoidRootPart"}) do
                        local part = player.Character:FindFirstChild(part_name)
                        if part then
                            part.Transparency = HitboxAlpha
                        end
                    end
                end
            end
            wait(1)
        end
    end)()
    
    silent_aim_connections.hitbox_loop = coroutine.wrap(function()
        while SilentEnabled do
            for _, player in pairs(players_service:GetPlayers()) do
                if player ~= local_player and player.Character then
                    for _, part_name in pairs({"RightUpperLeg", "LeftUpperLeg", "HeadHB", "HumanoidRootPart"}) do
                        local part = player.Character:FindFirstChild(part_name)
                        if part then
                            part.CanCollide = false
                            part.Size = Vector3.new(HitboxExpansion, HitboxExpansion, HitboxExpansion)
                        end
                    end
                end
            end
            wait(1)
        end
    end)()
end

local function stop_silent_aim()
    if silent_aim_connections.transparency_loop then
        silent_aim_connections.transparency_loop:Disconnect()
        silent_aim_connections.transparency_loop = nil
    end
    if silent_aim_connections.hitbox_loop then
        silent_aim_connections.hitbox_loop:Disconnect()
        silent_aim_connections.hitbox_loop = nil
    end
    
    for _, player in pairs(players_service:GetPlayers()) do
        if player ~= local_player and player.Character then
            for _, part_name in pairs({"RightUpperLeg", "LeftUpperLeg", "HeadHB", "HumanoidRootPart"}) do
                local part = player.Character:FindFirstChild(part_name)
                if part then
                    part.Transparency = 0
                    part.CanCollide = true
                    
                    if part_name == "HumanoidRootPart" then
                        part.Size = Vector3.new(2, 2, 1)
                    elseif part_name:find("Leg") then
                        part.Size = Vector3.new(1, 2, 1) 
                    elseif part_name == "HeadHB" then
                        part.Size = Vector3.new(2, 1, 1)
                    end
                end
            end
        end
    end
end

local function create_esp_for_player(player)
    if ESP_drawings[player] then return end

    local drawing_objects = {}
    
    drawing_objects.Spine = Drawing.new("Line")
    drawing_objects.LeftUpperArm = Drawing.new("Line")
    drawing_objects.LeftLowerArm = Drawing.new("Line")
    drawing_objects.RightUpperArm = Drawing.new("Line") 
    drawing_objects.RightLowerArm = Drawing.new("Line")
    drawing_objects.LeftUpperLeg = Drawing.new("Line")
    drawing_objects.LeftLowerLeg = Drawing.new("Line")
    drawing_objects.RightUpperLeg = Drawing.new("Line")
    drawing_objects.RightLowerLeg = Drawing.new("Line")
    
    drawing_objects.DistanceText = Drawing.new("Text")
    drawing_objects.DistanceText.Text = "0m"
    drawing_objects.DistanceText.Size = 16
    drawing_objects.DistanceText.Color = Color3.new(1, 1, 1)
    drawing_objects.DistanceText.Center = true
    drawing_objects.DistanceText.Outline = true
    drawing_objects.DistanceText.OutlineColor = Color3.new(0, 0, 0)
    drawing_objects.DistanceText.Visible = false
    
    for name, line_obj in pairs(drawing_objects) do
        if name:find("Arm") or name:find("Leg") or name == "Spine" then
            line_obj.Visible = false
            line_obj.Color = esp_color
            line_obj.Thickness = 2
        end
    end

    ESP_drawings[player] = drawing_objects
end

local function remove_esp_for_player(player)
    if not ESP_drawings[player] then return end

    for _, drawing_obj in pairs(ESP_drawings[player]) do
        drawing_obj:Remove()
    end
    ESP_drawings[player] = nil
end

local function update_esp_displays()
    for player, drawing_objects in pairs(ESP_drawings) do
        if player ~= LocalPlayer and player.Character and player.Character:FindFirstChild("Head") then
            if player.Team ~= LocalPlayer.Team then
                local character = player.Character
                local head = character:FindFirstChild("Head")
                local torso = character:FindFirstChild("Torso") or character:FindFirstChild("UpperTorso")
                
                local left_upper_arm = character:FindFirstChild("Left Arm") or character:FindFirstChild("LeftUpperArm")
                local left_lower_arm = character:FindFirstChild("Left Arm") or character:FindFirstChild("LeftLowerArm") 
                local right_upper_arm = character:FindFirstChild("Right Arm") or character:FindFirstChild("RightUpperArm")
                local right_lower_arm = character:FindFirstChild("Right Arm") or character:FindFirstChild("RightLowerArm")
                local left_upper_leg = character:FindFirstChild("Left Leg") or character:FindFirstChild("LeftUpperLeg")
                local left_lower_leg = character:FindFirstChild("Left Leg") or character:FindFirstChild("LeftLowerLeg")
                local right_upper_leg = character:FindFirstChild("Right Leg") or character:FindFirstChild("RightUpperLeg")
                local right_lower_leg = character:FindFirstChild("Right Leg") or character:FindFirstChild("RightLowerLeg")

                if head and torso then
                    local head_pos, head_on_screen = Camera:WorldToViewportPoint(head.Position)
                    local torso_pos, torso_on_screen = Camera:WorldToViewportPoint(torso.Position)
                    
                    if head_on_screen and torso_on_screen then
                        drawing_objects.Spine.From = Vector2.new(head_pos.X, head_pos.Y)
                        drawing_objects.Spine.To = Vector2.new(torso_pos.X, torso_pos.Y)
                        drawing_objects.Spine.Visible = ShowESP
                        
                        if left_upper_arm then
                            local left_upper_pos, left_upper_visible = Camera:WorldToViewportPoint(left_upper_arm.Position)
                            if left_upper_visible then
                                drawing_objects.LeftUpperArm.From = Vector2.new(torso_pos.X, torso_pos.Y)
                                drawing_objects.LeftUpperArm.To = Vector2.new(left_upper_pos.X, left_upper_pos.Y)
                                drawing_objects.LeftUpperArm.Visible = ShowESP
                                
                                if left_lower_arm and left_lower_arm ~= left_upper_arm then
                                    local left_lower_pos, left_lower_visible = Camera:WorldToViewportPoint(left_lower_arm.Position)
                                    if left_lower_visible then
                                        drawing_objects.LeftLowerArm.From = Vector2.new(left_upper_pos.X, left_upper_pos.Y)
                                        drawing_objects.LeftLowerArm.To = Vector2.new(left_lower_pos.X, left_lower_pos.Y)
                                        drawing_objects.LeftLowerArm.Visible = ShowESP
                                    else
                                        drawing_objects.LeftLowerArm.Visible = false
                                    end
                                else
                                    drawing_objects.LeftLowerArm.Visible = false
                                end
                            else
                                drawing_objects.LeftUpperArm.Visible = false
                                drawing_objects.LeftLowerArm.Visible = false
                            end
                        else
                            drawing_objects.LeftUpperArm.Visible = false
                            drawing_objects.LeftLowerArm.Visible = false
                        end
                        
                        if right_upper_arm then
                            local right_upper_pos, right_upper_visible = Camera:WorldToViewportPoint(right_upper_arm.Position)
                            if right_upper_visible then
                                drawing_objects.RightUpperArm.From = Vector2.new(torso_pos.X, torso_pos.Y)
                                drawing_objects.RightUpperArm.To = Vector2.new(right_upper_pos.X, right_upper_pos.Y)
                                drawing_objects.RightUpperArm.Visible = ShowESP
                                
                                if right_lower_arm and right_lower_arm ~= right_upper_arm then
                                    local right_lower_pos, right_lower_visible = Camera:WorldToViewportPoint(right_lower_arm.Position)
                                    if right_lower_visible then
                                        drawing_objects.RightLowerArm.From = Vector2.new(right_upper_pos.X, right_upper_pos.Y)
                                        drawing_objects.RightLowerArm.To = Vector2.new(right_lower_pos.X, right_lower_pos.Y)
                                        drawing_objects.RightLowerArm.Visible = ShowESP
                                    else
                                        drawing_objects.RightLowerArm.Visible = false
                                    end
                                else
                                    drawing_objects.RightLowerArm.Visible = false
                                end
                            else
                                drawing_objects.RightUpperArm.Visible = false
                                drawing_objects.RightLowerArm.Visible = false
                            end
                        else
                            drawing_objects.RightUpperArm.Visible = false
                            drawing_objects.RightLowerArm.Visible = false
                        end
                        
                        if left_upper_leg then
                            local left_leg_upper_pos, left_leg_upper_visible = Camera:WorldToViewportPoint(left_upper_leg.Position)
                            if left_leg_upper_visible then
                                drawing_objects.LeftUpperLeg.From = Vector2.new(torso_pos.X, torso_pos.Y)
                                drawing_objects.LeftUpperLeg.To = Vector2.new(left_leg_upper_pos.X, left_leg_upper_pos.Y)
                                drawing_objects.LeftUpperLeg.Visible = ShowESP
                                
                                if left_lower_leg and left_lower_leg ~= left_upper_leg then
                                    local left_leg_lower_pos, left_leg_lower_visible = Camera:WorldToViewportPoint(left_lower_leg.Position)
                                    if left_leg_lower_visible then
                                        drawing_objects.LeftLowerLeg.From = Vector2.new(left_leg_upper_pos.X, left_leg_upper_pos.Y)
                                        drawing_objects.LeftLowerLeg.To = Vector2.new(left_leg_lower_pos.X, left_leg_lower_pos.Y)
                                        drawing_objects.LeftLowerLeg.Visible = ShowESP
                                    else
                                        drawing_objects.LeftLowerLeg.Visible = false
                                    end
                                else
                                    drawing_objects.LeftLowerLeg.Visible = false
                                end
                            else
                                drawing_objects.LeftUpperLeg.Visible = false
                                drawing_objects.LeftLowerLeg.Visible = false
                            end
                        else
                            drawing_objects.LeftUpperLeg.Visible = false
                            drawing_objects.LeftLowerLeg.Visible = false
                        end
                        
                        if right_upper_leg then
                            local right_leg_upper_pos, right_leg_upper_visible = Camera:WorldToViewportPoint(right_upper_leg.Position)
                            if right_leg_upper_visible then
                                drawing_objects.RightUpperLeg.From = Vector2.new(torso_pos.X, torso_pos.Y)
                                drawing_objects.RightUpperLeg.To = Vector2.new(right_leg_upper_pos.X, right_leg_upper_pos.Y)
                                drawing_objects.RightUpperLeg.Visible = ShowESP
                                
                                if right_lower_leg and right_lower_leg ~= right_upper_leg then
                                    local right_leg_lower_pos, right_leg_lower_visible = Camera:WorldToViewportPoint(right_lower_leg.Position)
                                    if right_leg_lower_visible then
                                        drawing_objects.RightLowerLeg.From = Vector2.new(right_leg_upper_pos.X, right_leg_upper_pos.Y)
                                        drawing_objects.RightLowerLeg.To = Vector2.new(right_leg_lower_pos.X, right_leg_lower_pos.Y)
                                        drawing_objects.RightLowerLeg.Visible = ShowESP
                                    else
                                        drawing_objects.RightLowerLeg.Visible = false
                                    end
                                else
                                    drawing_objects.RightLowerLeg.Visible = false
                                end
                            else
                                drawing_objects.RightUpperLeg.Visible = false
                                drawing_objects.RightLowerLeg.Visible = false
                            end
                        else
                            drawing_objects.RightUpperLeg.Visible = false
                            drawing_objects.RightLowerLeg.Visible = false
                        end
                        
                        local distance = math.floor((head.Position - Camera.CFrame.Position).Magnitude)
                        drawing_objects.DistanceText.Text = distance .. "m"
                        drawing_objects.DistanceText.Position = Vector2.new(head_pos.X, head_pos.Y - 25)
                        drawing_objects.DistanceText.Visible = ShowESP
                    else
                        for _, element in pairs(drawing_objects) do
                            element.Visible = false
                        end
                    end
                else
                    for _, element in pairs(drawing_objects) do
                        element.Visible = false
                    end
                end
            else
                for _, element in pairs(drawing_objects) do
                    element.Visible = false
                end
            end
        else
            for _, element in pairs(drawing_objects) do
                element.Visible = false
            end
        end
    end
end

local function check_player_visibility(player)
    if not player.Character then return false end
    local target_head = player.Character:FindFirstChild("Head")
    if not target_head then return false end

    local camera_position = Camera.CFrame.Position
    local direction_to_target = (target_head.Position - camera_position).Unit
    local raycast = Ray.new(camera_position, direction_to_target * 1000)

    local hit_part, hit_position = workspace:FindPartOnRayWithIgnoreList(raycast, {LocalPlayer.Character, Camera})

    if hit_part and hit_part:IsDescendantOf(player.Character) then
        return true
    end
    return false
end

local function check_fov_circle(player)
    if not player.Character then return false end
    local target_head = player.Character:FindFirstChild("Head")
    if not target_head then return false end

    local screen_point, is_on_screen = Camera:WorldToViewportPoint(target_head.Position)
    if not is_on_screen then return false end

    local circle_center = fov_circle.Position
    local distance_from_center = (Vector2.new(screen_point.X, screen_point.Y) - circle_center).Magnitude

    return distance_from_center <= fov_circle.Radius
end

local function get_closest_valid_target()
    local closest_target = nil
    local shortest_distance = math.huge

    for _, player in pairs(Players:GetPlayers()) do
        if player ~= LocalPlayer and player.Character and player.Character:FindFirstChild("Head") then
            if player.Team ~= LocalPlayer.Team then
                if check_player_visibility(player) and check_fov_circle(player) then
                    local screen_pos = Camera:WorldToViewportPoint(player.Character.Head.Position)
                    local circle_center = fov_circle.Position
                    local distance_from_center = (Vector2.new(screen_pos.X, screen_pos.Y) - circle_center).Magnitude

                    if distance_from_center < shortest_distance then
                        closest_target = player
                        shortest_distance = distance_from_center
                    end
                end
            end
        end
    end

    return closest_target
end

local function run_aimbot()
    if not AimbotEnabled then return end 
    
    local target_player = get_closest_valid_target()
    if target_player and target_player.Character and target_player.Character:FindFirstChild("Head") then
        local target_part = target_player.Character.Head
        
        local current_look_direction = Camera.CFrame.LookVector
        local target_look_direction = (target_part.Position - Camera.CFrame.Position).Unit
        local smoothed_direction = (current_look_direction + (target_look_direction - current_look_direction) * SmoothingAmount).Unit
        Camera.CFrame = CFrame.new(Camera.CFrame.Position, Camera.CFrame.Position + smoothed_direction)
    end
end

AimbotSection:CreateSwitch("Enable Aimbot", function(enabled)
    AimbotEnabled = enabled
    print("Aimbot " .. (enabled and "Enabled" or "Disabled"))
end, AimbotEnabled)

SilentAimSection:CreateSwitch("Enable Silent Aim", function(enabled)
    SilentEnabled = enabled
    if enabled then
        start_silent_aim()
        print("Silent aim started - hitboxes expanded")
    else
        stop_silent_aim()
        print("Silent aim stopped - hitboxes reset")
    end
end, SilentEnabled)

VisualsSection:CreateSwitch("Show FOV Circle", function(enabled)
    ShowFOV = enabled
    fov_circle.Visible = enabled
    print("FOV Circle " .. (enabled and "shown" or "hidden"))
end, ShowFOV)

VisualsSection:CreateSwitch("Show ESP Skeleton", function(enabled)
    ShowESP = enabled
    print("ESP Skeleton " .. (enabled and "enabled" or "disabled"))
end, ShowESP)

DetectionSection:CreateSwitch("Show Script Users", function(enabled)
    ShowOtherScriptUsers = enabled
    if user_list_display then
        user_list_display.Visible = enabled
    end
    print("Script User Detection " .. (enabled and "enabled" or "disabled"))
end, ShowOtherScriptUsers)

DetectionSection:CreateButton("Refresh User List", function()
    refresh_detected_users()
    print("User list refreshed - Found " .. #detected_users .. " script users")
end)

SettingsSection:CreateSlider("FOV Size", function(new_value)
    FOVRadius = new_value
    fov_circle.Radius = new_value
    print("FOV set to: " .. new_value)
end, 50, 300, 1, false, FOVRadius)

SettingsSection:CreateSlider("Smoothing", function(new_value)
    SmoothingAmount = new_value / 100
    print("Smoothing set to: " .. (new_value / 100))
end, 30, 100, 1, false, SmoothingAmount * 100)

SettingsSection:CreateColorPicker("ESP Color", function(new_color)
    esp_color = new_color
    for _, drawing_objects in pairs(ESP_drawings) do
        if drawing_objects.Spine then drawing_objects.Spine.Color = new_color end
        if drawing_objects.LeftUpperArm then drawing_objects.LeftUpperArm.Color = new_color end
        if drawing_objects.LeftLowerArm then drawing_objects.LeftLowerArm.Color = new_color end
        if drawing_objects.RightUpperArm then drawing_objects.RightUpperArm.Color = new_color end
        if drawing_objects.RightLowerArm then drawing_objects.RightLowerArm.Color = new_color end
        if drawing_objects.LeftUpperLeg then drawing_objects.LeftUpperLeg.Color = new_color end
        if drawing_objects.LeftLowerLeg then drawing_objects.LeftLowerLeg.Color = new_color end
        if drawing_objects.RightUpperLeg then drawing_objects.RightUpperLeg.Color = new_color end
        if drawing_objects.RightLowerLeg then drawing_objects.RightLowerLeg.Color = new_color end
    end
    print("ESP Color changed to: " .. tostring(new_color))
end, false, esp_color)

SettingsSection:CreateButton("Reset Settings", function()
    AimbotEnabled = true
    SilentEnabled = false
    FOVRadius = 100
    SmoothingAmount = 0.1
    ShowFOV = true
    ShowESP = true
    esp_color = Color3.new(0, 1, 0)
    HitboxExpansion = 13
    HitboxAlpha = 10
    
    fov_circle.Radius = FOVRadius
    fov_circle.Visible = ShowFOV
    
    stop_silent_aim()
    
    for _, drawing_objects in pairs(ESP_drawings) do
        for _, line in pairs(drawing_objects) do
            line.Color = esp_color
        end
    end
    print("All settings reset to default values")
end)

setup_user_list_display()
announce_presence()

local update_success, update_error = pcall(function()
    RunService.RenderStepped:Connect(function()
        fov_circle.Position = Vector2.new(Camera.ViewportSize.X / 2, Camera.ViewportSize.Y / 2)
        update_esp_displays()
    end)
    
    RunService.RenderStepped:Connect(run_aimbot)
    
    spawn(function()
        while _G.AimBotScript do
            announce_presence()
            refresh_detected_users()
            wait(2)
        end
    end)
end)

if not update_success then
    warn("Error setting up update loops: " .. update_error)
end

for _, player in pairs(Players:GetPlayers()) do
    if player ~= LocalPlayer then
        create_esp_for_player(player)
    end
end

Players.PlayerAdded:Connect(function(player)
    create_esp_for_player(player)
end)

Players.PlayerRemoving:Connect(function(player)
    remove_esp_for_player(player)
end)

_G.AimBotScript = {
    Destroy = function()
        print("Cleaning up Arsenal script...")
        
        stop_silent_aim()

        if fov_circle then
            fov_circle:Remove()
        end

        if user_list_display then
            user_list_display:Remove()
        end

        if _G.ArsenalScriptUsers and _G.ArsenalScriptUsers[LocalPlayer.Name] then
            _G.ArsenalScriptUsers[LocalPlayer.Name] = nil
        end

        for player, drawing_objects in pairs(ESP_drawings) do
            remove_esp_for_player(player)
        end

        for _, connection in pairs(getconnections(RunService.RenderStepped)) do
            connection:Disconnect()
        end

        if gui then
            pcall(function() gui:CleanUp() end)
            pcall(function() gui:Hide() end)
            if gui.ScreenGui then
                gui.ScreenGui:Destroy()
            end
        end
        
        for _, gui_obj in pairs(game.CoreGui:GetChildren()) do
            if gui_obj.Name:find("DropLib") or gui_obj.Name:find("Arsenal") then
                gui_obj:Destroy()
            end
        end
        
        _G.AimBotScript = nil
        print("Arsenal script cleanup complete")
    end
}

print("Have fun! (and don't get banned lol)")