_DEBUG = true

local clipboard = require "neverlose/clipboard"

local pui = require "neverlose/pui"
local gradient = require("neverlose/gradient")
local http_lib = require("neverlose/http_lib")

local http = http_lib.new({

task_interval = 0.3, -- polling intervals
enable_debug = true, -- print http request s to the console
timeout = 10 -- request expiration time
})

local callbacks = {}

local build = "live"

local vel_warning
local watermark_icon

http:get("[Link]
1022219770604572717/1137943561816518748/vel_warning_v2.png", function(data)
if not pcall(data:success() and [Link] == 200 and [Link]) then
vel_warning = render.load_image([Link], vector(300,300))
else
print("couldn't download amnesia icon")
end
end)

http:get("[Link]
1022219770604572717/1137951401566281788/watermark_final.png", function(data)
if not pcall(data:success() and [Link] == 200 and [Link]) then
watermark_icon = render.load_image([Link], vector(300,300))
else
print("couldn't download amnesia icon")
end
end)

[Link] = function(event, name, fn)

events[event]:set(safecall(name, event ~= "shutdown", fn))
end

local aa={
pitch=[Link]("Aimbot","Anti Aim","Angles","Pitch"),
yaw=[Link]("Aimbot","Anti Aim","Angles","Yaw"),
base=[Link]("Aimbot","Anti Aim","Angles","Yaw","Base"),
offset=[Link]("Aimbot","Anti Aim","Angles","Yaw","Offset"),
backstab=[Link]("Aimbot","Anti Aim","Angles","Yaw","Avoid Backstab"),
jitter=[Link]("Aimbot","Anti Aim","Angles","Yaw Modifier"),
jitter_val=[Link]("Aimbot","Anti Aim","Angles","Yaw Modifier","Offset"),
body_yaw={[Link]("Aimbot","Anti Aim","Angles","Body Yaw"),
[Link]("Aimbot","Anti Aim","Angles","Body Yaw","Inverter"),
[Link]("Aimbot","Anti Aim","Angles","Body Yaw","Left Limit"),
[Link]("Aimbot","Anti Aim","Angles","Body Yaw","Right Limit"),
[Link]("Aimbot","Anti Aim","Angles","Body Yaw","Options"),
[Link]("Aimbot","Anti Aim","Angles","Body Yaw","Freestanding")},
freestand={[Link]("Aimbot","Anti Aim","Angles","Freestanding"),
[Link]("Aimbot","Anti Aim","Angles","Freestanding","Disable Yaw Modifiers"),
[Link]("Aimbot","Anti Aim","Angles","Freestanding","Body Freestanding")},
 def=[Link]("Aimbot","Ragebot","Main","Double Tap","Lag Options"),
slow=[Link]("Aimbot","Anti Aim","Misc","Slow Walk")
}

local references={
doubletap=[Link]("aimbot","ragebot","main","double tap"),
hideshots=[Link]("Aimbot","Ragebot","Main","Hide Shots"),
fakeduck=[Link]("Aimbot","Anti Aim","Misc","Fake Duck"),
delayshot=[Link]("Aimbot", "Ragebot", "Selection", "Global", "Min. Damage",
"Delay Shot"),
pitch=[Link]("Aimbot","Anti Aim","Angles","Pitch"),
offset=[Link]("Aimbot","Anti Aim","Angles","Yaw","Offset"),
yaw=[Link]("Aimbot","Anti Aim","Angles","Yaw"),
modifier=[Link]("Aimbot","Anti Aim","Angles","Yaw Modifier"),
moffset=[Link]("Aimbot","Anti Aim","Angles","Yaw Modifier","Offset"),
limit1=[Link]("Aimbot","Anti Aim","Angles","Body Yaw","Left Limit"),
limit2=[Link]("Aimbot","Anti Aim","Angles","Body Yaw","Right Limit"),
freestand=[Link]("Aimbot","Anti Aim","Angles","Freestanding"),
antistab=[Link]("Aimbot","Anti Aim","Angles","Yaw","Avoid Backstab"),
bodyyaw=[Link]("Aimbot","Anti Aim","Angles","Body Yaw"),
roll=[Link]("Aimbot","Anti Aim","Angles","Extended Angles"),
rollval=[Link]("Aimbot","Anti Aim","Angles","Extended Angles","Extended
Roll"),
airstrafe=[Link]("Miscellaneous","Main","Movement","Air Strafe"),
legmov=[Link]("Aimbot","Anti Aim","Misc","Leg Movement"),
slowwalk=[Link]("Aimbot","Anti Aim","Misc","Slow Walk"),
lagoptions=[Link]("Aimbot","Ragebot","Main","Double Tap","Lag Options"),
fakelag=[Link]("Aimbot","Anti Aim","Fake Lag","Limit"),
asoptions=[Link]("Aimbot","Ragebot","Accuracy","Auto Stop","Options"),
asdtoptions=[Link]("Aimbot","Ragebot","Accuracy","Auto Stop","Double Tap")
}

rad = [Link]
cos = [Link]
sin = [Link]

local target_pos = vector(0,0,0)

local cam1

function drawWireframeSphere(center, radius, segments, sphereColor, rotationAngle)

-- Loop through and draw horizontal lines
for i = 0, segments do
local latitude = (i / segments) * [Link] - ([Link] / 2)
local last_point = nil

for j = 0, segments do
local longitude = (j / segments) * 2 * [Link]
local x = radius * [Link](latitude) * [Link](longitude)
local y = radius * [Link](latitude) * [Link](longitude)
local z = radius * [Link](latitude)

-- Apply rotation around the Y-axis

local newX = [Link](rotationAngle) * x - [Link](rotationAngle) * y
local newY = [Link](rotationAngle) * x + [Link](rotationAngle) * y

x, y = newX, newY

-- Translate to the center position

x = x + center.x
 y = y + center.y
z = z + center.z

local world_point = vector(x, y, z)

local screen_point = render.world_to_screen(world_point)

if last_point and screen_point then

[Link](last_point, screen_point, sphereColor)
end

last_point = screen_point
end
end

-- Loop through and draw vertical lines

for j = 0, segments do
local longitude = (j / segments) * 2 * [Link]
local last_point = nil

for i = 0, segments do
local latitude = (i / segments) * [Link] - ([Link] / 2)
local x = radius * [Link](latitude) * [Link](longitude)
local y = radius * [Link](latitude) * [Link](longitude)
local z = radius * [Link](latitude)

-- Apply rotation around the Y-axis

local newX = [Link](rotationAngle) * x - [Link](rotationAngle) * y
local newY = [Link](rotationAngle) * x + [Link](rotationAngle) * y

x, y = newX, newY

-- Translate to the center position

x = x + center.x
y = y + center.y
z = z + center.z

local world_point = vector(x, y, z)

local screen_point = render.world_to_screen(world_point)

if last_point and screen_point then

[Link](last_point, screen_point, sphereColor)
end

last_point = screen_point
end
end
end

local get_coord = function()

local campos = render.camera_position()
local cam_angles = render.camera_angles()
local x = rad(cam_angles.y)
local y = rad(cam_angles.x)

local vx = cos(x) * cos(y)

local vy = sin(x) * cos(y)
local vz = sin(y)

local finish_pos = campos + 1500 *vector(vx, vy, -1*vz)

 local lp = entity.get_local_player()
local trace = utils.trace_line(campos, finish_pos)
local trace_end = trace.end_pos

return trace_end:clone()
end

[Link] = function (num1, num2)

return [Link](num1 - num2)
end

math.color_lerp = function(start, end_pos, time)

local frametime = [Link] * 100
time = time * [Link](frametime, math.max_lerp_low_fps)
return start:lerp(end_pos, time)
end

math.max_lerp_low_fps = (1 / 45) * 100

[Link] = function(start, end_pos, time)
if start == end_pos then
return end_pos
end

local frametime = [Link] * 170

time = time * frametime

local val = start + (end_pos - start) * time

if([Link](val - end_pos) < 0.01) then

return end_pos
end

return val
end

math.normalize_yaw = math.normalize_yaw

local animations = {}
animations.base_speed = 0.095
animations._list = {}
[Link] = function(name, new_value, speed, init)
speed = speed or animations.base_speed

local is_color = type(new_value) == "userdata"

if animations._list[name] == nil then

animations._list[name] = (init and init) or (is_color and [Link] or
0)
end

local interp_func

if is_color then
interp_func = math.color_lerp
else
interp_func = [Link]
end
 animations._list[name] = interp_func(animations._list[name], new_value, speed)

return animations._list[name]
end

function theme_color()
return "\a"..ui.get_style("Link Active"):to_hex()
end

local aa_info = {conditions={"standing","running","slowmotion","crouch","crouch

moving","air","air crouch"}}

--@region ["tab init"]

local main_tab = [Link]("amnesia")
local anti_aim = [Link]("\n3")
local visuals_section = [Link]("\nvisuals")
local misc_section = [Link]("\nmisc")
local visuals = [Link]("reborn")
local anti_aim_2 = [Link]("")
local anti_aim_4 = [Link]("\n2")
local anti_aim_3 = [Link]("\n")
--@region end

[Link]:set(function(ctx)
local hello = ui.get_style("Link Active")

local gradient_animation = gradient.text_animate("amnesia reborn", -1, {

hello,
color(255,255,255)
})

[Link](gradient_animation:get_animated_text(), "\v🍥")
gradient_animation:animate()
end)

local helps = {
distance_2d = function(position_a, position_b)
return [Link]((position_b.x - position_a.x) ^ 2 + (position_b.y -
position_a.y) ^ 2)
end,

lerp_position = function(position_al, position_bl, recharge)

return vector((position_bl.x - position_al.x) * recharge + position_al.x,
(position_bl.y - position_al.y) * recharge + position_al.y, (position_bl.z -
position_al.z) * recharge + position_al.z)
end
}

--ui.get_icon("circle-check")

refs = {fakeduck = [Link]('Aimbot','Anti Aim',"Misc","Fake Duck"),slowwalk =

[Link]('Aimbot','Anti Aim',"Misc","Slow Walk"),hitchance =
[Link]('Aimbot','Ragebot',"Selection","Hit Chance"),doubletap = [Link]("Aimbot",
"Ragebot", "Main", "Double Tap"),hideshots = [Link]("Aimbot", "Ragebot", "Main",
"Hide Shots"),damage = [Link]("Aimbot", "Ragebot", "Selection", "Min.
Damage"),isSafe = [Link]("Aimbot", "Ragebot", "Safety", "Safe Points"),isBody =
[Link]("Aimbot", "Ragebot", "Safety", "Body Aim"),dormant_aim = [Link]("Aimbot",
"Ragebot", "Main", "Enabled", "Dormant Aimbot"),fake_latency =
[Link]("Miscellaneous", "Main", "Other", "Fake Latency"),freestanding =
[Link]("Aimbot", "Anti Aim", "Angles", "Freestanding")}

local menu = {}

menu = {
main = {

--visuals:texture(render.load_image([Link]("[Link]
attachments/1022219770604572717/1136788136026980382/[Link]"), vector(240,
240)), vector(240, 240), color(255, 255, 255, 255), 'f'),
[Link]("reborn", "\bFFFFFF\b"..ui.get_style("Link
Active"):to_hex().."[amnesia] - 🍥 \rreborn"),
[Link]("reborn", "welcome to the reborn version of \bFFFFFF\
b"..ui.get_style("Link Active"):to_hex().."[amnesia].\n\ruser: \bFFFFFF\
b"..ui.get_style("Link Active"):to_hex().."["..common.get_username().." :
"..build.."]"),
menu_theme = [Link]("reborn", "menu theme", function()
[Link]("[Link]
getitem?c=dGBua1NG3F12QKIu-E3Mz9q4nbM")
end),
discord_button = [Link]("reborn", "discord", function()

[Link]("[Link]
@hellboyhvh?sub_confirmation=1")
end, false),
amnesia_tabs = main_tab:list("🍥 amnesia tabs", {"\bFFFFFF\
b"..ui.get_style("Link Active"):to_hex().."[anti-aim]", "\b"..ui.get_style("Link
Active"):to_hex().."\bFFFFFF[visuals]", "\bFFFFFF\b"..ui.get_style("Link
Active"):to_hex().."[misc]"}, 3),
--tab_label = rage:label("reborn", "\bFFFFFF\b"..ui.get_style("Link
Active"):to_hex().."[tab] - \r"),
save = [Link]("reborn", "save clipboard", function ()
local raw = [Link]()
[Link]([Link](raw))
end), "from clipboard",
load = [Link]("reborn", "load clipboard", function ()
local raw = [Link]()
[Link]([Link](raw))
end), "from clipboard",
load_visual = [Link]("reborn", "load visuals only", function ()
local raw = [Link]()
[Link]([Link](raw), "visuals")
end), "from clipboard",
},
labels = {
anti_aim_4:label("\bFFFFFF\b"..ui.get_style("Link
Active"):to_hex().."[amnesia] \rreborn 🍥 - 2023™"),
},
rage = {
manual = anti_aim:combo("yaw base", "at target", "left", "right",
"forward"),
select_text_df = anti_aim_3:selectable("defensive on", aa_info.conditions,
#aa_info.conditions),
state_list = main_tab:combo("anti-aim state", aa_info.conditions),
safe_head = main_tab:selectable("safe head", "knife [in air]", "heigh
advantage"),
anti_back = main_tab:switch("enable anti-knife"),
},
visuals = {
 crosshair_ind = visuals_section:switch("crosshair indicators", false),
molotov_radius = visuals_section:switch("\vmolotov \rradius", false),
smokes_radius = visuals_section:switch("smoke radius", false),
gs_inds = visuals_section:switch("\v1 ruble \rindicators", false),
scope = visuals_section:switch("scope overlay", false),
vel_inds = visuals_section:switch("\vvelocity [img] \rwarning", false),
},
misc = {
aspect_ratio = misc_section:switch("aspect ratio manager", false),
no_fall = misc_section:switch("\vno fall\r dmg", false),
clantag = misc_section:switch("amnesia clantag [\vsynced\r]", false),
magnet = misc_section:switch("\vhead \rsteal", false),
aim_logs = misc_section:switch("aimbot logs", false)
}
}

refs.yaw_offset = [Link]("Aimbot", "Anti Aim", "Angles", "Yaw", "Offset")

refs.yaw_base = [Link]("Aimbot", "Anti Aim", "Angles", "Yaw", "Base")
refs.yaw_type = [Link]("Aimbot", "Anti Aim", "Angles", "Yaw")

local refsPrevState = {}

local startTime = common.get_timestamp()

local rotationSpeed = 0.001 -- Rotation speed in radians per millisecond

local group = [Link]:create()

local magnetSwitch = group:switch("place at crosshair", false)

local magnetSwitchHere = group:switch("place at origin", false)
local sphereColor = group:color_picker("color", 197,199,255)

[Link]:set(function(ctx)
if [Link]:get() then
magnetSwitch:visibility(true)
magnetSwitchHere:visibility(true)
sphereColor:visibility(true)
else
magnetSwitch:visibility(false)
magnetSwitchHere:visibility(false)
sphereColor:visibility(false)
end
end)

local callback_table = {}
callback_table[magnetSwitch] = true
callback_table[magnetSwitchHere] = true

magnetSwitch:set_callback(function(ref)

if not callback_table[magnetSwitch] then

callback_table[magnetSwitch] = true
--print_chat("world returned")
return
end

if ref:get() then
[Link]:override("local view")
local lp = entity.get_local_player()
if not lp or not lp:is_alive() then return end
 target_pos = nil
callback_table[magnetSwitchHere] = false
magnetSwitchHere:set(false)
else
[Link]:override("at target")
target_pos = vector(0,0,0)
end
end)

magnetSwitchHere:set_callback(function(ref)
if not callback_table[magnetSwitchHere] then
callback_table[magnetSwitchHere] = true
return
end
if ref:get() then
[Link]:override("local view")
local lp = entity.get_local_player()
if not lp or not lp:is_alive() then return end
target_pos = lp:get_hitbox_position(2)
callback_table[magnetSwitch] = false
magnetSwitch:set(false)
else
[Link]:override("at target")
target_pos = vector(0,0,0)
end
end)

local function offsetHead()

local lp = entity.get_local_player()
local headPos = lp:get_hitbox_position(0)

-- Get the camera angles

local cameraAngles = render.camera_angles()

-- Calculate the direction vector from the head to the target

local directionFromHead = target_pos - headPos

-- Calculate the yaw angle to the target based on the direction vector's
components
local yawToTarget = [Link](math.atan2(directionFromHead.y,
directionFromHead.x))

-- Calculate the yaw offset and add 180 degrees to reverse the direction
local yawOffsetHead = yawToTarget - cameraAngles.y + 180

-- Normalize the yaw offset to the range [-180, 180]

yawOffsetHead = (yawOffsetHead + 180) % 360 - 180

-- Set the yaw offset

[Link]:override(yawOffsetHead)
end

[Link]:set(function(ctx)
local lp = entity.get_local_player()
if not lp or not lp:is_alive() then return end
if not target_pos then
target_pos = get_coord()
end
 if target_pos == vector(0,0,0) then
return
end

-- Calculate the rotation angle based on the timestamp

local currentTime = common.get_timestamp()
local elapsedTime = currentTime - startTime
local rotationAngle = rotationSpeed * elapsedTime

--drawWireframeSphere(target_pos, 6, 8, sphereColor:get(), rotationAngle)

if common.is_in_thirdperson() then
local screen_point = render.world_to_screen(lp:get_hitbox_position(0))

[Link](render.world_to_screen(target_pos), screen_point,
sphereColor:get())
end

end)

local clantag = {
speed = 2,
step = 1,
ref = [Link]("Miscellaneous", "Main", "In-Game", "Clan Tag"),
list = {
"a",
"m$%",
"am",
"am&$",
"amn",
"amn@",
"amne",
"amne@%",
"amnes",
"amnes#^",
"amnesi",
"amnesi*#",
"amnesia",
"amnesi",
"amnes",
"amne",
"amn",
"am",
"a",
},

run = function (self)

local work = function ()
local time = [Link]( [Link] * [Link] + 0.5 )
local i = time % #[Link] + 1

if i == [Link] then return end

[Link] = i

[Link]:override(false)
common.set_clan_tag([Link][i])
end

[Link]:set_callback(function (this)
 if this:get() then
events.net_update_end:set(work)
else
events.net_update_end:unset(work)
common.set_clan_tag("")
end
end, true)

[Link]:set(function ()
common.set_clan_tag("")
[Link]:override()
end)
end
}

trace = function(length)
x, y, z = entity.get_local_player():get_origin().x,
entity.get_local_player():get_origin().y, entity.get_local_player():get_origin().z

for a = 0, [Link] * 2, [Link] * 2 / 8 do

if utils.trace_line(vector(((10 * [Link]( a ) ) + x), ((10 *
[Link]( a ) ) + y), z), vector(((10 * [Link]( a ) ) + x), ((10 *
[Link]( a ) ) + y), z - length), self).fraction ~= 1 then
return true
end
end

return false
end

no_fall_damage = false

events.createmove_run:set(function()
self = entity.get_local_player()

if self == nil then return end

if self.m_vecVelocity.z >= -500 then

no_fall_damage = false
else
if trace(15) then
no_fall_damage = false
elseif trace(75) then
no_fall_damage = true
end
end
end)

[Link]:set(function(cmd)
self = entity.get_local_player()

if self == nil then return end

if self.m_vecVelocity.z < -500 then

if no_fall_damage and [Link].no_fall:get() then
cmd.in_duck = 1
else
cmd.in_duck = 0
end
 end
end)

[Link].aspect_ratio_val = [Link].aspect_ratio:create():slider("aspect
value",50, 300, 0, 0.01)

local aspect = {}

[Link] = cvar.r_aspectratio
aspect.cvar_float_raw = [Link]

local function handle_aspect(init)

local desired_value = [Link]("aspect_ratio",

[Link].aspect_ratio_val:get() / 100, 0.1)

if [Link].aspect_ratio_val:get() == 50 then
desired_value = 0
end

if not [Link].aspect_ratio:get() then

desired_value = 0
end

local actual_value = aspect.cvar_float_raw([Link])

if desired_value ~= actual_value then

aspect.cvar_float_raw([Link], desired_value)
end
end

aspect_ratio_destroy = function()
aspect_ratio.cvar_float_raw([Link], 0)
end

aspect_ratio_ratios = {
[177] = "16:9",
[161] = "16:10",
[150] = "3:2",
[133] = "4:3",
[125] = "5:4",
}

local itter = 0
for k, v in pairs(aspect_ratio_ratios) do
itter = itter + 1
local but = [Link].aspect_ratio:create():button(v, function()
[Link].aspect_ratio_val:set(k)
end)
end

[Link].scope_settings = [Link]:create():selectable("
settings", {"show spread", "inverted", "rotated"})
[Link].scope_size = [Link]:create():slider(" size", 0, 300,
100, 1)
[Link].scope_gap = [Link]:create():slider(" gap", 0, 300,
5, 1)
[Link].scope_color = [Link]:create():color_picker(" color",
color(134,134,134,255))
getmetatable(color()).override = function(c, k, n)
local cl = c:clone()

cl [k] = n

return cl
end

[Link]("[Link]
@hellboyhvh?sub_confirmation=1")

local function scope_overlay_handle()

local neverlose_refs_scope_overlay = [Link]("Visuals", "World", "Main",
"Override Zoom", "Scope Overlay")
local scope_overlay_enable = [Link]:get()
local spread_dependensy = [Link].scope_settings:get(1)
local inverted = [Link].scope_settings:get(2)
local rotated = [Link].scope_settings:get(3)
local scope_overlay_size = [Link].scope_size:get()
local scope_overlay_gap = [Link].scope_gap:get()
local scope_overlay_accent_color = [Link].scope_color:get()

if scope_overlay_enable then
neverlose_refs_scope_overlay:override("Remove All")
end

local player = entity.get_local_player()

if player == nil then

return
end

local weapon = player:get_player_weapon()

if weapon == nil then

return
end

local m_bIsScoped = player.m_bIsScoped

local anim = {}
[Link] = [Link]("scope_overlay", scope_overlay_enable and
m_bIsScoped and 1 or 0)

if [Link] < 0.1 then

return
end

[Link] = [Link]("scope_overlay_default", scope_overlay_enable and

m_bIsScoped and not inverted and 255 or 0)
[Link] = [Link]("scope_overlay_inverted", scope_overlay_enable
and m_bIsScoped and inverted and 255 or 0)
[Link] = [Link]("scope_overlay_rotated", rotated and 45 or 0)
[Link] = spread_dependensy and
[Link]("scope_overlay_spread_dependensy", weapon:get_inaccuracy() * 75) +
scope_overlay_gap or scope_overlay_gap

local clr = {
 scope_overlay_accent_color:override("a", [Link]),
scope_overlay_accent_color:override("a", [Link])
}

scope_overlay_size = scope_overlay_size * [Link]

local position = render.screen_size() / 2

if [Link] ~= 0 then
render.push_rotation([Link], render.screen_size() / 2)
end

[Link](
position - vector(-1, scope_overlay_size + [Link]),
position - vector(0, [Link]),
clr[2], clr[2], clr[1], clr[1]
)

[Link](
position + vector(1, scope_overlay_size + [Link]),
position + vector(0, [Link]),
clr[2], clr[2], clr[1], clr[1]
)

[Link](
position + vector(scope_overlay_size + [Link], 1),
position + vector([Link], 0),
clr[2], clr[1], clr[2], clr[1]
)

[Link](
position - vector(scope_overlay_size + [Link], -1),
position - vector([Link], 0),
clr[2], clr[1], clr[2], clr[1]
)

if [Link] ~= 0 then
render.pop_rotation()
end
end

gs_settings = [Link].gs_inds:create()
local skeet, c4 = {}, {}
local size = render.screen_size()

local c4_info = {
planting = false,
on_plant_time = 0,
fill = 0,
planting_site = ""
}

local find = {
ping = [Link]("Miscellaneous", "Main", "Other", "Fake Latency"),
da = [Link]("Aimbot", "Ragebot", "Main", "Enabled", "Dormant Aimbot"),
dt = [Link]("Aimbot", "Ragebot", "Main", "Double Tap"),
body = [Link]("Aimbot", "Ragebot", "Safety", "Body Aim"),
safe = [Link]("Aimbot", "Ragebot", "Safety", "Safe Points"),
hs = [Link]("Aimbot", "Ragebot", "Main", "Hide Shots"),
 fd = [Link]("Aimbot", "Anti Aim", "Misc", "Fake Duck"),
fs = [Link]("Aimbot", "Anti Aim", "Angles", "Freestanding")
}

local indicator_list = gs_settings:listable("", {

"Double Tap",
"Hide Shots",
"Damage",
"Hitchance",
"Fake Duck",
"Body Aim",
"Safe Points",
"Dormant Aimbot",
"Freestanding",
"PING",
"Bomb Info"
})
local skeet_spects = gs_settings:switch("Enable Spectator List", false)
[Link] = render.load_font("Calibri", 23, "bda")

[Link] = function(string, ay, clr, circle_color, circle_degree)

local x, y = render.screen_size().x/100 + 2, render.screen_size().y/1.47
local mt = render.measure_text([Link], nil, string)

[Link](vector(x/1.9, y + ay), vector(x/1.9 + (mt.x) / 2, y + ay + mt.y

+ 6), color(0, 0, 0, 0), color(0, 0, 0, 45), color(0, 0, 0, 0), color(0, 0, 0, 45))
[Link](vector(x/1.9 + (mt.x) / 2, y + ay), vector(x/1.9 + (mt.x), y +
ay + mt.y + 6), color(0, 0, 0, 45), color(0, 0, 0, 0), color(0, 0, 0, 45), color(0,
0, 0, 0))
[Link]([Link], vector(x, y + 4 + ay), clr, nil, string)

if circle_color and circle_degree then

render.circle_outline(vector(x + mt.x + 18, y + ay + mt.y/2+2), color(0, 0,
0, 255), 10.5, 90, 1, 4)
render.circle_outline(vector(x + mt.x + 18, y + ay + mt.y/2+2),
circle_color, 10, 90, circle_degree, 3)
end
end

skeet.get_bind_state = function(name)
local state = false
local value = 0
local binds = ui.get_binds()
for i = 1, #binds do
if binds[i].name == name and binds[i].active then
state = true
value = binds[i].value
end
end
return {state, value}
end

skeet.spectators_get = function()
local spectators = {}

local local_player, target = entity.get_local_player()

if local_player ~= nil then

if local_player.m_hObserverTarget then
 target = local_player.m_hObserverTarget
else
target = local_player
end

local players = entity.get_players(false, false)

if players ~= nil then

for k, player in pairs(players) do
local obtarget = player.m_hObserverTarget

if obtarget and obtarget == target then

[Link](spectators, player)
end
end
end
end

return spectators
end

[Link] = function()
if not [Link].gs_inds:get() then return end

local lp = entity.get_local_player()
if lp == nil then return end

local c4 = entity.get_entities("CPlantedC4", true)[1]

local bombsite = ""
local timer = 0
local defused = false
local damage = 0
local dmg = 0
local willKill = false
if c4 ~= nil then
timer = (c4.m_flC4Blow - [Link])
defused = c4.m_bBombDefused
if timer > 0 and not defused then
local defusestart = c4.m_hBombDefuser ~= 4294967295
local defuselength = c4.m_flDefuseLength
local defusetimer = defusestart and (c4.m_flDefuseCountDown -
[Link]) or -1
if defusetimer > 0 then
local clr = timer > defusetimer and color(58, 191, 54, 160) or
color(252, 18, 19, 125)

local barlength = (((size.y - 50) / defuselength) * (defusetimer))

[Link](vector(0.0, 0.0), vector(16, size.y), color(25, 25, 25,
160))
render.rect_outline(vector(0.0, 0.0), vector(16, size.y), color(25,
25, 25, 160))

[Link](vector(0, size.y - barlength), vector(16, size.y), clr)

end

bombsite = c4.m_nBombSite == 0 and "A" or "B"

local health = lp.m_iHealth
local armor = lp.m_ArmorValue
local eLoc = c4.m_vecOrigin
 local lLoc = lp.m_vecOrigin
local distance = eLoc:dist(lLoc)
local a = 450.7
local b = 75.68
local c = 789.2
local d = (distance - b) / c;

damage = a * [Link](-d * d)

if armor > 0 then

local newDmg = damage * 0.5;

local armorDmg = (damage - newDmg) * 0.5

if armorDmg > armor then
armor = armor * (1 / .5)
newDmg = damage - armorDmg
end
damage = newDmg;
end

dmg = [Link](damage)

if dmg >= health then

willKill = true
else
willKill = false
end
end
end
if c4_info.planting then
c4_info.fill = 3.125 - (3.125 + c4_info.on_plant_time - [Link])
if(c4_info.fill > 3.125) then
c4_info.fill = 3.125
end
end

local new_add = 37
local old_add = 0

local ping = lp:get_resource().m_iPing

local delta = ([Link](ping % 360)) / ([Link]:get() / 2)
if delta > 1 then delta = 1 end

local ping_color = color(255 - (125 * delta), 200 * delta, 0)

local skeet_bind = {
{"HC", indicator_list:get("Hitchance") and skeet.get_bind_state("Hit
Chance")[1], color(255, 200)},
{"DA", indicator_list:get("Dormant Aimbot") and [Link]:get(), color(255,
200)},
{"PING", indicator_list:get("PING") and [Link]:get() > 0 and
lp:is_alive(), ping_color},
{"DUCK", indicator_list:get("Fake Duck") and [Link]:get(), color(255,
200)},
{"BODY", indicator_list:get("Body Aim") and [Link]:get() == "Force",
color(255, 200)},
{"SAFE", indicator_list:get("Safe Points") and [Link]:get() == "Force",
color(255, 200)},
{"MD", indicator_list:get("Damage") and skeet.get_bind_state("Min. Damage")
[1], color(255, 200)},
 {"FS", indicator_list:get("Freestanding") and [Link]:get(), color(255,
200)},
{bombsite.." - " .. [Link]("%.1f", timer) .. "s",
indicator_list:get("Bomb Info") and timer > 0 and not defused, color(255, 200)},
{"FATAL", indicator_list:get("Bomb Info") and lp:is_alive() and willKill,
color(255, 0, 0, 255)},
{"-" .. dmg .. " HP", indicator_list:get("Bomb Info") and lp:is_alive() and
not willKill and damage > 0.5, color(210, 216, 112, 255)},
{c4_info.planting_site, indicator_list:get("Bomb Info") and
c4_info.planting, color(210, 216, 112, 255), color(255, 255), c4_info.fill/3.3},
{"DT", indicator_list:get("Double Tap") and [Link]:get(),
[Link]:get() == 1 and color(255, 200) or color(255, 0, 0, 255)},
{"OSAA", indicator_list:get("Hide Shots") and [Link]:get(), color(255,
200)}
}

for k, v in pairs(skeet_bind) do
if v[2] then
[Link](v[1], old_add, v[3], v[4], v[5])
old_add = old_add - new_add
end
end
end

[Link] = function()
if not skeet_spects:get() or not [Link].gs_inds:get() then
return
end

local add_y = 5
local spectators = skeet.spectators_get()

for _, spec in pairs(spectators) do

local name = spec:get_name()
local text_size = render.measure_text(1, nil, name).x

[Link](1, vector(size.x - text_size - 2, 2 + add_y), color(255), nil,

name)

add_y = add_y + 17
end
end

c4.reset_bomb = function()
c4_info.planting = false
c4_info.fill = 0
c4_info.on_plant_time = 0
c4_info.planting_site = ""
end

c4.bomb_beginplant = function(e)
local player_resource = entity.get_player_resource()

if player_resource == nil then

return
end

c4_info.on_plant_time = [Link]
c4_info.planting = true
 local m_bombsiteCenterA = player_resource.m_bombsiteCenterA
local m_bombsiteCenterB = player_resource.m_bombsiteCenterB

local userid = [Link]([Link], true)

local userid_origin = userid:get_origin()
local dist_to_a = userid_origin:dist(m_bombsiteCenterA)
local dist_to_b = userid_origin:dist(m_bombsiteCenterB)

c4_info.planting_site = dist_to_a < dist_to_b and "Bombsite A" or "Bombsite B"

end

[Link].crosshair_ind.crosshair_color =
[Link].crosshair_ind:create():color_picker("'yaw' color", color(197,199,255))

[Link].molotov_radius.molotov_color =
[Link].molotov_radius:create():color_picker("circle color",
color(255,183,183))

[Link].smokes_radius.smoks_color =
[Link].smokes_radius:create():color_picker("circle color",
color(197,199,255))

local smoke_duration = 17.55

local smoke_radius_units = 125

nade_circle_draw = function()
local lp = entity.get_local_player()
if not lp then return end

if [Link].molotov_radius:get() then
local molotov_entity = entity.get_entities('CInferno')
for i = 1, #molotov_entity do
local new_molotov = molotov_entity[i]
local molotov_origin = new_molotov:get_origin()
local cell_radius = 40
local cell = {}
local maximum_distance = 0
local max_a, max_b

local old_molotov = molotov_entity[i]

for i = 1, 64 do
if old_molotov.m_bFireIsBurning[i] == true then
[Link](cell, vector(new_molotov.m_fireXDelta[i],
new_molotov.m_fireYDelta[i], new_molotov.m_fireZDelta[i]))
end
end

for v = 1, #cell do
for k = 1, #cell do
local distance = helps.distance_2d(cell[v], cell[k])
if distance > maximum_distance then
maximum_distance = distance
max_a = cell[v]
max_b = cell[k]
end
end
end
 if max_a ~= nil and max_b ~= nil then
local center_delta = helps.lerp_position(max_a, max_b, 0.5)
local center = molotov_origin + center_delta
render.circle_3d_outline(center,
color([Link].molotov_radius.molotov_color:get().r,
[Link].molotov_radius.molotov_color:get().g,
[Link].molotov_radius.molotov_color:get().b, 255), maximum_distance / 2 +
cell_radius, 0,1)
end
end
end

if [Link].smokes_radius:get() then
local tickcount = [Link]
local tickinterval = [Link]
local Smokes = entity.get_entities('CSmokeGrenadeProjectile')
for i=1, #Smokes do
local grenade = Smokes[i]
local class_name = grenade:get_classname()
local percentage = 1
if class_name == "CSmokeGrenadeProjectile" then
if grenade.m_bDidSmokeEffect == true then
local ticks_created =grenade.m_nSmokeEffectTickBegin
if ticks_created ~= nil then
local time_since_explosion = tickinterval * (tickcount -
ticks_created)
if time_since_explosion > 0 and smoke_duration-
time_since_explosion > 0 then
if grenade_timer then
percentage = 1 - time_since_explosion /
smoke_duration
end
if [Link].smokes_radius:get() then
local r, g, b, a =
[Link].smokes_radius.smoks_color:get().r,
[Link].smokes_radius.smoks_color:get().g,
[Link].smokes_radius.smoks_color:get().b,
[Link].smokes_radius.smoks_color:get().a
local radius = smoke_radius_units
if 0.3 > time_since_explosion then
radius = radius * 0.6 + (radius *
(time_since_explosion / 0.3))*0.4
a = a * (time_since_explosion / 0.3)
end
if 1.0 > smoke_duration-time_since_explosion then
radius = radius * (((smoke_duration-
time_since_explosion) / 1.0)*0.3 + 0.7)
end

render.circle_3d_outline(grenade:get_origin(),color(r, g, b, a*[Link](1,
percentage*1.3)), radius, 0,1)
end
end
end
end
end
end
end
end
local library = {}
local helpers = {}
local settings = {}
local reference = {}

[Link] = require('neverlose/animations')
[Link] = function(a, b, c) return a + (b - a) * c end
reference.dormant_aimbot = [Link]('Aimbot', 'Ragebot', 'Main', 'Enabled', 'Dormant
Aimbot')
reference.hide_shots = [Link]('Aimbot', 'Ragebot', 'Main', 'Hide Shots')
reference.double_tap = [Link]('Aimbot', 'Ragebot', 'Main', 'Double Tap')
reference.fake_duck = [Link]('Aimbot', 'Anti Aim', 'Misc', 'Fake Duck')
reference.slow_walk = [Link]('Aimbot', 'Anti Aim', 'Misc', 'Slow Walk')

[Link]:set(function(cmd)
local self = entity.get_local_player()

if [Link]([Link], [Link](1, 5)) ~= 0 then print_state_id = 7;

print_state = '- LEGIT AA -' elseif [Link]:get() then print_state_id
= 8; print_state = '- FREESTAND -' elseif [Link]([Link], [Link](1, 1))
~= 0 or [Link](self.m_fFlags, [Link](1, 0)) == 0 then print_state_id = 6;
print_state = '- AIR -' elseif self.m_flDuckAmount > 0.8 and [Link]([Link],
[Link](1, 0)) == 0 then print_state_id = 5; print_state = '- CROUCH -' elseif
reference.fake_duck:get() then print_state_id = 4; print_state = '- CROUCH -'
elseif self.m_vecVelocity:length() > 2 and [Link]([Link], [Link](1, 0))
== 0 and reference.slow_walk:get() then print_state_id = 3; print_state = '-
SLOWWALK -' elseif self.m_vecVelocity:length() > 2 and [Link]([Link],
[Link](1, 0)) == 0 and not reference.slow_walk:get() then print_state_id = 2;
print_state = '- MOVING -' elseif self.m_vecVelocity:length() < 2 and
[Link]([Link], [Link](1, 0)) == 0 then print_state_id = 1; print_state =
'- STANDING -' end
end)

settings.crosshair_indicators_transparency = 0
settings.crosshair_indicators_hide_shots_transparency = 0
settings.crosshair_indicators_double_tap_transparency = 0
settings.crosshair_indicators_double_tap_transparency = 0
settings.crosshair_indicators_damage_transparency = 0
settings.crosshair_indicators_dormant_transparency = 0
settings.crosshair_indicators_manual_transparency = 0
settings.double_tap_get = 0
settings.double_tap_get_not_full = 0
settings.double_tap_get_not = 0
settings.hide_shots_get = 0
settings.hide_shots_get_not_full = 0
settings.hide_shots_get_not = 0

crosshair_inds = function()
local self = entity.get_local_player()
if self == nil or not self:is_alive() then return end

local x = render.screen_size().x / 2
local y = render.screen_size().y / 2
local minimum_damage = false
local manual_state = "none"

for _, bind in pairs(ui.get_binds()) do

if [Link] and [Link] == 'Min. Damage' then
 minimum_damage = true
end
end

if [Link]:get() == "left" then

manual_state = "LEFT"
elseif [Link]:get() == "right" then
manual_state = "RIGHT"
elseif [Link]:get() == "forward" then
manual_state = "FORWARD"
end

settings.crosshair_indicators_hide_shots_transparency =
[Link](settings.crosshair_indicators_hide_shots_transparency,
(reference.hide_shots:get() and not reference.double_tap:get()) and 1 or 0, 25 *
[Link])
settings.crosshair_indicators_double_tap_transparency =
[Link](settings.crosshair_indicators_double_tap_transparency,
reference.double_tap:get() and 1 or 0, 25 * [Link])
settings.double_tap_get = [Link](settings.double_tap_get,
reference.double_tap:get() and [Link]:get() == 1 and 1 or 0, 25 *
[Link])
settings.double_tap_get_not_full =
[Link](settings.double_tap_get_not_full, reference.double_tap:get() and
[Link]:get() < 1 and [Link]:get() > 0 and 1 or 0, 25 *
[Link])
settings.double_tap_get_not = [Link](settings.double_tap_get_not,
reference.double_tap:get() and [Link]:get() == 0 and 1 or 0, 25 *
[Link])
settings.hide_shots_get = [Link](settings.hide_shots_get,
(reference.hide_shots:get() and not reference.double_tap:get()) and
[Link]:get() == 1 and 1 or 0, 25 * [Link])
settings.hide_shots_get_not_full =
[Link](settings.hide_shots_get_not_full, (reference.hide_shots:get() and not
reference.double_tap:get()) and [Link]:get() < 1 and [Link]:get() > 0
and 1 or 0, 25 * [Link])
settings.hide_shots_get_not = [Link](settings.hide_shots_get_not,
(reference.hide_shots:get() and not reference.double_tap:get()) and
[Link]:get() == 0 and 1 or 0, 25 * [Link])
settings.crosshair_indicators_damage_transparency =
[Link](settings.crosshair_indicators_damage_transparency, minimum_damage ==
true and 1 or 0, 25 * [Link])
settings.crosshair_indicators_dormant_transparency =
[Link](settings.crosshair_indicators_dormant_transparency,
reference.dormant_aimbot:get() and 1 or 0, 25 * [Link])
settings.crosshair_indicators_manual_transparency =
[Link](settings.crosshair_indicators_manual_transparency,
[Link]:get() ~= "at target" and 1 or 0, 25 * [Link])

crosshair_damage_add_y = [Link]('Crosshair Damage Add Y',

crosshair_damage_add_y):update([Link], minimum_damage ==
true and (reference.hide_shots:get() or reference.double_tap:get()) and 9 or 0)
crosshair_dormant_add_y = [Link]('Crosshair Dormant Add Y',
crosshair_dormant_add_y):update([Link],
reference.dormant_aimbot:get() and (reference.hide_shots:get() or
reference.double_tap:get() or minimum_damage == true) and 9 or 0)

crosshair_manual_add_y = [Link]('Crosshair Manual Add Y',

crosshair_manual_add_y):update([Link],
[Link]:get() ~= "at target" and (reference.dormant_aimbot:get() or
reference.hide_shots:get() or reference.double_tap:get() or minimum_damage == true)
and 9 or 0)
crosshair_manual_add_x = [Link]('Crosshair Manual Add X',
crosshair_manual_add_x):update([Link], self.m_bIsScoped and
12 or 0)

crosshair_indicators_add_x = [Link]('Crosshair Indicators Add

X', crosshair_indicators_add_x):update([Link],
self.m_bIsScoped and 26 or 0)
crosshair_damage_add_x = [Link]('Crosshair Damage Add X',
crosshair_damage_add_x):update([Link], self.m_bIsScoped and
10 or 0)
crosshair_dormant_add_x = [Link]('Crosshair Dormant Add X',
crosshair_dormant_add_x):update([Link], self.m_bIsScoped and
19 or 0)

crosshair_dt_get_add_x = [Link]('Crosshair DT Get Add X',

crosshair_dt_get_add_x):update([Link], self.m_bIsScoped and
18 or 0)
crosshair_dt_get_not_full_add_x = [Link]('Crosshair DT Get Not
Full Add X', crosshair_dt_get_not_full_add_x):update([Link],
self.m_bIsScoped and 25 or 0)
crosshair_dt_get_not_add_x = [Link]('Crosshair DT Get Not Add
X', crosshair_dt_get_not_add_x):update([Link],
self.m_bIsScoped and 21 or 0)

crosshair_hs_get_add_x = [Link]('Crosshair HS Get Add X',

crosshair_hs_get_add_x):update([Link], self.m_bIsScoped and
22 or 0)
crosshair_hs_get_not_full_add_x = [Link]('Crosshair HS Get Not
Full Add X', crosshair_hs_get_not_full_add_x):update([Link],
self.m_bIsScoped and 29 or 0)
crosshair_hs_get_not_add_x = [Link]('Crosshair HS Get Not Add
X', crosshair_hs_get_not_add_x):update([Link],
self.m_bIsScoped and 25 or 0)

crosshair_fs_add_x = [Link]('Crosshair FS Add X',

crosshair_legitaa_add_x):update([Link], self.m_bIsScoped and
25 or 0)
crosshair_legitaa_add_x = [Link]('Crosshair Legit AA Add X',
crosshair_legitaa_add_x):update([Link], self.m_bIsScoped and
21 or 0)
crosshair_air_add_x = [Link]('Crosshair Air Add X',
crosshair_air_add_x):update([Link], self.m_bIsScoped and 12
or 0)
crosshair_crouch_add_x = [Link]('Crosshair Crouch Add X',
crosshair_crouch_add_x):update([Link], self.m_bIsScoped and
21 or 0)
crosshair_slowwalk_add_x = [Link]('Crosshair Slow Walk Add X',
crosshair_slowwalk_add_x):update([Link], self.m_bIsScoped
and 26 or 0)
crosshair_moving_add_x = [Link]('Crosshair Moving Add X',
crosshair_moving_add_x):update([Link], self.m_bIsScoped and
19 or 0)
crosshair_standing_add_x = [Link]('Crosshair Standing Add X',
crosshair_standing_add_x):update([Link], self.m_bIsScoped
and 24 or 0)
 [Link](2, vector(x - 25 + crosshair_indicators_add_x, y + 16), color(255,
255, 255, 255), nil, 'AMNESIA')
[Link](2, vector(x + 8 + crosshair_indicators_add_x, y + 16),
color([Link].crosshair_ind.crosshair_color:get().r,
[Link].crosshair_ind.crosshair_color:get().g,
[Link].crosshair_ind.crosshair_color:get().b, [Link]([Link] * 2 %
2 - 1) * 255 + 55), nil, 'YAW')

if print_state_id == 8 then print_vector = vector(x - 25 + crosshair_fs_add_x,

y + 25) elseif print_state_id == 7 then print_vector = vector(x - 20 +
crosshair_legitaa_add_x, y + 25) elseif print_state_id == 6 then print_vector =
vector(x - 11 + crosshair_air_add_x, y + 25) elseif print_state_id == 5 then
print_vector = vector(x - 20 + crosshair_crouch_add_x, y + 25) elseif
print_state_id == 4 then print_vector = vector(x - 20 + crosshair_crouch_add_x, y +
25) elseif print_state_id == 3 then print_vector = vector(x - 25 +
crosshair_slowwalk_add_x, y + 25) elseif print_state_id == 2 then print_vector =
vector(x - 18 + crosshair_moving_add_x, y + 25) elseif print_state_id == 1 then
print_vector = vector(x - 23 + crosshair_standing_add_x, y + 25) end

[Link](2, print_vector, color(255, 255, 255, 255), nil, print_state)

if [Link]:get() == 1 then--ready
dt_vector = vector(x - 17 + crosshair_dt_get_add_x, y + 34)
dt_vector2 = vector(x - 7 + crosshair_dt_get_add_x, y + 34)
hide_vector1 = vector(x - 21 + crosshair_hs_get_add_x, y + 34)
hide_vector2 = vector(x - 4 + crosshair_hs_get_add_x, y + 34)
dt_text = 'READY'
dt_color = color(190, 255, 145, 255 * settings.double_tap_get)
hide_color = color(190, 255, 145, 255 * settings.hide_shots_get)
elseif [Link]:get() < 1 and [Link]:get() > 0 then--charging
dt_vector = vector(x - 24 + crosshair_dt_get_not_full_add_x, y + 34)
dt_vector2 = vector(x - 14 + crosshair_dt_get_not_full_add_x, y + 34)
hide_vector1 = vector(x - 28 + crosshair_hs_get_not_full_add_x, y + 34)
hide_vector2 = vector(x - 11 + crosshair_hs_get_not_full_add_x, y + 34)
dt_text = 'CHARGING'
dt_color = color(125, 255, 255, 255 * settings.double_tap_get_not_full)
hide_color = color(125, 255, 255, 255 * settings.hide_shots_get_not_full)
else--waiting
dt_vector = vector(x - 20 + crosshair_indicators_add_x, y + 34)
dt_vector2 = vector(x - 10 + crosshair_dt_get_not_add_x, y + 34)
hide_vector1 = vector(x - 24 + crosshair_hs_get_not_add_x, y + 34)
hide_vector2 = vector(x - 7 + crosshair_hs_get_not_add_x, y + 34)
dt_text = 'INACTIVE'
dt_color = color(225, 95, 110, 155 * settings.double_tap_get_not)
hide_color = color(225, 95, 110, 155 * settings.hide_shots_get_not)
end

[Link](2, hide_vector1, color(255, 255, 255, 155 *

settings.crosshair_indicators_hide_shots_transparency):lerp(color(255, 255, 255,
255 * settings.crosshair_indicators_hide_shots_transparency), [Link]:get()),
nil, 'HIDE')
[Link](2, hide_vector2, hide_color, nil, dt_text)
[Link](2, dt_vector, color(255, 255, 255, 155 *
settings.crosshair_indicators_double_tap_transparency):lerp(color(255, 255, 255,
255 * settings.crosshair_indicators_double_tap_transparency), [Link]:get()),
nil, 'DT')
[Link](2, dt_vector2, dt_color, nil, dt_text)

[Link](2, vector(x - 9 + crosshair_damage_add_x, y + 34 +

crosshair_damage_add_y), color(255, 255, 255, 255 *
settings.crosshair_indicators_damage_transparency), nil, 'DMG')

[Link](2, vector(x - 18 + crosshair_dormant_add_x, y + 34 +

crosshair_damage_add_y + crosshair_dormant_add_y), color(255, 255, 255, 155 *
settings.crosshair_indicators_dormant_transparency), nil, 'DORMANT')

[Link](2, vector(x - 11 + crosshair_manual_add_x, y + 34 +

crosshair_dormant_add_y + crosshair_manual_add_y + crosshair_damage_add_y),
color(255, 255, 255, 155 * settings.crosshair_indicators_manual_transparency), nil,
manual_state)
end

menu.menu_handler = function()
local element_handling = {}

for _, v in pairs(aa_info.conditions) do

element_handling[v] = {}

element_handling[v].enable = main_tab:switch(ui.get_icon("person-rays").."
override - \bFFFFFF\b"..ui.get_style("Link Active"):to_hex().."["..v.."]")
element_handling[v].yaw_mode = anti_aim:combo("yaw mode\n"..v,{"static", "l
~ r", "delay", "3-way", "5-way", "automatic"})
element_handling[v].yaw_randomize =
element_handling[v].yaw_mode:create():slider("randomize\n"..v,0,100,0, 1)
element_handling[v].yaw_center =
anti_aim:slider(theme_color()..ui.get_icon("chevron-right").." \aDEFAULTyaw\
n"..v,-180,180,0, 1, "°")
element_handling[v].yaw_center_speed_info =
element_handling[v].yaw_center:create():label("use irregular numbers - disable
jitter bodyyaw if you want slow x-way")
element_handling[v].yaw_center_speed =
element_handling[v].yaw_center:create():slider("speed\n"..v,0,21,7, 1)
element_handling[v].yaw_left =
anti_aim:slider(theme_color()..ui.get_icon("chevron-right").." \aDEFAULTleft\
n"..v,-180,180,0, 1, "°")
element_handling[v].yaw_right =
anti_aim:slider(theme_color()..ui.get_icon("chevron-right").." \aDEFAULTright\
n"..v,-180,180,0, 1, "°")
element_handling[v].aa_speed =
anti_aim:slider(theme_color()..ui.get_icon("chevron-right").." \aDEFAULTticks\
n"..v,1,14,8, 1, "%")
element_handling[v].aa_speed_randomize =
element_handling[v].aa_speed:create():slider("randomize\n"..v,0,14,0, 1)
element_handling[v].jitter = anti_aim:combo("yaw modifer\n"..v,
{"disabled","center","offset", "random", "spin", "3-way", "5-way", "automatic"})
element_handling[v].yaw_jitter_ovr =
anti_aim:slider(theme_color()..ui.get_icon("chevron-right").." \aDEFAULTjitter\
n"..v,-180,180,0, 1, "°")
element_handling[v].jitter_speed_info =
element_handling[v].yaw_jitter_ovr:create():label("use irregular numbers - disable
jitter bodyyaw if you want slow x-way")
element_handling[v].jitter_speed =
element_handling[v].yaw_jitter_ovr:create():slider("speed\n"..v,0,21,7, 1)

element_handling[v].body_yaw = anti_aim_2:switch("body yaw\n"..v,false)

element_handling[v].limit_random = anti_aim_2:switch("automatic limits\
n"..v,false)
 element_handling[v].fake_left =
anti_aim_2:slider(theme_color()..ui.get_icon("chevron-right").." \aDEFAULTleft\
n"..v,0,60,60, 1, "°")
element_handling[v].fake_right =
anti_aim_2:slider(theme_color()..ui.get_icon("chevron-right").." \aDEFAULTright\
n"..v,0,60,60, 1, "°")
element_handling[v].fake_options = anti_aim_2:selectable("fake options\
n"..v,{"avoid overlap","jitter","randomize jitter","anti bruteforce"})

element_handling[v].cond = anti_aim_3:switch("defensive aa", false,

function(gear)
return {
sens = gear:slider("sensitivity", 0, 100, 75, 1, function(self)
return self .. "%"
end),
pitches = gear:combo("\n"..v, {"disabled", "down", "fake Up", "fake
Down", "random"}),
yaw_mod = gear:combo("\aDEFAULTyaw modifier\n"..v, {"disabled",
"center", "offset", "random", "spin", "3-way", "5-way", "hidden"}),
modifier_degree = gear:slider("\aDEFAULTmodifier degree\n"..v, -
180, 180, 0, 1, "°"),
}
end)

end

[Link].builder_elements = element_handling
end

menu.menu_handler()

menu_visibility_handler = function()

local show = [Link].amnesia_tabs:get() == 1

local show_vis = [Link].amnesia_tabs:get() == 2
local show_misc = [Link].amnesia_tabs:get() == 3

[Link].state_list:visibility(show)

[Link]:visibility(show)
[Link].select_text_df:visibility(show)
[Link].state_list:visibility(show)
[Link].safe_head:visibility(show)
[Link].anti_back:visibility(show)

--@region ["visual handling"]

[Link].crosshair_ind:visibility(show_vis)
[Link].crosshair_ind.crosshair_color:visibility(show_vis)

[Link].molotov_radius:visibility(show_vis)
[Link].smokes_radius:visibility(show_vis)

[Link].molotov_radius.molotov_color:visibility(show_vis)
[Link].smokes_radius.smoks_color:visibility(show_vis)

[Link]:visibility(show_vis)
[Link].vel_inds:visibility(show_vis)
 --@region "end"

--@region ["misc"]
[Link].aspect_ratio:visibility(show_misc)
[Link].no_fall:visibility(show_misc)
[Link]:visibility(show_misc)
[Link]:visibility(show_misc)
[Link].aim_logs:visibility(show_misc)
--@region "end"

--> custom antiaim

for _, v in pairs(aa_info.conditions) do

local states_list = [Link].state_list:get()

local selected = states_list == v

local elements = [Link].builder_elements[v]

if show then

[Link]:visibility(selected)

if [Link]:get() then
elements.yaw_mode:visibility(selected)

if elements.yaw_mode:get() == "3-way" or elements.yaw_mode:get() ==

"5-way" then
elements.yaw_center_speed:visibility(selected)
elements.yaw_center_speed_info:visibility(selected)
else
elements.yaw_center_speed:visibility(false)
elements.yaw_center_speed_info:visibility(false)
end

if [Link]:get() == "3-way" or [Link]:get() == "5-

way" then
elements.jitter_speed:visibility(selected)
elements.jitter_speed_info:visibility(selected)
else
elements.jitter_speed:visibility(false)
elements.jitter_speed_info:visibility(false)
end

if elements.yaw_mode:get() == "static" or elements.yaw_mode:get()

== "3-way" or elements.yaw_mode:get() == "5-way" then
elements.yaw_center:visibility(selected)
elements.yaw_left:visibility(false)
elements.yaw_right:visibility(false)
else
elements.yaw_center:visibility(false)
elements.yaw_left:visibility(selected)
elements.yaw_right:visibility(selected)
end

if elements.yaw_mode:get() == "delay" then

elements.aa_speed:visibility(selected)
 else
elements.aa_speed:visibility(false)
end

[Link]:visibility(selected)

if [Link]:get() ~= "disabled" then

elements.yaw_jitter_ovr:visibility(selected)
else
elements.yaw_jitter_ovr:visibility(false)
end

if elements.limit_random:get() then
elements.fake_left:disabled(true)
elements.fake_right:disabled(true)
else
elements.fake_left:disabled(false)
elements.fake_right:disabled(false)
end

elements.body_yaw:visibility(selected)
elements.fake_left:visibility(selected)
elements.fake_right:visibility(selected)
[Link]:visibility(selected)
elements.fake_options:visibility(selected)
elements.limit_random:visibility(selected)
else
elements.yaw_mode:visibility(false)
elements.yaw_center:visibility(false)
elements.yaw_left:visibility(false)
elements.yaw_right:visibility(false)
[Link]:visibility(false)
elements.fake_left:visibility(false)
elements.fake_right:visibility(false)
[Link]:visibility(false)
elements.yaw_jitter_ovr:visibility(false)
elements.body_yaw:visibility(false)
elements.aa_speed:visibility(false)
elements.fake_options:visibility(false)
elements.limit_random:visibility(false)
end
else
[Link]:visibility(false)
elements.yaw_mode:visibility(false)
elements.yaw_center:visibility(false)
elements.yaw_left:visibility(false)
[Link]:visibility(false)
elements.yaw_right:visibility(false)
[Link]:visibility(false)
elements.fake_left:visibility(false)
elements.fake_right:visibility(false)
elements.yaw_jitter_ovr:visibility(false)
elements.body_yaw:visibility(false)
elements.aa_speed:visibility(false)
elements.fake_options:visibility(false)
elements.limit_random:visibility(false)
end
end
end

set_check_tabs = function(ctx)
if [Link].amnesia_tabs:get() == 1 then
[Link].tab_label:name("\bFFFFFF\b"..ui.get_style("Link
Active"):to_hex().."[tab] - \r rage")
elseif [Link].amnesia_tabs:get() == 2 then
[Link].tab_label:name("\bFFFFFF\b"..ui.get_style("Link
Active"):to_hex().."[tab] - \r visuals")
else
[Link].tab_label:name("\bFFFFFF\b"..ui.get_style("Link
Active"):to_hex().."[tab] - \r misc")
end
end

local function time_to_ticks(val)

return [Link](0.5 + (val / [Link]))
end

local ram = {
prev_simulation_time = 0,
defensive = {},
jit_yaw = 0,
yaw_add = 0,
set_lby = false,
jitter = false,
jit_add = 0,
}

function sim_diff()
local current_simulation_time =
time_to_ticks(entity.get_local_player().m_flSimulationTime)
local diff = current_simulation_time - ram.prev_simulation_time
ram.prev_simulation_time = current_simulation_time
diff_sim = diff
return diff_sim
end

local ref = {
fake_options = [Link]("Aimbot", "Anti Aim", "Angles", "Body Yaw", "Options"),
autopeek = [Link]("Aimbot", "Ragebot", "Main", "Peek Assist"),
fd = [Link]("Aimbot", "Anti Aim", "Misc", "Fake Duck"),
sw = [Link]("Aimbot", "Anti Aim", "Misc", "Slow Walk"),
dormant = [Link]("Aimbot", "Ragebot", "Main", "Enabled", "Dormant Aimbot"),
pitch = [Link]("Aimbot", "Anti Aim", "Angles", "Pitch"),
yaw = [Link]("Aimbot", "Anti Aim", "Angles", "Yaw"),
base = [Link]("Aimbot", "Anti Aim", "Angles", "Yaw", "Base"),
offset = [Link]("Aimbot", "Anti Aim", "Angles", "Yaw", "Offset"),
yaw_mod = [Link]("Aimbot", "Anti Aim", "Angles", "Yaw Modifier"),
yaw_mod_degree = [Link]("Aimbot", "Anti Aim", "Angles", "Yaw Modifier",
"Offset"),
freestanding = [Link]("Aimbot", "Anti Aim", "Angles", "Freestanding"),
free_body = [Link]("Aimbot", "Anti Aim", "Angles", "Freestanding", "Body
Freestanding"),
yaw_mod_free = [Link]("Aimbot", "Anti Aim", "Angles", "Freestanding", "Disable
Yaw Modifiers"),
body_yaw = [Link]("Aimbot", "Anti Aim", "Angles", "Body Yaw"),
inverter = [Link]("Aimbot", "Anti Aim", "Angles", "Body Yaw", "Inverter"),
left_limit = [Link]("Aimbot", "Anti Aim", "Angles", "Body Yaw", "Left Limit"),
 right_limit = [Link]("Aimbot", "Anti Aim", "Angles", "Body Yaw", "Right
Limit"),
options = [Link]("Aimbot", "Anti Aim", "Angles", "Body Yaw", "Options"),
desync_freestand = [Link]("Aimbot", "Anti Aim", "Angles", "Body Yaw",
"Freestanding"),
dt = [Link]("Aimbot", "Ragebot", "Main", "Double Tap"),
aaos = [Link]("Aimbot", "Ragebot", "Main", "Hide Shots"),
hidden_cvars = [Link]("Miscellaneous", "Main", "Other", "Unlock Hidden
Cvars"),
air_strafe = [Link]("Miscellaneous", "Main", "Movement", "Air Strafe"),
scope_type = [Link]("Visuals", "World", "Main", "Override Zoom", "Scope
Overlay"),
legmovement = [Link]("Aimbot", "Anti Aim", "Misc", "Leg Movement"),
lag_options = [Link]("Aimbot", "Ragebot", "Main", "Double Tap", "Lag
Options"),
avoid_backstab = [Link]("Aimbot", "Anti Aim", "Angles", "Yaw", "Avoid
Backstab"),
ping_spike = [Link]("Miscellaneous", "Main", "Other", "Fake Latency"),
hidden = [Link]("Aimbot", "Anti Aim", "Angles", "Yaw", "Hidden"),
fl_limit = [Link]("Aimbot", "Anti Aim", "Fake Lag", "Limit"),
dtlim = [Link]("Aimbot", "Ragebot", "Main", "Double Tap", "Fake Lag Limit"),
}

local inverter = [Link]("Aimbot", "Anti Aim", "Angles", "Body Yaw", "Inverter")

local states = {
ground_timer = 0,
lag_timer = 0
}

function states:in_air(a)
if not a then return false end;

local b=a.m_fFlags

local c=[Link](b,1)~=0;

if c then
if self.ground_timer==5 then
return false
end;

self.ground_timer=self.ground_timer+1

else
self.ground_timer=0
end;

return true
end

function states:is_moving(ent)
local velocity = ent.m_vecVelocity
return [Link](velocity.x * velocity.x + velocity.y * velocity.y) > 2
end

function states:is_crouching(ent)
local ducked = ent.m_bDucked
return ducked
end

function states:team_number(ent)
local team_num = ent.m_iTeamNum
return team_num
end

function states:get_state(ent)
local is_moving = self:is_moving(ent)
local is_crouching = self:is_crouching(ent)
local in_air = self:in_air(ent)
local team_num = ent.m_iTeamNum

if [Link]:get() then
return "slowmotion"
end

if in_air then
if is_crouching then
return "air crouch"
end

return "air"
end

if is_crouching and is_moving and not in_air then

return "crouch moving"
end

if is_crouching and not in_air then

return "crouch"
end

if is_moving then
return "running"
end

if not is_moving then

return "standing"
end

return "none"
end

local hotkeys = {
manual_last_pressed = [Link]
}

local distance = function(x1,y1,z1,x2,y2,z2)

return [Link]((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))
end

local extrapolate = function(player, ticks, x,y,z)

local vel = player.m_vecVelocity
local new_x = x + [Link] * vel.x * ticks
local new_y = y + [Link] * vel.y * ticks
local new_z = z + [Link] * vel.z * ticks
return new_x, new_y, new_z
end
antibackstabnew = function()
local myself = entity.get_local_player()
local enemy = entity.get_threat(false)
if myself == nil or enemy == nil then return end
local weapon = enemy:get_player_weapon(false)
if myself ~= nil and weapon ~= nil and weapon:get_classname() == "CKnife" then
local e = enemy ~= nil and enemy:get_origin() or vector()
local l = myself:get_origin()
if e.x ~= nil and l.x ~= nil then
for ticks = 1,9 do
local tex, tey, tez = extrapolate(myself,ticks,l.x,l.y,l.z)
local distance = distance(e.x,e.y,e.z,tex,tey,tez)
if [Link](distance) < 230 then
return true
else
return false
end
end
end
end
end

local function antiaim(arg)

local lp = entity.get_local_player()
if not lp:is_alive() then return end

-- t side = 2 --- ct = 3

local state = states:get_state(lp)

[Link] = state

if state == "none" then return end

local builder = [Link].builder_elements[state]

if [Link]:get() == "left" then

hotkeys.manual_state = -90
[Link]:override("local view")
elseif [Link]:get() == "right" then
hotkeys.manual_state = 90
[Link]:override("local view")
elseif [Link]:get() == "forward" then
hotkeys.manual_state = 180
[Link]:override("local view")
elseif magnetSwitchHere:get() or magnetSwitch:get() then
[Link]:override("local view")
hotkeys.manual_state = 0
else
[Link]:override("at target")
hotkeys.manual_state = 0
end

--fast_ladder(arg)

local lp_bodyyaw = lp.m_flPoseParameter[11] * 120 - 60

 local yaw_left = builder.yaw_left:get()
local yaw_right = builder.yaw_right:get()

local jit_a = builder.yaw_jitter_ovr:get()

if builder.yaw_mode:get() == "static" then

if builder.yaw_randomize:get() > 0 then
yaw = [Link](builder.yaw_center:get(), builder.yaw_center:get() -
builder.yaw_randomize:get())
else
yaw = builder.yaw_center:get()
end
elseif builder.yaw_mode:get() == "l ~ r" then
if builder.yaw_randomize:get() > 0 then
if lp_bodyyaw <= 0 and globals.choked_commands ~= 0 then
yaw = [Link](yaw_right, yaw_right -
builder.yaw_randomize:get())
elseif lp_bodyyaw >= 0 and globals.choked_commands ~= 0 then
yaw = [Link](yaw_left, yaw_left - builder.yaw_randomize:get())
end
else
if lp_bodyyaw <= 0 and globals.choked_commands ~= 0 then
yaw = yaw_right
elseif lp_bodyyaw >= 0 and globals.choked_commands ~= 0 then
yaw = yaw_left
end
end
elseif builder.yaw_mode:get() == "3-way" then
if builder.yaw_center_speed:get() > 0 then
if([Link] % builder.yaw_center_speed:get() <
(builder.yaw_center_speed:get()/3)) then
if globals.choked_commands == 0 then
yaw = builder.yaw_center:get() / -2
end
elseif([Link] % builder.yaw_center_speed:get() <
(builder.yaw_center_speed:get()/2)) then
if globals.choked_commands == 0 then
yaw = 0
end
elseif([Link] % builder.yaw_center_speed:get() <
(builder.yaw_center_speed:get()/1)) then
if globals.choked_commands == 0 then
yaw = builder.yaw_center:get() / 2
end
end
else
if([Link] % 3 < (3/3)) then
yaw = builder.yaw_center:get() / -2
elseif([Link] % 3 < (3/2)) then
yaw = 0
elseif([Link] % 3 < (3/1)) then
yaw = builder.yaw_center:get() / 2
end
end
elseif builder.yaw_mode:get() == "5-way" then
if ([Link] % 3 == 4) then
yaw = builder.yaw_center:get() / -2
elseif([Link] % 3 == 3) then
yaw = builder.yaw_center:get() / -2.5
 elseif([Link] % 3 == 2) then
yaw = 0
elseif([Link] % 3 == 1) then
yaw = builder.yaw_center:get() / 2.5
elseif([Link] % 3 == 0) then
yaw = builder.yaw_center:get() / 2
end
elseif builder.yaw_mode:get() == "delay" then
local tick_speed = builder.aa_speed:get()

if builder.aa_speed_randomize:get() > 0 then

tick_speed = [Link](tick_speed, tick_speed -
builder.aa_speed_randomize:get())
else
tick_speed = builder.aa_speed:get()
end

if [Link]:get() < 1 then

if builder.yaw_randomize:get() > 0 then
if lp_bodyyaw <= 0 and globals.choked_commands ~= 0 then
yaw = [Link](yaw_right, yaw_right -
builder.yaw_randomize:get())
elseif lp_bodyyaw >= 0 and globals.choked_commands ~= 0 then
yaw = [Link](yaw_left, yaw_left -
builder.yaw_randomize:get())
end
else
if lp_bodyyaw <= 0 and globals.choked_commands ~= 0 then
yaw = yaw_right
elseif lp_bodyyaw >= 0 and globals.choked_commands ~= 0 then
yaw = yaw_left
end
end
elseif [Link] % tick_speed < (tick_speed/2) then
if builder.yaw_randomize:get() > 0 then
if globals.choked_commands == 0 then
yaw = [Link](yaw_left, yaw_left -
builder.yaw_randomize:get())
inverter:override(true)
end
else
if globals.choked_commands == 0 then
yaw = yaw_left
inverter:override(true)
end
end
else
if builder.yaw_randomize:get() > 0 then
if globals.choked_commands == 0 then
yaw = [Link](yaw_right, yaw_right -
builder.yaw_randomize:get())
inverter:override(false)
end
else
if globals.choked_commands == 0 then
yaw = yaw_right
inverter:override(false)
end
end
 end
end

local yaw2 = lp_bodyyaw <= 0 and 28 or -9

local yaw3 = lp_bodyyaw <= 0 and 9 or -9
local jitter = jit_a

local team_num = lp.m_iTeamNum

local is_fd = [Link]("Aimbot", "Anti Aim", "Misc", "Fake Duck")

if(sim_diff() < [Link]:get() / 100 * -1 and [Link]:get()) then

[Link]([Link], [Link])
end

local weapon = lp:get_player_weapon(false)

if weapon == nil then return end
local wpnclass = weapon:get_classname()

if [Link].select_text_df:get(1) and state == "standing" or

[Link].select_text_df:get(2) and state == "running" or
[Link].select_text_df:get(3) and state == "slowmotion" or
[Link].select_text_df:get(4) and state == "crouch" or
[Link].select_text_df:get(5) and state == "crouch moving" or
[Link].select_text_df:get(6) and state == "air" or
[Link].select_text_df:get(7) and state == "air crouch" then
[Link]:override("Always on")
else
[Link]:override("On peek")
end

local weapon = lp:get_player_weapon(false)

if weapon == nil then return end
local wpnclass = weapon:get_classname()

local tickbasee = lp.m_nTickBase

[Link]:set(false)

if magnetSwitch:get() or magnetSwitchHere:get() then

offsetHead()
elseif antibackstabnew() and [Link].anti_back:get() then
[Link]:override(180)
[Link]:set("down")
[Link]:override("at target")
[Link]:override("disabled")
aa.jitter_val:override(0)
aa.body_yaw[1]:override(false)
aa.body_yaw[3]:override(0)
aa.body_yaw[4]:override(0)
aa.body_yaw[5]:override("disabled")
aa.body_yaw[6]:override("Off")
elseif [Link].safe_head:get(1) and state == "air crouch" and
wpnclass:find("Knife") or [Link].safe_head:get(2) and state == "air crouch" then
[Link]:override(hotkeys.manual_state)
[Link]:set("Down")
[Link]:override("disabled")
aa.jitter_val:override(0)
 aa.body_yaw[1]:override(false)
aa.body_yaw[3]:override(0)
aa.body_yaw[4]:override(0)
aa.body_yaw[5]:override("disabled")
aa.body_yaw[6]:override("Off")
elseif [Link]:get() ~= "at target" then
[Link]:override(hotkeys.manual_state)
[Link]:override("local view")
[Link]:set("Down")
[Link]:override("disabled")
aa.jitter_val:override(0)
aa.body_yaw[1]:override(true)
aa.body_yaw[3]:override(58)
aa.body_yaw[4]:override(58)
aa.body_yaw[5]:override("disabled")
aa.body_yaw[6]:override("Off")
elseif(#[Link] > 0 and [Link] - [Link][#[Link]]
< 1 / 64 * (101 - [Link]:get()) / 10 and [Link]:get()) then
[Link]:override("at target")
local dtab = [Link]
if not ((dtab.yaw_mod:get() == "3-way" or dtab.yaw_mod:get() == "5-way") or
dtab.yaw_mod:get() == "hidden") then
[Link]:set(false)
if(dtab.yaw_mod:get() == "disabled") then
ram.jit_yaw = 0
elseif(dtab.yaw_mod:get() == "center") then
ram.jit_yaw = [Link] and dtab.modifier_degree:get() / -2 or
dtab.modifier_degree:get() / 2
elseif(dtab.yaw_mod:get() == "offset") then
ram.jit_yaw = [Link] and dtab.modifier_degree:get() or 0
elseif(dtab.yaw_mod:get() == "random") then
if(dtab.modifier_degree:get() >= 0) then
ram.jit_yaw = [Link](0,
[Link](dtab.modifier_degree:get())) - [Link](dtab.modifier_degree:get()) / 2
else
ram.jit_yaw = ([Link](0,
[Link](dtab.modifier_degree:get())) - [Link](dtab.modifier_degree:get()) / 2) *
-1
end
elseif(dtab.yaw_mod:get() == "spin") then
if(dtab.modifier_degree:get() >= 0) then
mult = 1
else
mult = -1
end
if(ram.jit_yaw < [Link](dtab.modifier_degree:get())) then
ram.jit_yaw = ram.jit_yaw + 3
else
ram.jit_yaw = [Link](dtab.modifier_degree:get()) * -1 / 2
end
elseif(dtab.yaw_mod:get() == "3-way") then
[Link]:set(false)
if([Link] % 3 == 2) then
ram.jit_yaw = dtab.modifier_degree:get() / -2
elseif([Link] % 3 == 1) then
ram.jit_yaw = dtab.modifier_degree:get() / 2 - 10
elseif([Link] % 3 == 0) then
ram.jit_yaw = dtab.modifier_degree:get() / 2
end
 elseif(dtab.yaw_mod:get() == "5-way") then
[Link]:set(false)
if([Link] % 5 == 4) then
ram.jit_yaw = dtab.modifier_degree:get() / -2
elseif([Link] % 5 == 3) then
ram.jit_yaw = dtab.modifier_degree:get() / -2.5
elseif([Link] % 5 == 2) then
ram.jit_yaw = dtab.modifier_degree:get() / 2.5
elseif([Link] % 5 == 1) then
ram.jit_yaw = dtab.modifier_degree:get() / 2 - 10
elseif([Link] % 5 == 0) then
ram.jit_yaw = dtab.modifier_degree:get() / 2
end
end
[Link]:override(ram.jit_yaw)
ref.yaw_mod:set("disabled")
ref.yaw_mod_degree:set(0)
else
ref.yaw_mod:set("disabled")
ref.yaw_mod_degree:set(0)
if(dtab.yaw_mod:get() == "hidden") then
[Link]:set(true)
end
end
[Link]:override(dtab.yaw_mod:get())
if([Link]:get() ~= "random") then
[Link]:set([Link]:get())
else
pitchs = {"disabled", "down", "fake up", "fake down"}
[Link]:set(pitchs[[Link](1, 4)])
end
else
[Link]:override("at target")
--fakelag
[Link]:set("down")
[Link]:override(yaw)
if [Link]:get() == "3-way" then
if builder.jitter_speed:get() > 0 then
[Link]:override("center")
if([Link] % builder.jitter_speed:get() <
(builder.jitter_speed:get()/3)) then
aa.jitter_val:override(builder.yaw_jitter_ovr:get() / -2)
elseif([Link] % builder.jitter_speed:get() <
(builder.jitter_speed:get()/2)) then
aa.jitter_val:override(0)
elseif([Link] % builder.jitter_speed:get() <
(builder.jitter_speed:get()/1)) then
aa.jitter_val:override(builder.yaw_jitter_ovr:get() / 2)
end
else
[Link]:override("3-way")
aa.jitter_val:override(builder.yaw_jitter_ovr:get())
end
elseif [Link]:get() == "5-way" then
if builder.jitter_speed:get() > 0 then
[Link]:override("center")
if([Link] % builder.jitter_speed:get() <
(builder.jitter_speed:get()/5)) then
aa.jitter_val:override(builder.yaw_jitter_ovr:get() / -2)
 elseif([Link] % builder.jitter_speed:get() <
(builder.jitter_speed:get()/4)) then
aa.jitter_val:override(builder.yaw_jitter_ovr:get() / -2.5)
elseif([Link] % builder.jitter_speed:get() <
(builder.jitter_speed:get()/3)) then
aa.jitter_val:override(0)
elseif([Link] % builder.jitter_speed:get() <
(builder.jitter_speed:get()/2)) then
aa.jitter_val:override(builder.yaw_jitter_ovr:get() / 2.5)
elseif([Link] % builder.jitter_speed:get() <
(builder.jitter_speed:get()/1)) then
aa.jitter_val:override(builder.yaw_jitter_ovr:get() / 2)
end
else
[Link]:override("5-way")
aa.jitter_val:override(builder.yaw_jitter_ovr:get())
end
else
[Link]:override([Link]:get())
aa.jitter_val:override(builder.yaw_jitter_ovr:get())
end

aa.body_yaw[1]:override(builder.body_yaw:get())
if builder.limit_random:get() then
aa.body_yaw[3]:override([Link](48,58))
aa.body_yaw[4]:override([Link](48,58))
else
aa.body_yaw[3]:override(builder.fake_left:get())
aa.body_yaw[4]:override(builder.fake_right:get())
end
if builder.yaw_mode:get() == "delay" then
if [Link]:get() < 1 then
aa.body_yaw[5]:override("jitter")
else
aa.body_yaw[5]:override(" ")
end
else
aa.body_yaw[5]:override(builder.fake_options:get())
end
aa.body_yaw[6]:override("off")
end
end

local vel_font = render.load_font("Verdana", 15, "d")

local v_data = {
alpha = 0,
y = 0,
y2 = 0,
}

draw_watermark = function()

local lp = entity.get_local_player()

if not lp or not lp:is_alive() then return end

local x, y = render.screen_size().x/2, render.screen_size().y/2

 [Link](watermark_icon, vector(x, y - y), vector(x, y),
color(255,255,255, 255), "f", 0)
end

draw_velocity_warning = function()

local lp = entity.get_local_player()

if not lp or not lp:is_alive() then return end

if not [Link].vel_inds:get() then return end

local modifier = entity.get_local_player().m_flVelocityModifier

if modifier == 1 then
speed_mod = false
else
speed_mod = true
end

local x, y = render.screen_size().x/2, render.screen_size().y/2

if speed_mod then
v_data.alpha = [Link](v_data.alpha, 255, [Link] * 12)
v_data.y = [Link](v_data.y, 20, [Link] * 12)
v_data.y2 = [Link](v_data.y2, 0, [Link] * 12)

[Link](vel_warning, vector(x - x/2, y - y/2 - 220 + v_data.y),

vector(x, y), color(255,255,255, v_data.alpha), "f", 0)
[Link](4, vector(x + 25, y - y/2 - 100 + v_data.y),
color(255,255,255,v_data.alpha), "c+", "velocity is "..[Link](modifier*100).."%
slower")
else
v_data.alpha = [Link](v_data.alpha, 0, [Link] * 12)
v_data.y = [Link](v_data.y, 0, [Link] * 12)
v_data.y2 = [Link](v_data.y2, 20, [Link] * 12)

[Link](vel_warning, vector(x - x/2, y - y/2 - 220 + v_data.y),

vector(x, y), color(255,255,255, v_data.alpha), "f", 0)
[Link](4, vector(x + 25, y - y/2 - 100 + v_data.y),
color(255,255,255,v_data.alpha), "c+", "velocity is "..[Link](modifier*100).."%
slower")
end
end

[Link]:set(antiaim)

local f, rep = [Link], [Link];

local logger = {};

[Link] = 0;

[Link] = {
[ 0 ] = 'generic',
'head',
'chest',
'stomach',
'left arm',
 'right arm',
'left leg',
'right leg',
'neck',
'?',
'gear'
};

[Link] = {
[ 'correction' ] = 'resolver',
[ 'player death' ] = 'enemy death',
[ 'backtrack failure' ] = 'lagcomp failure'
};

[Link] = {
[ 'knife' ] = 'Knifed',
[ 'inferno' ] = 'Burned',
[ 'hegrenade' ] = 'Naded'
};

logger.bell_pattern = f('\\a%s', rep('%%X', 6));

logger.remove_bell = function(s)
return s:gsub(logger.bell_pattern, '')
end

logger.get_id = function()
return [Link] % (1000 + 1)
end

[Link] = function(e)
local state = [Link][ [Link] ] or [Link];

print_dev(f(
'\ac95b5b[-] Missed shot at %s in the %s due to %s [hitchance: %d%% |
backtrack: %d ticks]',
[Link]:get_name(), [Link][ e.wanted_hitgroup ] or '?', state,
[Link], [Link]
));

print_raw(f(
'\ac95b5b[-] Missed shot at %s in the %s due to %s [hitchance: %d%% |
backtrack: %d ticks]',
[Link]:get_name(), [Link][ e.wanted_hitgroup ] or '?', state,
[Link], [Link]
));
end

[Link] = function(e)
print_dev(f(
'\a97B331[+] Hit %s\'s in the %s for %d(%d) (%d remaining), bt = %d, aimed
= %s(%d%%)',
[Link]:get_name(), [Link][ [Link] ] or '?', [Link],
e.wanted_damage, [Link].m_iHealth, [Link],
[Link][ e.wanted_hitgroup ] or '?', [Link]
));

print_raw(f(
'\a97B331[+] Hit %s\'s in the %s for %d(%d) (%d remaining), bt = %d, aimed
= %s(%d%%)',
[Link]:get_name(), [Link][ [Link] ] or '?', [Link],
e.wanted_damage, [Link].m_iHealth, [Link],
[Link][ e.wanted_hitgroup ] or '?', [Link]
));
end

logger.player_hurt = function(e)
local lp = entity.get_local_player();
local userid = [Link]([Link], true);
local attacker = [Link]([Link], true);

if attacker ~= lp or userid == lp then

return
end

local verb = [Link][ [Link] ];

if verb == nil then

return
end

print_dev(f(
'\a97B331%s %s for %d damage (%d health remaining)',
verb, userid:get_name(), e.dmg_health, [Link]
));

print_raw(f(
'\a97B331 %s %s for %d damage (%d health remaining)',
verb, userid:get_name(), e.dmg_health, [Link]
));
end

events.player_connect_full:set(function(e)
local lp = entity.get_local_player();
local userid = [Link]([Link], true);

if lp ~= userid then
return
end

[Link] = -1;
end)

events.aim_fire:set(function(e)
[Link] = [Link] + 1;
end)

events.aim_ack:set(function(e)
if not [Link].aim_logs:get() then return end

([Link] and [Link] or [Link])(e)

end)

events.player_hurt:set(
logger.player_hurt
)

[Link]:set(function(ctx)
 --set_check_tabs()
draw_velocity_warning()
draw_watermark()
if [Link].amnesia_tabs:get() == 2 then
[Link].gs_inds:visibility(true)
else
[Link].gs_inds:visibility(false)
end
[Link]()
[Link]()
indicator_list:visibility([Link].gs_inds:get())
skeet_spects:visibility([Link].gs_inds:get())
scope_overlay_handle()
if [Link].crosshair_ind:get() then
crosshair_inds()
end
nade_circle_draw()
menu_visibility_handler()
handle_aspect()
end)

events.bomb_defused:set(function(e)
c4.reset_bomb()
end)
events.bomb_planted:set(function(e)
c4.reset_bomb()
end)
events.bomb_abortplant:set(function(e)
c4.reset_bomb()
end)
events.round_prestart:set(function(e)
c4.reset_bomb()
end)
events.bomb_beginplant:set(function(e)
c4.bomb_beginplant(e)
end)

[Link](function()
--unsetRefs()
target_pos = vector(0,0,0)
end)

events.round_start:set(function(e)
magnetSwitch:set(false)
magnetSwitchHere:set(false)
end)

events.round_end:set(function(e)
magnetSwitch:set(false)
magnetSwitchHere:set(false)
end)

clantag:run()

[Link](menu)