local bit = require("bit")

local ffi = require("ffi")

local clipboard = require("neverlose/clipboard")
local base64 = require("neverlose/base64")
local aantiaim = require("neverlose/anti_aim")
local color_p = require("neverlose/color_print")
local texts = render.measure_text
local beta = 'Debug' -- 'Debug' or 'Beta' or 'Live'
local username = common.get_username() -- getting cheat username pls elleqt allow
me
local callbacks = {}
local func = {}
local tbl = {}
local str = 'Cyrax.Tech'
local yawbases = {
Forward = 180,
Left = -90,
Right = 90,
Backward = 0,
}
ffi.cdef[[

typedef struct
{
float x;
float y;
float z;
} Vector_t;

int VirtualProtect(void* lpAddress, unsigned long dwSize, unsigned long

flNewProtect, unsigned long* lpflOldProtect);
void* VirtualAlloc(void* lpAddress, unsigned long dwSize, unsigned long
flAllocationType, unsigned long flProtect);
int VirtualFree(void* lpAddress, unsigned long dwSize, unsigned long
dwFreeType);
typedef uintptr_t (__thiscall* GetClientEntity_4242425_t)(void*, int);

typedef struct
{
char pad0[0x60]; // 0x00
void* pEntity; // 0x60
void* pActiveWeapon; // 0x64
void* pLastActiveWeapon; // 0x68
float flLastUpdateTime; // 0x6C
int iLastUpdateFrame; // 0x70
float flLastUpdateIncrement; // 0x74
float flEyeYaw; // 0x78
float flEyePitch; // 0x7C
float flGoalFeetYaw; // 0x80
float flLastFeetYaw; // 0x84
float flMoveYaw; // 0x88
float flLastMoveYaw; // 0x8C // changes when moving/jumping/hitting
ground
float flLeanAmount; // 0x90
char pad1[0x4]; // 0x94
float flFeetCycle; // 0x98 0 to 1
float flMoveWeight; // 0x9C 0 to 1
float flMoveWeightSmoothed; // 0xA0
float flDuckAmount; // 0xA4
 float flHitGroundCycle; // 0xA8
float flRecrouchWeight; // 0xAC
Vector_t vecOrigin; // 0xB0
Vector_t vecLastOrigin;// 0xBC
Vector_t vecVelocity; // 0xC8
Vector_t vecVelocityNormalized; // 0xD4
Vector_t vecVelocityNormalizedNonZero; // 0xE0
float flVelocityLenght2D; // 0xEC
float flJumpFallVelocity; // 0xF0
float flSpeedNormalized; // 0xF4 // clamped velocity from 0 to 1
float flRunningSpeed; // 0xF8
float flDuckingSpeed; // 0xFC
float flDurationMoving; // 0x100
float flDurationStill; // 0x104
bool bOnGround; // 0x108
bool bHitGroundAnimation; // 0x109
char pad2[0x2]; // 0x10A
float flNextLowerBodyYawUpdateTime; // 0x10C
float flDurationInAir; // 0x110
float flLeftGroundHeight; // 0x114
float flHitGroundWeight; // 0x118 // from 0 to 1, is 1 when standing
float flWalkToRunTransition; // 0x11C // from 0 to 1, doesnt change
when walking or crouching, only running
char pad3[0x4]; // 0x120
float flAffectedFraction; // 0x124 // affected while jumping and
running, or when just jumping, 0 to 1
char pad4[0x208]; // 0x128
float flMinBodyYaw; // 0x330
float flMaxBodyYaw; // 0x334
float flMinPitch; //0x338
float flMaxPitch; // 0x33C
int iAnimsetVersion; // 0x340
} CCSGOPlayerAnimationState_534535_t;

]]
local log = {}
local cyraxUI = {}
local conditional_aa = {}
conditional_aa.pitch = ui.find("Aimbot", "Anti Aim", "Angles", "Pitch")
conditional_aa.yawbase = ui.find("Aimbot", "Anti Aim", "Angles", "Yaw")
conditional_aa.yawadd = ui.find("Aimbot", "Anti Aim", "Angles", "Yaw", "Offset")
conditional_aa.yawmodifier = ui.find("Aimbot", "Anti Aim", "Angles", "Yaw
Modifier")
conditional_aa.modifierdegree = ui.find("Aimbot", "Anti Aim", "Angles", "Yaw
Modifier", "Offset")
conditional_aa.fakelimitleft = ui.find("Aimbot", "Anti Aim", "Angles", "Body Yaw",
"Left Limit")
conditional_aa.fakelimitright = ui.find("Aimbot", "Anti Aim", "Angles", "Body Yaw",
"Right Limit")
conditional_aa.fakeoptions = ui.find("Aimbot", "Anti Aim", "Angles", "Body Yaw",
"Options")
conditional_aa.lbymode = ui.find("Aimbot", "Anti Aim", "Angles", "Body Yaw", "LBY
Mode")
conditional_aa.freestandingdesync = ui.find("Aimbot", "Anti Aim", "Angles", "Body
Yaw", "Freestanding")
conditional_aa.desynconshot = ui.find("Aimbot", "Anti Aim", "Angles", "Body Yaw",
"On Shot")
conditional_aa.slow_walk = ui.find("Aimbot", "Anti Aim", "Misc", "Slow Walk")
conditional_aa.legmovement = ui.find("Aimbot", "Anti Aim", "Misc", "Leg Movement")
conditional_aa.freestanding = ui.find("Aimbot", "Anti Aim", "Angles",
"Freestanding")
conditional_aa.freestanding_setts = ui.find("Aimbot", "Anti Aim", "Angles",
"Freestanding", "Disable Yaw Modifiers")

local urlmon = ffi.load 'UrlMon'

local wininet = ffi.load 'WinInet'

function func:lerp(a, b, t)
return a + (b - a) * t
end
local solus_lerp = function(time,a,b)
return a * (1-time) + b * time
end

panorama.loadstring([[
return {
asdstringify: JSON.stringify,
asdparse: JSON.parse
};
]], "CSGOMainMenu")()

ffi.cdef[[
void* __stdcall URLDownloadToFileA(void* LPUNKNOWN, const char* LPCSTR, const
char* LPCSTR2, int a, int LPBINDSTATUSCALLBACK);

bool DeleteUrlCacheEntryA(const char* lpszUrlName);

]]

function func:contains(list, x)
for _, v in pairs(list) do
if v == x then return true end
end
return false
end
function func:get_neverlose_path()
return common.get_game_directory():sub(1, -5) .. "nl\\"
end
files.create_folder(common.get_game_directory().."\\sound\\cyrax\\")
function func:Download(from, to)
wininet.DeleteUrlCacheEntryA(from)
urlmon.URLDownloadToFileA(nil, from, to, 0,0)
end
function func:file_exists(file, path_id)
local func_file_exists = ffi.cast("bool (__thiscall*)(void*, const char*, const
char*)", ffi.cast(ffi.typeof("void***"),
utils.create_interface("filesystem_stdio.dll", "VBaseFileSystem011"))[0][10])
return func_file_exists(ffi.cast(ffi.typeof("void***"),
utils.create_interface("filesystem_stdio.dll", "VBaseFileSystem011")), file,
path_id)
end

if not func:file_exists(func:get_neverlose_path().."Cyrax\\skeet.tff", "GAME") then

func:Download('https://github.com/fakeangle/neverlose_bettervisuals/blob/
main/Small_Fonts.ttf?raw=true', func:get_neverlose_path().."Cyrax\\skeet.tff")
end

if not func:file_exists(func:get_neverlose_path().."Cyrax\\smallest.tff", "GAME")

then
 func:Download('https://github.com/fakeangle/neverlose_bettervisuals/blob/
main/smallest_pixel-7.ttf?raw=true', func:get_neverlose_path().."Cyrax\\
smallest.tff")
end

if not func:file_exists(func:get_neverlose_path().."Cyrax\\code_bold.tff", "GAME")

then
func:Download('https://github.com/lordcristi/whatisthis/blob/main/CODE
%20Bold.ttf?raw=true', func:get_neverlose_path().."Cyrax\\code_bold.tff")
end

if not func:file_exists(func:get_neverlose_path().."Cyrax\\cyrax1.gif", "GAME")

then
func:Download('https://raw.githubusercontent.com/lordcristi/whatisthis/main/
21.gif', func:get_neverlose_path().."Cyrax\\cyrax1.gif")
end

if not func:file_exists(func:get_neverlose_path().."Cyrax\\funny_dog.png", "GAME")

then
func:Download('https://raw.githubusercontent.com/lordcristi/whatisthis/main/
shaved_cat.png', func:get_neverlose_path().."Cyrax\\funny_dog.png")
end

files.create_folder(func:get_neverlose_path().."Cyrax\\")

local vars = {
font = {
pixel = render.load_font(func:get_neverlose_path().."Cyrax\\
smallest.tff", 10, 'o'),
verdana = render.load_font("Verdana", 11),
verdana_r = render.load_font("Verdana", 11, 'a'),
calibri = render.load_font("Calibri", 16, 'b'),
calibri_dog = render.load_font(func:get_neverlose_path().."Cyrax\\
code_bold.tff", 35),
calibri_dog2 = render.load_font(func:get_neverlose_path().."Cyrax\\
code_bold.tff", 10),
skeet = render.load_font(func:get_neverlose_path().."Cyrax\\skeet.tff",
11, 'o')},
menu = {
thirdperson = ui.find("Visuals", "World", "Main", "Force Thirdperson"),
dt = ui.find("Aimbot", "Ragebot", "Main", "Double Tap"),
hs = ui.find("Aimbot", "Ragebot", "Main", "Hide Shots"),
fd = ui.find("Aimbot", "Anti Aim", "Misc", "Fake Duck"),
fs = ui.find("Aimbot", "Anti Aim", "Angles", "Freestanding"),
remove_scope = ui.find("Visuals", "World", "Main", "Override Zoom",
"Scope Overlay"),
qp = ui.find("Aimbot", "Ragebot", "Main", "Peek Assist"),
sw = ui.find("Aimbot", "Anti Aim", "Misc", "Slow Walk"),
fl = ui.find("Aimbot", "Anti Aim", "Fake Lag", "Enabled"),
body = ui.find("Aimbot", "Ragebot", "Safety", "Body Aim"),
sp = ui.find("Aimbot", "Ragebot", "Safety", "Safe Points")
},
da = {
[1] = true,
[2] = true,
[3] = true,
[4] = true
},
sus = {
 [1] = 40,
[2] = 31,
[3] = 9,
[4] = 1
},
ind = {
fs_alpha = 0,
dt_alpha = 0,
dmg_alpha = 0,
dt_bar_alpha = 0,
hs_pos = 0,
dmg_pos = 0,
dmg_val = 0,
smooth = 0,
scope_smooth = 2,
legacy_check = false,
v2 = {
a = {
[1] = {
0,
0,
0,
},
[2] = 0,
[3] = 0,
[4] = 0,
},
p = {
[1] = 40,
[2] = 40,
[3] = 40,
},
cond_text = "amingus"
},
lavendu = {
textu = "",
anim = {
[1] = {
dt = 0,
fs = 0,
},
[2] = {
dt = 0,
fs = 0,
},
[3] = {
[1] = 0,
[2] = 0,
[3] = 0,
},
},
chestie = 0,
},
},
mark = {

},
pi_divided = math.pi / 180,
}
function func:version()
return beta
end

local function IsPlayer(player)

if not player then return false end
if not player:is_bot() then return true end
end

function func:CanSee(self, entity)

if not entity then return false end
if IsPlayer(entity) then return false end

local hitboxes = {0, 5, 7, 8, 11, 12, 13, 14, 15, 17}

for i, hitbox in pairs(hitboxes) do

local trace = utils.trace_line(self:get_eye_position(),
entity:get_hitbox_position(hitbox), self, 0x4600400B)
if trace.hit_entity then
return IsPlayer(trace.hit_entity)
end
end
return false
end
color_p("cyrax - ", color(255,255,255,255))
color_p("information \n", color(222, 194, 153, 255))
color_p("version - ", color(255,255,255,255))
color_p(string.lower(func:version().."\n"), color(222, 194, 153, 255))
color_p("username - ", color(255,255,255,255))
color_p(username.."\n", color(222, 194, 153, 255))
color_p("discord server - ", color(255,255,255,255))
color_p("https://discord.gg/R5VrugTNbg\n", color(222, 194, 153, 255))

local group = {
info = {
gif = ui.create("\afbfbfbffI\afbf7f5ffn\afcf3eefff\afcf0e8ffo\
afdece1ffr\afde8dbffm\afde4d5ffa\afee0cefft\afeddc8ffi\affd9c1ffo\affd5bbffn", ""),
info = ui.create("\afbfbfbffI\afbf7f5ffn\afcf3eefff\afcf0e8ffo\
afdece1ffr\afde8dbffm\afde4d5ffa\afee0cefft\afeddc8ffi\affd9c1ffo\affd5bbffn", "\
aFFD5BBFFInformation"),
cfg = ui.create("\afbfbfbffI\afbf7f5ffn\afcf3eefff\afcf0e8ffo\
afdece1ffr\afde8dbffm\afde4d5ffa\afee0cefft\afeddc8ffi\affd9c1ffo\affd5bbffn", "\
aFFD5BBFFConfigs"),
misc = ui.create("\afbfbfbffI\afbf7f5ffn\afcf3eefff\afcf0e8ffo\
afdece1ffr\afde8dbffm\afde4d5ffa\afee0cefft\afeddc8ffi\affd9c1ffo\affd5bbffn", "\
aFFD5BBFFMisc"),
},
aa = {
aa = ui.create("\aFFD5BBFFAnti-Aim", "Anti-Aim"),
conditions = {
standing = ui.create("\aFFD5BBFFAnti-Aim", "\aFFD5BBFFStanding"),
crouching = ui.create("\aFFD5BBFFAnti-Aim", "\
aFFD5BBFFCrouching"),
slowwalk = ui.create("\aFFD5BBFFAnti-Aim", "\aFFD5BBFFSlowwalk"),
moving = ui.create("\aFFD5BBFFAnti-Aim", "\aFFD5BBFFMoving"),
in_air = ui.create("\aFFD5BBFFAnti-Aim", "\aFFD5BBFFIn Air"),
in_air_d = ui.create("\aFFD5BBFFAnti-Aim", "\aFFD5BBFFIn Air +
Duck"),
 },
},
settings = {
visuals = ui.create("\affd5bbffS\affdbc5ffe\affe1cefft\affe7d8fft\
affede2ffi\afff3ecffn\afff9f5ffg\affffffffs", "Visuals"),
misc = ui.create("\affd5bbffS\affdbc5ffe\affe1cefft\affe7d8fft\
affede2ffi\afff3ecffn\afff9f5ffg\affffffffs", "Miscellaneous"),
},
}
print_dev("Cyrax - Welcome, "..username..".")
-- INFORMATION
local gif = render.load_image_from_file(func:get_neverlose_path().."Cyrax\\
cyrax1.gif", vector(540, 540))
local dog = render.load_image_from_file(func:get_neverlose_path().."Cyrax\\
funny_dog.png", vector(828, 828))
group.info.gif:texture(gif,vector(270, 270), color(255, 255, 255), 'f')
group.info.info:label("User: \aFFD5BBFF"..username)
group.info.info:label("Build: \aFFD5BBFF"..func:version())
group.info.info:label("If you have any issues open a ticket in the discord server
or message \aFFD5BBFFcomezo#2441")
group.info.cfg:button("Discord Link", function()
panorama.SteamOverlayAPI.OpenExternalBrowserURL("https://discord.gg/R5VrugTNbg")
end, true)
group.info.cfg:button("Neverlose Config", function()
panorama.SteamOverlayAPI.OpenExternalBrowserURL("https://en.neverlose.cc/market/
item?id=yXbDoa") end, true)
local anim_switch = group.info.misc:switch("Loading Animation", true)
local funny_dog = group.info.misc:switch("Funny Dog", true)
local smooth = {0, 0, 0}
function func:funnydog()
local screen = render.screen_size()

if funny_dog:get() then
smooth[1] = func:lerp(smooth[1], 150, globals.frametime * 5)
smooth[3] = func:lerp(smooth[3], ui.get_position().y - 125,
globals.frametime * 5)
else
smooth[1] = func:lerp(smooth[1], 0, globals.frametime * 5)
smooth[3] = func:lerp(smooth[3], screen.y, globals.frametime * 5)
end
smooth[2] = func:lerp(smooth[2], ui.get_position().x - 20, globals.frametime
* 5)

render.texture(dog, vector(smooth[2], smooth[3]), vector(smooth[1],

smooth[1]), color(255, 255, 255, smooth[1]*1.7), 'f')

end
local menu_cyrax = {
visuals_switch = {
_ = group.settings.visuals:switch("\aFFD5BBFFEnable Visual Options",
false),
name = "visuals_switch",
element = "switch"
},
indicators_switch = {
_ = group.settings.visuals:switch("Indicators", false),
name = "indicators_switch",
element = "switch"
},
 watermark_switch = {
_ = group.settings.visuals:switch("Watermark", false),
name = "watermark_switch",
element = "switch"
},
scope_switch = {
_ = group.settings.visuals:switch("Custom Scope", false),
name = "scope_switch",
element = "switch"
},
logs_switch = {
_ = group.settings.visuals:switch("Aimbot Logging", false),
name = "logs_switch",
element = "switch"
},
solus_switch = {
_ = group.settings.visuals:switch("Widgets", false),
name = "solus_switch",
element = "switch"
},
misc_switch = {
_ = group.settings.misc:switch("\aFFD5BBFFEnable Miscellaneous
Options", false),
name = "misc_switch",
element = "switch"
},
jumpscout_switch = {
_ = group.settings.misc:switch("Jumpscout Fix", false),
name = "jumpscout_switch",
element = "switch"
},
killsay_switch = {
_ = group.settings.misc:switch("Killsay", false),
name = "killsay_switch",
element = "switch"
},
animbreaker_switch = {
_ = group.settings.misc:switch("Anim. Breaker", false),
name = "animbreaker_switch",
element = "switch"
}
}
local data = {

YawBase_Standing = {"Forward", "Backward", "Right", "Left", "At Target"},

YawBase_Crouching = {"Forward", "Backward", "Right", "Left", "At Target"},
YawBase_Slowwalk = {"Forward", "Backward", "Right", "Left", "At Target"},
YawBase_Moving = {"Forward", "Backward", "Right", "Left", "At Target"},
YawBase_InAir = {"Forward", "Backward", "Right", "Left", "At Target"},
YawBase_InAirDuck = {"Forward", "Backward", "Right", "Left", "At Target"},

Pitch_Standing = {"Disabled", "Down", "Fake Down", "Fake Up"},

Pitch_Crouching = {"Disabled", "Down", "Fake Down", "Fake Up"},
Pitch_Slowwalk = {"Disabled", "Down", "Fake Down", "Fake Up"},
Pitch_Moving = {"Disabled", "Down", "Fake Down", "Fake Up"},
Pitch_InAir = {"Disabled", "Down", "Fake Down", "Fake Up"},
Pitch_InAirDuck = {"Disabled", "Down", "Fake Down", "Fake Up"},

YawModifier_Standing = {"Disabled", "Center", "Offset", "Random", "Spin"},

 YawModifier_Crouching = {"Disabled", "Center", "Offset", "Random", "Spin"},
YawModifier_Slowwalk = {"Disabled", "Center", "Offset", "Random", "Spin"},
YawModifier_Moving = {"Disabled", "Center", "Offset", "Random", "Spin"},
YawModifier_InAir = {"Disabled", "Center", "Offset", "Random", "Spin"},
YawModifier_InAirDuck = {"Disabled", "Center", "Offset", "Random", "Spin"},

YawModifierType_Standing = {"Default", "Random"},

YawModifierType_Crouching = {"Default", "Random"},
YawModifierType_Slowwalk = {"Default", "Random"},
YawModifierType_Moving = {"Default", "Random"},
YawModifierType_InAir = {"Default", "Random"},
YawModifierType_InAirDuck = {"Default", "Random"},

FakeLimitType_Standing = {"Static", "Jitter", "Random Jitter"},

FakeLimitType_Crouching = {"Static", "Jitter", "Random Jitter"},
FakeLimitType_Slowwalk = {"Static", "Jitter", "Random Jitter"},
FakeLimitType_Moving = {"Static", "Jitter", "Random Jitter"},
FakeLimitType_InAir = {"Static", "Jitter", "Random Jitter"},
FakeLimitType_InAirDuck = {"Static", "Jitter", "Random Jitter"},

FakeOptions_Standing = {"Avoid Overlap", "Jitter", "Randomize Jitter", "Anti

Bruteforce"},
FakeOptions_Crouching = {"Avoid Overlap", "Jitter", "Randomize Jitter", "Anti
Bruteforce"},
FakeOptions_Slowwalk = {"Avoid Overlap", "Jitter", "Randomize Jitter", "Anti
Bruteforce"},
FakeOptions_Moving = {"Avoid Overlap", "Jitter", "Randomize Jitter", "Anti
Bruteforce"},
FakeOptions_InAir = {"Avoid Overlap", "Jitter", "Randomize Jitter", "Anti
Bruteforce"},
FakeOptions_InAirDuck = {"Avoid Overlap", "Jitter", "Randomize Jitter", "Anti
Bruteforce"},

LBYMode_Standing = {"Disabled", "Opposite", "Sway"},

LBYMode_Crouching = {"Disabled", "Opposite", "Sway"},
LBYMode_Slowwalk = {"Disabled", "Opposite", "Sway"},
LBYMode_Moving = {"Disabled", "Opposite", "Sway"},
LBYMode_InAir = {"Disabled", "Opposite", "Sway"},
LBYMode_InAirDuck = {"Disabled", "Opposite", "Sway"},

FreestandingDesync_Standing = {"Off", "Peek Fake", "Peek Real"},

FreestandingDesync_Crouching = {"Off", "Peek Fake", "Peek Real"},
FreestandingDesync_Slowwalk = {"Off", "Peek Fake", "Peek Real"},
FreestandingDesync_Moving = {"Off", "Peek Fake", "Peek Real"},
FreestandingDesync_InAir = {"Off", "Peek Fake", "Peek Real"},
FreestandingDesync_InAirDuck = {"Off", "Peek Fake", "Peek Real"},

DesyncOnShot_Standing = {"Disabled", "Opposite", "Freestanding", "Switch"},

DesyncOnShot_Crouching = {"Disabled", "Opposite", "Freestanding", "Switch"},
DesyncOnShot_Slowwalk = {"Disabled", "Opposite", "Freestanding", "Switch"},
DesyncOnShot_Moving = {"Disabled", "Opposite", "Freestanding", "Switch"},
DesyncOnShot_InAir = {"Disabled", "Opposite", "Freestanding", "Switch"},
DesyncOnShot_InAirDuck = {"Disabled", "Opposite", "Freestanding", "Switch"},

indicators_styles = {"Cyrax", "Cyrax V2", "Cyrax V3", "Cyrax V4"},

sparg = {"Static Legs In Air", "Leg Breaker"},

}
local menu_aa = {

Switch_AntiAim = {
_ = group.aa.aa:switch("\aFFD5BBFFEnable Custom Anti Aim", false),
name = "Switch_AntiAim",
element = "switch"
},

--YAW BASE

YawBase_Standing = {
_ = group.aa.conditions.standing:combo("Yaw Base",
data.YawBase_Standing, 0),
name = "YawBase_Standing",
element = "combo"
},
YawBase_Crouching = {
_ = group.aa.conditions.crouching:combo("Yaw Base",
data.YawBase_Crouching, 0),
name = "YawBase_Crouching",
element = "combo"
},
YawBase_Slowwalk = {
_ = group.aa.conditions.slowwalk:combo("Yaw Base",
data.YawBase_Slowwalk, 0),
name = "YawBase_Slowwalk",
element = "combo"
},
YawBase_Moving = {
_ = group.aa.conditions.moving:combo("Yaw Base", data.YawBase_Moving,
0),
name = "YawBase_Moving",
element = "combo"
},
YawBase_InAir = {
_ = group.aa.conditions.in_air:combo("Yaw Base", data.YawBase_InAir,
0),
name = "YawBase_InAirDuck",
element = "combo"
},
YawBase_InAirDuck = {
_ = group.aa.conditions.in_air_d:combo("Yaw Base",
data.YawBase_InAirDuck, 0),
name = "YawBase_InAirDuck",
element = "combo"
},

--YAW ADD LEFT

YawAddLeft_Standing = {
_ = group.aa.conditions.standing:slider("Yaw Add Left", -180, 180, 0),
name = "YawAddLeft_Standing",
element = "slider"
},
YawAddLeft_Crouching = {
_ = group.aa.conditions.crouching:slider("Yaw Add Left", -180, 180, 0),
name = "YawAddLeft_Crouching",
element = "slider"
},
 YawAddLeft_Slowwalk = {
_ = group.aa.conditions.slowwalk:slider("Yaw Add Left", -180, 180, 0),
name = "YawAddLeft_Slowwalk",
element = "slider"
},
YawAddLeft_Moving = {
_ = group.aa.conditions.moving:slider("Yaw Add Left", -180, 180, 0),
name = "YawAddLeft_Moving",
element = "slider"
},
YawAddLeft_InAir = {
_ = group.aa.conditions.in_air:slider("Yaw Add Left", -180, 180, 0),
name = "YawAddLeft_InAir",
element = "slider"
},
YawAddLeft_InAirDuck = {
_ = group.aa.conditions.in_air_d:slider("Yaw Add Left", -180, 180, 0),
name = "YawAddLeft_InAirDuck",
element = "slider"
},

--YAW ADD RIGHT

YawAddRight_Standing = {
_ = group.aa.conditions.standing:slider("Yaw Add Right", -180, 180, 0),
name = "YawAddRight_Standing",
element = "slider"
},
YawAddRight_Crouching = {
_ = group.aa.conditions.crouching:slider("Yaw Add Right", -180, 180,
0),
name = "YawAddRight_Crouching",
element = "slider"
},
YawAddRight_Slowwalk = {
_ = group.aa.conditions.slowwalk:slider("Yaw Add Right", -180, 180, 0),
name = "YawAddRight_Slowwalk",
element = "slider"
},
YawAddRight_Moving = {
_ = group.aa.conditions.moving:slider("Yaw Add Right", -180, 180, 0),
name = "YawAddRight_Moving",
element = "slider"
},
YawAddRight_InAir = {
_ = group.aa.conditions.in_air:slider("Yaw Add Right", -180, 180, 0),
name = "YawAddRight_InAir",
element = "slider"
},
YawAddRight_InAirDuck = {
_ = group.aa.conditions.in_air_d:slider("Yaw Add Right", -180, 180, 0),
name = "YawAddRight_InAirDuck",
element = "slider"
},

--PITCH

Pitch_Standing = {
_ = group.aa.conditions.standing:combo("Pitch", data.Pitch_Standing,
0),
name = "Pitch_Standing",
element = "combo"
},
Pitch_Crouching = {
_ = group.aa.conditions.crouching:combo("Pitch", data.Pitch_Crouching,
0),
name = "Pitch_Crouching",
element = "combo"
},
Pitch_Slowwalk = {
_ = group.aa.conditions.slowwalk:combo("Pitch", data.Pitch_Slowwalk,
0),
name = "Pitch_Slowwalk",
element = "combo"
},
Pitch_Moving = {
_ = group.aa.conditions.moving:combo("Pitch", data.Pitch_Moving, 0),
name = "Pitch_Moving",
element = "combo"
},
Pitch_InAir = {
_ = group.aa.conditions.in_air:combo("Pitch", data.Pitch_InAir, 0),
name = "Pitch_InAir",
element = "combo"
},
Pitch_InAirDuck = {
_ = group.aa.conditions.in_air_d:combo("Pitch", data.Pitch_InAirDuck,
0),
name = "Pitch_InAirDuck",
element = "combo"
},

--YAW MODIFIER

YawModifier_Standing = {
_ = group.aa.conditions.standing:combo("Yaw Modifier",
data.YawModifier_Standing, 0),
name = "YawModifier_Standing",
element = "combo"
},
YawModifier_Crouching = {
_ = group.aa.conditions.crouching:combo("Yaw Modifier",
data.YawModifier_Crouching, 0),
name = "YawModifier_Crouching",
element = "combo"
},
YawModifier_Slowwalk = {
_ = group.aa.conditions.slowwalk:combo("Yaw Modifier",
data.YawModifier_Slowwalk, 0),
name = "YawModifier_Slowwalk",
element = "combo"
},
YawModifier_Moving = {
_ = group.aa.conditions.moving:combo("Yaw Modifier",
data.YawModifier_Moving, 0),
name = "YawModifier_Moving",
element = "combo"
},
 YawModifier_InAir = {
_ = group.aa.conditions.in_air:combo("Yaw Modifier",
data.YawModifier_InAir, 0),
name = "YawModifier_InAir",
element = "combo"
},
YawModifier_InAirDuck = {
_ = group.aa.conditions.in_air_d:combo("Yaw Modifier",
data.YawModifier_InAirDuck, 0),
name = "YawModifier_InAirDuck",
element = "combo"
},

--YAW MODIFIER TYPE

YawModifierType_Standing = {
_ = group.aa.conditions.standing:combo("Yaw Modifier Type",
data.YawModifierType_Standing, 0),
name = "YawModifierType_Standing",
element = "combo"
},
YawModifierType_Crouching = {
_ = group.aa.conditions.crouching:combo("Yaw Modifier Type",
data.YawModifierType_Crouching, 0),
name = "YawModifierType_Crouching",
element = "combo"
},
YawModifierType_Slowwalk = {
_ = group.aa.conditions.slowwalk:combo("Yaw Modifier Type",
data.YawModifierType_Slowwalk, 0),
name = "YawModifierType_Slowwalk",
element = "combo"
},
YawModifierType_Moving = {
_ = group.aa.conditions.moving:combo("Yaw Modifier Type",
data.YawModifierType_Moving, 0),
name = "YawModifierType_Moving",
element = "combo"
},
YawModifierType_InAir = {
_ = group.aa.conditions.in_air:combo("Yaw Modifier Type",
data.YawModifierType_InAir, 0),
name = "YawModifierType_InAir",
element = "combo"
},
YawModifierType_InAirDuck = {
_ = group.aa.conditions.in_air_d:combo("Yaw Modifier Type",
data.YawModifierType_InAirDuck, 0),
name = "YawModifierType_InAirDuck",
element = "combo"
},

--MODIFIER DEGREE

ModifierDegree_Standing = {
_ = group.aa.conditions.standing:slider("Modifier Degree", -180, 180,
0),
name = "ModifierDegree_Standing",
element = "slider"
 },
ModifierDegree_Crouching = {
_ = group.aa.conditions.crouching:slider("Modifier Degree", -180, 180,
0),
name = "ModifierDegree_Crouching",
element = "slider"
},
ModifierDegree_Slowwalk = {
_ = group.aa.conditions.slowwalk:slider("Modifier Degree", -180, 180,
0),
name = "ModifierDegree_Slowwalk",
element = "slider"
},
ModifierDegree_Moving = {
_ = group.aa.conditions.moving:slider("Modifier Degree", -180, 180, 0),
name = "ModifierDegree_Moving",
element = "slider"
},
ModifierDegree_InAir = {
_ = group.aa.conditions.in_air:slider("Modifier Degree", -180, 180, 0),
name = "ModifierDegree_InAir",
element = "slider"
},
ModifierDegree_InAirDuck = {
_ = group.aa.conditions.in_air_d:slider("Modifier Degree", -180, 180,
0),
name = "ModifierDegree_InAirDuck",
element = "slider"
},

--MODIFIER DEGREE MINMINUM

ModifierDegreeMin_Standing = {
_ = group.aa.conditions.standing:slider("Modifier Degree Min", -180,
180, 0),
name = "ModifierDegreeMin_Standing",
element = "slider"
},
ModifierDegreeMin_Crouching = {
_ = group.aa.conditions.crouching:slider("Modifier Degree Min", -180,
180, 0),
name = "ModifierDegreeMin_Crouching",
element = "slider"
},
ModifierDegreeMin_Slowwalk = {
_ = group.aa.conditions.slowwalk:slider("Modifier Degree Min", -180,
180, 0),
name = "ModifierDegreeMin_Slowwalk",
element = "slider"
},
ModifierDegreeMin_Moving = {
_ = group.aa.conditions.moving:slider("Modifier Degree Min", -180, 180,
0),
name = "ModifierDegreeMin_Moving",
element = "slider"
},
ModifierDegreeMin_InAir = {
_ = group.aa.conditions.in_air:slider("Modifier Degree Min", -180, 180,
0),
 name = "ModifierDegreeMin_InAir",
element = "slider"
},
ModifierDegreeMin_InAirDuck = {
_ = group.aa.conditions.in_air_d:slider("Modifier Degree Min", -180,
180, 0),
name = "ModifierDegreeMin_InAirDuck",
element = "slider"
},

--MODIFIER DEGREE MAXIMUM

ModifierDegreeMax_Standing = {
_ = group.aa.conditions.standing:slider("Modifier Degree Max", -180,
180, 0),
name = "ModifierDegreeMax_Standing",
element = "slider"
},
ModifierDegreeMax_Crouching = {
_ = group.aa.conditions.crouching:slider("Modifier Degree Max", -180,
180, 0),
name = "ModifierDegreeMax_Crouching",
element = "slider"
},
ModifierDegreeMax_Slowwalk = {
_ = group.aa.conditions.slowwalk:slider("Modifier Degree Max", -180,
180, 0),
name = "ModifierDegreeMax_Slowwalk",
element = "slider"
},
ModifierDegreeMax_Moving = {
_ = group.aa.conditions.moving:slider("Modifier Degree Max", -180, 180,
0),
name = "ModifierDegreeMax_Moving",
element = "slider"
},
ModifierDegreeMax_InAir = {
_ = group.aa.conditions.in_air:slider("Modifier Degree Max", -180, 180,
0),
name = "ModifierDegreeMax_InAir",
element = "slider"
},
ModifierDegreeMax_InAirDuck = {
_ = group.aa.conditions.in_air_d:slider("Modifier Degree Max", -180,
180, 0),
name = "ModifierDegreeMax_InAirDuck",
element = "slider"
},

--FAKE LIMIT TYPE

FakeLimitType_Standing = {
_ = group.aa.conditions.standing:combo("Fake Limit Type",
data.FakeLimitType_Standing, 0),
name = "FakeLimitType_Standing",
element = "combo"
},
FakeLimitType_Crouching = {
_ = group.aa.conditions.crouching:combo("Fake Limit Type",
data.FakeLimitType_Crouching, 0),
name = "FakeLimitType_Crouching",
element = "combo"
},
FakeLimitType_Slowwalk = {
_ = group.aa.conditions.slowwalk:combo("Fake Limit Type",
data.FakeLimitType_Slowwalk, 0),
name = "FakeLimitType_Slowwalk",
element = "combo"
},
FakeLimitType_Moving = {
_ = group.aa.conditions.moving:combo("Fake Limit Type",
data.FakeLimitType_Moving, 0),
name = "FakeLimitType_Moving",
element = "combo"
},
FakeLimitType_InAir = {
_ = group.aa.conditions.in_air:combo("Fake Limit Type",
data.FakeLimitType_InAir, 0),
name = "FakeLimitType_InAir",
element = "combo"
},
FakeLimitType_InAirDuck = {
_ = group.aa.conditions.in_air_d:combo("Fake Limit Type",
data.FakeLimitType_InAirDuck, 0),
name = "FakeLimitType_InAirDuck",
element = "combo"
},

--LEFT LIMIT

LeftLimit_Standing = {
_ = group.aa.conditions.standing:slider("Left Limit", 0, 60, 60),
name = "LeftLimit_Standing",
element = "slider"
},
LeftLimit_Crouching = {
_ = group.aa.conditions.crouching:slider("Left Limit", 0, 60, 60),
name = "LeftLimit_Crouching",
element = "slider"
},
LeftLimit_Slowwalk = {
_ = group.aa.conditions.slowwalk:slider("Left Limit", 0, 60, 60),
name = "LeftLimit_Slowwalk",
element = "slider"
},
LeftLimit_Moving = {
_ = group.aa.conditions.moving:slider("Left Limit", 0, 60, 60),
name = "LeftLimit_Moving",
element = "slider"
},
LeftLimit_InAir = {
_ = group.aa.conditions.in_air:slider("Left Limit", 0, 60, 60),
name = "LeftLimit_InAir",
element = "slider"
},
LeftLimit_InAirDuck = {
_ = group.aa.conditions.in_air_d:slider("Left Limit", 0, 60, 60),
name = "LeftLimit_InAirDuck",
 element = "slider"
},

--RIGHT LIMIT

RightLimit_Standing = {
_ = group.aa.conditions.standing:slider("Right Limit", 0, 60, 60),
name = "RightLimit_Standing",
element = "slider"
},
RightLimit_Crouching = {
_ = group.aa.conditions.crouching:slider("Right Limit", 0, 60, 60),
name = "RightLimit_Crouching",
element = "slider"
},
RightLimit_Slowwalk = {
_ = group.aa.conditions.slowwalk:slider("Right Limit", 0, 60, 60),
name = "RightLimit_Slowwalk",
element = "slider"
},
RightLimit_Moving = {
_ = group.aa.conditions.moving:slider("Right Limit", 0, 60, 60),
name = "RightLimit_Moving",
element = "slider"
},
RightLimit_InAir = {
_ = group.aa.conditions.in_air:slider("Right Limit", 0, 60, 60),
name = "RightLimit_InAir",
element = "slider"
},
RightLimit_InAirDuck = {
_ = group.aa.conditions.in_air_d:slider("Right Limit", 0, 60, 60),
name = "RightLimit_InAirDuck",
element = "slider"
},

--FAKE OPTIONS

FakeOptions_Standing = {
_ = group.aa.conditions.standing:selectable("Fake Options",
data.FakeOptions_Standing, 0),
name = "FakeOptions_Standing",
element = "selectable"
},
FakeOptions_Crouching = {
_ = group.aa.conditions.crouching:selectable("Fake Options",
data.FakeOptions_Crouching, 0),
name = "FakeOptions_Crouching",
element = "selectable"
},
FakeOptions_Slowwalk = {
_ = group.aa.conditions.slowwalk:selectable("Fake Options",
data.FakeOptions_Slowwalk, 0),
name = "FakeOptions_Slowwalk",
element = "selectable"
},
FakeOptions_Moving = {
_ = group.aa.conditions.moving:selectable("Fake Options",
data.FakeOptions_Moving, 0),
 name = "FakeOptions_Moving",
element = "selectable"
},
FakeOptions_InAir = {
_ = group.aa.conditions.in_air:selectable("Fake Options",
data.FakeOptions_InAir, 0),
name = "FakeOptions_InAir",
element = "selectable"
},
FakeOptions_InAirDuck = {
_ = group.aa.conditions.in_air_d:selectable("Fake Options",
data.FakeOptions_InAirDuck, 0),
name = "FakeOptions_InAirDuck",
element = "selectable"
},

--LBY MODE

LBYMode_Standing = {
_ = group.aa.conditions.standing:combo("LBY Mode",
data.LBYMode_Standing, 0),
name = "LBYMode_Standing",
element = "combo",
},
LBYMode_Crouching = {
_ = group.aa.conditions.crouching:combo("LBY Mode",
data.LBYMode_Crouching, 0),
name = "LBYMode_Crouching",
element = "combo",
},
LBYMode_Slowwalk = {
_ = group.aa.conditions.slowwalk:combo("LBY Mode",
data.LBYMode_Slowwalk, 0),
name = "LBYMode_Slowwalk",
element = "combo",
},
LBYMode_Moving = {
_ = group.aa.conditions.moving:combo("LBY Mode", data.LBYMode_Moving,
0),
name = "LBYMode_Moving",
element = "combo",
},
LBYMode_InAir = {
_ = group.aa.conditions.in_air:combo("LBY Mode", data.LBYMode_InAir,
0),
name = "LBYMode_InAir",
element = "combo",
},
LBYMode_InAirDuck = {
_ = group.aa.conditions.in_air_d:combo("LBY Mode",
data.LBYMode_InAirDuck, 0),
name = "LBYMode_InAirDuck",
element = "combo",
},

--FREESTANDING DESYNC

FreestandingDesync_Standing = {
_ = group.aa.conditions.standing:combo("Freestanding Desync",
data.FreestandingDesync_Standing, 0),
name = "FreestandingDesync_Standing",
element = "combo",
},
FreestandingDesync_Crouching = {
_ = group.aa.conditions.crouching:combo("Freestanding Desync",
data.FreestandingDesync_Crouching, 0),
name = "FreestandingDesync_Crouching",
element = "combo",
},
FreestandingDesync_Slowwalk = {
_ = group.aa.conditions.slowwalk:combo("Freestanding Desync",
data.FreestandingDesync_Slowwalk, 0),
name = "FreestandingDesync_Slowwalk",
element = "combo",
},
FreestandingDesync_Moving = {
_ = group.aa.conditions.moving:combo("Freestanding Desync",
data.FreestandingDesync_Moving, 0),
name = "FreestandingDesync_Moving",
element = "combo",
},
FreestandingDesync_InAir = {
_ = group.aa.conditions.in_air:combo("Freestanding Desync",
data.FreestandingDesync_InAir, 0),
name = "FreestandingDesync_InAir",
element = "combo",
},
FreestandingDesync_InAirDuck = {
_ = group.aa.conditions.in_air_d:combo("Freestanding Desync",
data.FreestandingDesync_InAirDuck, 0),
name = "FreestandingDesync_InAirDuck",
element = "combo",
},

--DESYNC ON SHOT

DesyncOnShot_Standing = {
_ = group.aa.conditions.standing:combo("Desync On Shot",
data.DesyncOnShot_Standing, 0),
name = "DesyncOnShot_Standing",
element = "combo",
},
DesyncOnShot_Crouching = {
_ = group.aa.conditions.crouching:combo("Desync On Shot",
data.DesyncOnShot_Crouching, 0),
name = "DesyncOnShot_Crouching",
element = "combo",
},
DesyncOnShot_Slowwalk = {
_ = group.aa.conditions.slowwalk:combo("Desync On Shot",
data.DesyncOnShot_Slowwalk, 0),
name = "DesyncOnShot_Slowwalk",
element = "combo",
},
DesyncOnShot_Moving = {
_ = group.aa.conditions.moving:combo("Desync On Shot",
data.DesyncOnShot_Moving, 0),
name = "DesyncOnShot_Moving",
 element = "combo",
},
DesyncOnShot_InAir = {
_ = group.aa.conditions.in_air:combo("Desync On Shot",
data.DesyncOnShot_InAir, 0),
name = "DesyncOnShot_InAir",
element = "combo",
},
DesyncOnShot_InAirDuck = {
_ = group.aa.conditions.in_air_d:combo("Desync On Shot",
data.DesyncOnShot_InAirDuck, 0),
name = "DesyncOnShot_InAirDuck",
element = "combo",
},
}
local override_yaw = group.aa.aa:combo("Override Yaw Base", {'Disabled', 'Forward',
'Left', 'Right', 'Backward'})
local conditions = group.aa.aa:combo("Current Condition", {'Standing', 'Crouching',
'Slowwalk', 'Moving', 'In Air', 'In Air + Duck'})
local gear = {
indicators = menu_cyrax.indicators_switch._:create(),
wm = menu_cyrax.watermark_switch._:create(),
scope = menu_cyrax.scope_switch._:create(),
logs = menu_cyrax.logs_switch._:create(),
aa = menu_aa.Switch_AntiAim._:create(),
anim = menu_cyrax.animbreaker_switch._:create(),
solus = menu_cyrax.solus_switch._:create(),
}

local gear_opt = {
indicators_type = gear.indicators:combo('', data.indicators_styles),
indicators_color = gear.indicators:color_picker('Color', color(194, 187, 250,
255)),
animate = gear.wm:switch('Animate', false),
wm_color = gear.wm:color_picker('Color', color(194, 187, 250, 255)),
wm_color2 = gear.wm:color_picker('Color', color(255, 255, 255, 255)),
t_style = gear.scope:switch('T Style', false),
scope_color1 = gear.scope:color_picker('Color #1', color(255, 255,
255 ,255)),
scope_color2 = gear.scope:color_picker('Color #2', color(0, 0, 0, 0)),
scope_length = gear.scope:slider('Length', 0, 360, 100),
scope_offset = gear.scope:slider('Offset', 0, 100, 5),
screen_logs = gear.logs:switch('On Screen', false),
logs_hit = gear.logs:color_picker('Color on Hit', color(210, 206, 242)),
logs_miss = gear.logs:color_picker('Color on Miss', color(210, 206, 242)),
logs_miss_what = gear.logs:color_picker('Color on Miss', color(255, 255, 255,
255)),
export = gear.aa:button('Export', true),
import = gear.aa:button('Import', true),
default = gear.aa:button('Default Settings', true),
anim = gear.anim:selectable('', {'Static Legs', 'Leg Breaker'}),
solus_binds = gear.solus:switch('Keybinds', false),
solus_watermark = gear.solus:switch('Watermark', false),
solus_clr = gear.solus:color_picker('Color', color(210, 206, 242, 122)),
solus_1 = gear.solus:slider('xaxaxa', 0, render.screen_size().x, 120),
solus_2 = gear.solus:slider('xaxaxa', 0, render.screen_size().x, 120),
}
gear_opt.solus_1:set_visible(false)
gear_opt.solus_2:set_visible(false)
function cyraxUI.visibility()

if menu_cyrax.visuals_switch._:get() then
menu_cyrax.indicators_switch._:set_visible(true)
menu_cyrax.scope_switch._:set_visible(true)
menu_cyrax.logs_switch._:set_visible(true)
menu_cyrax.solus_switch._:set_visible(true)
menu_cyrax.watermark_switch._:set_visible(true)
else
menu_cyrax.indicators_switch._:set_visible(false)
menu_cyrax.scope_switch._:set_visible(false)
menu_cyrax.logs_switch._:set_visible(false)
menu_cyrax.solus_switch._:set_visible(false)
menu_cyrax.watermark_switch._:set_visible(false)
end

if menu_cyrax.misc_switch._:get() then
menu_cyrax.jumpscout_switch._:set_visible(true)
menu_cyrax.killsay_switch._:set_visible(true)
menu_cyrax.animbreaker_switch._:set_visible(true)
else
menu_cyrax.jumpscout_switch._:set_visible(false)
menu_cyrax.killsay_switch._:set_visible(false)
menu_cyrax.animbreaker_switch._:set_visible(false)
end

if menu_aa.Switch_AntiAim._:get() then
override_yaw:set_visible(true)
conditions:set_visible(true)

if conditions:get() == 'Standing' then

menu_aa.Pitch_Standing._:set_visible(true)
menu_aa.YawBase_Standing._:set_visible(true)
menu_aa.YawModifier_Standing._:set_visible(true)
menu_aa.FakeLimitType_Standing._:set_visible(true)
menu_aa.FakeOptions_Standing._:set_visible(true)
menu_aa.LBYMode_Standing._:set_visible(true)
menu_aa.FreestandingDesync_Standing._:set_visible(true)
menu_aa.DesyncOnShot_Standing._:set_visible(true)
menu_aa.YawAddLeft_Standing._:set_visible(true)
menu_aa.YawAddRight_Standing._:set_visible(true)
menu_aa.LeftLimit_Standing._:set_visible(true)
menu_aa.RightLimit_Standing._:set_visible(true)
menu_aa.YawModifierType_Standing._:set_visible(true)
if menu_aa.YawModifierType_Standing._:get() == 'Default' then
menu_aa.ModifierDegree_Standing._:set_visible(true)
menu_aa.ModifierDegreeMin_Standing._:set_visible(false)
menu_aa.ModifierDegreeMax_Standing._:set_visible(false)
else
menu_aa.ModifierDegree_Standing._:set_visible(false)
menu_aa.ModifierDegreeMin_Standing._:set_visible(true)
menu_aa.ModifierDegreeMax_Standing._:set_visible(true)
end
else
menu_aa.Pitch_Standing._:set_visible(false)
menu_aa.YawBase_Standing._:set_visible(false)
menu_aa.YawModifier_Standing._:set_visible(false)
menu_aa.FakeLimitType_Standing._:set_visible(false)
 menu_aa.FakeOptions_Standing._:set_visible(false)
menu_aa.LBYMode_Standing._:set_visible(false)
menu_aa.FreestandingDesync_Standing._:set_visible(false)
menu_aa.DesyncOnShot_Standing._:set_visible(false)
menu_aa.YawAddLeft_Standing._:set_visible(false)
menu_aa.YawAddRight_Standing._:set_visible(false)
menu_aa.ModifierDegree_Standing._:set_visible(false)
menu_aa.LeftLimit_Standing._:set_visible(false)
menu_aa.RightLimit_Standing._:set_visible(false)
menu_aa.ModifierDegreeMin_Standing._:set_visible(false)
menu_aa.ModifierDegreeMax_Standing._:set_visible(false)
menu_aa.YawModifierType_Standing._:set_visible(false)
end

if conditions:get() == 'Crouching' then

menu_aa.Pitch_Crouching._:set_visible(true)
menu_aa.YawBase_Crouching._:set_visible(true)
menu_aa.YawModifier_Crouching._:set_visible(true)
menu_aa.FakeLimitType_Crouching._:set_visible(true)
menu_aa.FakeOptions_Crouching._:set_visible(true)
menu_aa.LBYMode_Crouching._:set_visible(true)
menu_aa.FreestandingDesync_Crouching._:set_visible(true)
menu_aa.DesyncOnShot_Crouching._:set_visible(true)
menu_aa.YawAddLeft_Crouching._:set_visible(true)
menu_aa.YawAddRight_Crouching._:set_visible(true)
menu_aa.LeftLimit_Crouching._:set_visible(true)
menu_aa.RightLimit_Crouching._:set_visible(true)
menu_aa.YawModifierType_Crouching._:set_visible(true)
if menu_aa.YawModifierType_Crouching._:get() == 'Default' then
menu_aa.ModifierDegree_Crouching._:set_visible(true)
menu_aa.ModifierDegreeMin_Crouching._:set_visible(false)
menu_aa.ModifierDegreeMax_Crouching._:set_visible(false)
else
menu_aa.ModifierDegree_Crouching._:set_visible(false)
menu_aa.ModifierDegreeMin_Crouching._:set_visible(true)
menu_aa.ModifierDegreeMax_Crouching._:set_visible(true)
end
else
menu_aa.Pitch_Crouching._:set_visible(false)
menu_aa.YawBase_Crouching._:set_visible(false)
menu_aa.YawModifier_Crouching._:set_visible(false)
menu_aa.FakeLimitType_Crouching._:set_visible(false)
menu_aa.FakeOptions_Crouching._:set_visible(false)
menu_aa.LBYMode_Crouching._:set_visible(false)
menu_aa.FreestandingDesync_Crouching._:set_visible(false)
menu_aa.DesyncOnShot_Crouching._:set_visible(false)
menu_aa.YawAddLeft_Crouching._:set_visible(false)
menu_aa.YawAddRight_Crouching._:set_visible(false)
menu_aa.ModifierDegree_Crouching._:set_visible(false)
menu_aa.LeftLimit_Crouching._:set_visible(false)
menu_aa.RightLimit_Crouching._:set_visible(false)
menu_aa.ModifierDegreeMin_Crouching._:set_visible(false)
menu_aa.ModifierDegreeMax_Crouching._:set_visible(false)
menu_aa.YawModifierType_Crouching._:set_visible(false)
end

if conditions:get() == 'Slowwalk' then

menu_aa.Pitch_Slowwalk._:set_visible(true)
menu_aa.YawBase_Slowwalk._:set_visible(true)
 menu_aa.YawModifier_Slowwalk._:set_visible(true)
menu_aa.FakeLimitType_Slowwalk._:set_visible(true)
menu_aa.FakeOptions_Slowwalk._:set_visible(true)
menu_aa.LBYMode_Slowwalk._:set_visible(true)
menu_aa.FreestandingDesync_Slowwalk._:set_visible(true)
menu_aa.DesyncOnShot_Slowwalk._:set_visible(true)
menu_aa.YawAddLeft_Slowwalk._:set_visible(true)
menu_aa.YawAddRight_Slowwalk._:set_visible(true)
menu_aa.LeftLimit_Slowwalk._:set_visible(true)
menu_aa.RightLimit_Slowwalk._:set_visible(true)
menu_aa.YawModifierType_Slowwalk._:set_visible(true)
if menu_aa.YawModifierType_Slowwalk._:get() == 'Default' then
menu_aa.ModifierDegree_Slowwalk._:set_visible(true)
menu_aa.ModifierDegreeMin_Slowwalk._:set_visible(false)
menu_aa.ModifierDegreeMax_Slowwalk._:set_visible(false)
else
menu_aa.ModifierDegree_Slowwalk._:set_visible(false)
menu_aa.ModifierDegreeMin_Slowwalk._:set_visible(true)
menu_aa.ModifierDegreeMax_Slowwalk._:set_visible(true)
end
else
menu_aa.Pitch_Slowwalk._:set_visible(false)
menu_aa.YawBase_Slowwalk._:set_visible(false)
menu_aa.YawModifier_Slowwalk._:set_visible(false)
menu_aa.FakeLimitType_Slowwalk._:set_visible(false)
menu_aa.FakeOptions_Slowwalk._:set_visible(false)
menu_aa.LBYMode_Slowwalk._:set_visible(false)
menu_aa.FreestandingDesync_Slowwalk._:set_visible(false)
menu_aa.DesyncOnShot_Slowwalk._:set_visible(false)
menu_aa.YawAddLeft_Slowwalk._:set_visible(false)
menu_aa.YawAddRight_Slowwalk._:set_visible(false)
menu_aa.ModifierDegree_Slowwalk._:set_visible(false)
menu_aa.LeftLimit_Slowwalk._:set_visible(false)
menu_aa.RightLimit_Slowwalk._:set_visible(false)
menu_aa.ModifierDegreeMin_Slowwalk._:set_visible(false)
menu_aa.ModifierDegreeMax_Slowwalk._:set_visible(false)
menu_aa.YawModifierType_Slowwalk._:set_visible(false)
end

if conditions:get() == 'Moving' then

menu_aa.Pitch_Moving._:set_visible(true)
menu_aa.YawBase_Moving._:set_visible(true)
menu_aa.YawModifier_Moving._:set_visible(true)
menu_aa.FakeLimitType_Moving._:set_visible(true)
menu_aa.FakeOptions_Moving._:set_visible(true)
menu_aa.LBYMode_Moving._:set_visible(true)
menu_aa.FreestandingDesync_Moving._:set_visible(true)
menu_aa.DesyncOnShot_Moving._:set_visible(true)
menu_aa.YawAddLeft_Moving._:set_visible(true)
menu_aa.YawAddRight_Moving._:set_visible(true)
menu_aa.LeftLimit_Moving._:set_visible(true)
menu_aa.RightLimit_Moving._:set_visible(true)
menu_aa.YawModifierType_Moving._:set_visible(true)
if menu_aa.YawModifierType_Moving._:get() == 'Default' then
menu_aa.ModifierDegree_Moving._:set_visible(true)
menu_aa.ModifierDegreeMin_Moving._:set_visible(false)
menu_aa.ModifierDegreeMax_Moving._:set_visible(false)
else
menu_aa.ModifierDegree_Moving._:set_visible(false)
 menu_aa.ModifierDegreeMin_Moving._:set_visible(true)
menu_aa.ModifierDegreeMax_Moving._:set_visible(true)
end
else
menu_aa.Pitch_Moving._:set_visible(false)
menu_aa.YawBase_Moving._:set_visible(false)
menu_aa.YawModifier_Moving._:set_visible(false)
menu_aa.FakeLimitType_Moving._:set_visible(false)
menu_aa.FakeOptions_Moving._:set_visible(false)
menu_aa.LBYMode_Moving._:set_visible(false)
menu_aa.FreestandingDesync_Moving._:set_visible(false)
menu_aa.DesyncOnShot_Moving._:set_visible(false)
menu_aa.YawAddLeft_Moving._:set_visible(false)
menu_aa.YawAddRight_Moving._:set_visible(false)
menu_aa.ModifierDegree_Moving._:set_visible(false)
menu_aa.LeftLimit_Moving._:set_visible(false)
menu_aa.RightLimit_Moving._:set_visible(false)
menu_aa.ModifierDegreeMin_Moving._:set_visible(false)
menu_aa.ModifierDegreeMax_Moving._:set_visible(false)
menu_aa.YawModifierType_Moving._:set_visible(false)
end

if conditions:get() == 'In Air' then

menu_aa.Pitch_InAir._:set_visible(true)
menu_aa.YawBase_InAir._:set_visible(true)
menu_aa.YawModifier_InAir._:set_visible(true)
menu_aa.FakeLimitType_InAir._:set_visible(true)
menu_aa.FakeOptions_InAir._:set_visible(true)
menu_aa.LBYMode_InAir._:set_visible(true)
menu_aa.FreestandingDesync_InAir._:set_visible(true)
menu_aa.DesyncOnShot_InAir._:set_visible(true)
menu_aa.YawAddLeft_InAir._:set_visible(true)
menu_aa.YawAddRight_InAir._:set_visible(true)
menu_aa.ModifierDegree_InAir._:set_visible(true)
menu_aa.LeftLimit_InAir._:set_visible(true)
menu_aa.RightLimit_InAir._:set_visible(true)
menu_aa.YawModifierType_InAir._:set_visible(true)
if menu_aa.YawModifierType_InAir._:get() == 'Default' then
menu_aa.ModifierDegree_InAir._:set_visible(true)
menu_aa.ModifierDegreeMin_InAir._:set_visible(false)
menu_aa.ModifierDegreeMax_InAir._:set_visible(false)
else
menu_aa.ModifierDegree_InAir._:set_visible(false)
menu_aa.ModifierDegreeMin_InAir._:set_visible(true)
menu_aa.ModifierDegreeMax_InAir._:set_visible(true)
end
else
menu_aa.Pitch_InAir._:set_visible(false)
menu_aa.YawBase_InAir._:set_visible(false)
menu_aa.YawModifier_InAir._:set_visible(false)
menu_aa.FakeLimitType_InAir._:set_visible(false)
menu_aa.FakeOptions_InAir._:set_visible(false)
menu_aa.LBYMode_InAir._:set_visible(false)
menu_aa.FreestandingDesync_InAir._:set_visible(false)
menu_aa.DesyncOnShot_InAir._:set_visible(false)
menu_aa.YawAddLeft_InAir._:set_visible(false)
menu_aa.YawAddRight_InAir._:set_visible(false)
menu_aa.ModifierDegree_InAir._:set_visible(false)
menu_aa.LeftLimit_InAir._:set_visible(false)
 menu_aa.RightLimit_InAir._:set_visible(false)
menu_aa.ModifierDegreeMin_InAir._:set_visible(false)
menu_aa.ModifierDegreeMax_InAir._:set_visible(false)
menu_aa.YawModifierType_InAir._:set_visible(false)
end

if conditions:get() == 'In Air + Duck' then

menu_aa.Pitch_InAirDuck._:set_visible(true)
menu_aa.YawBase_InAirDuck._:set_visible(true)
menu_aa.YawModifier_InAirDuck._:set_visible(true)
menu_aa.FakeLimitType_InAirDuck._:set_visible(true)
menu_aa.FakeOptions_InAirDuck._:set_visible(true)
menu_aa.LBYMode_InAirDuck._:set_visible(true)
menu_aa.FreestandingDesync_InAirDuck._:set_visible(true)
menu_aa.DesyncOnShot_InAirDuck._:set_visible(true)
menu_aa.YawAddLeft_InAirDuck._:set_visible(true)
menu_aa.YawAddRight_InAirDuck._:set_visible(true)
menu_aa.LeftLimit_InAirDuck._:set_visible(true)
menu_aa.RightLimit_InAirDuck._:set_visible(true)
menu_aa.YawModifierType_InAirDuck._:set_visible(true)
if menu_aa.YawModifierType_InAirDuck._:get() == 'Default' then
menu_aa.ModifierDegree_InAirDuck._:set_visible(true)
menu_aa.ModifierDegreeMin_InAirDuck._:set_visible(false)
menu_aa.ModifierDegreeMax_InAirDuck._:set_visible(false)
else
menu_aa.ModifierDegree_InAirDuck._:set_visible(false)
menu_aa.ModifierDegreeMin_InAirDuck._:set_visible(true)
menu_aa.ModifierDegreeMax_InAirDuck._:set_visible(true)
end
else
menu_aa.Pitch_InAirDuck._:set_visible(false)
menu_aa.YawBase_InAirDuck._:set_visible(false)
menu_aa.YawModifier_InAirDuck._:set_visible(false)
menu_aa.FakeLimitType_InAirDuck._:set_visible(false)
menu_aa.FakeOptions_InAirDuck._:set_visible(false)
menu_aa.LBYMode_InAirDuck._:set_visible(false)
menu_aa.FreestandingDesync_InAirDuck._:set_visible(false)
menu_aa.DesyncOnShot_InAirDuck._:set_visible(false)
menu_aa.YawAddLeft_InAirDuck._:set_visible(false)
menu_aa.YawAddRight_InAirDuck._:set_visible(false)
menu_aa.ModifierDegree_InAirDuck._:set_visible(false)
menu_aa.LeftLimit_InAirDuck._:set_visible(false)
menu_aa.RightLimit_InAirDuck._:set_visible(false)
menu_aa.ModifierDegreeMin_InAirDuck._:set_visible(false)
menu_aa.ModifierDegreeMax_InAirDuck._:set_visible(false)
menu_aa.YawModifierType_InAirDuck._:set_visible(false)
end

else
override_yaw:set_visible(false)
conditions:set_visible(false)

menu_aa.Pitch_Standing._:set_visible(false)
menu_aa.YawBase_Standing._:set_visible(false)
menu_aa.YawModifier_Standing._:set_visible(false)
menu_aa.FakeLimitType_Standing._:set_visible(false)
menu_aa.FakeOptions_Standing._:set_visible(false)
menu_aa.LBYMode_Standing._:set_visible(false)
menu_aa.FreestandingDesync_Standing._:set_visible(false)
menu_aa.DesyncOnShot_Standing._:set_visible(false)
menu_aa.YawAddLeft_Standing._:set_visible(false)
menu_aa.YawAddRight_Standing._:set_visible(false)
menu_aa.ModifierDegree_Standing._:set_visible(false)
menu_aa.LeftLimit_Standing._:set_visible(false)
menu_aa.RightLimit_Standing._:set_visible(false)
menu_aa.ModifierDegreeMin_Standing._:set_visible(false)
menu_aa.ModifierDegreeMax_Standing._:set_visible(false)
menu_aa.YawModifierType_Standing._:set_visible(false)

menu_aa.Pitch_Crouching._:set_visible(false)
menu_aa.YawBase_Crouching._:set_visible(false)
menu_aa.YawModifier_Crouching._:set_visible(false)
menu_aa.FakeLimitType_Crouching._:set_visible(false)
menu_aa.FakeOptions_Crouching._:set_visible(false)
menu_aa.LBYMode_Crouching._:set_visible(false)
menu_aa.FreestandingDesync_Crouching._:set_visible(false)
menu_aa.DesyncOnShot_Crouching._:set_visible(false)
menu_aa.YawAddLeft_Crouching._:set_visible(false)
menu_aa.YawAddRight_Crouching._:set_visible(false)
menu_aa.ModifierDegree_Crouching._:set_visible(false)
menu_aa.LeftLimit_Crouching._:set_visible(false)
menu_aa.RightLimit_Crouching._:set_visible(false)
menu_aa.ModifierDegreeMin_Crouching._:set_visible(false)
menu_aa.ModifierDegreeMax_Crouching._:set_visible(false)
menu_aa.YawModifierType_Crouching._:set_visible(false)

menu_aa.Pitch_Slowwalk._:set_visible(false)
menu_aa.YawBase_Slowwalk._:set_visible(false)
menu_aa.YawModifier_Slowwalk._:set_visible(false)
menu_aa.FakeLimitType_Slowwalk._:set_visible(false)
menu_aa.FakeOptions_Slowwalk._:set_visible(false)
menu_aa.LBYMode_Slowwalk._:set_visible(false)
menu_aa.FreestandingDesync_Slowwalk._:set_visible(false)
menu_aa.DesyncOnShot_Slowwalk._:set_visible(false)
menu_aa.YawAddLeft_Slowwalk._:set_visible(false)
menu_aa.YawAddRight_Slowwalk._:set_visible(false)
menu_aa.ModifierDegree_Slowwalk._:set_visible(false)
menu_aa.LeftLimit_Slowwalk._:set_visible(false)
menu_aa.RightLimit_Slowwalk._:set_visible(false)
menu_aa.ModifierDegreeMin_Slowwalk._:set_visible(false)
menu_aa.ModifierDegreeMax_Slowwalk._:set_visible(false)
menu_aa.YawModifierType_Slowwalk._:set_visible(false)

menu_aa.Pitch_Moving._:set_visible(false)
menu_aa.YawBase_Moving._:set_visible(false)
menu_aa.YawModifier_Moving._:set_visible(false)
menu_aa.FakeLimitType_Moving._:set_visible(false)
menu_aa.FakeOptions_Moving._:set_visible(false)
menu_aa.LBYMode_Moving._:set_visible(false)
menu_aa.FreestandingDesync_Moving._:set_visible(false)
menu_aa.DesyncOnShot_Moving._:set_visible(false)
menu_aa.YawAddLeft_Moving._:set_visible(false)
menu_aa.YawAddRight_Moving._:set_visible(false)
menu_aa.ModifierDegree_Moving._:set_visible(false)
menu_aa.LeftLimit_Moving._:set_visible(false)
menu_aa.RightLimit_Moving._:set_visible(false)
menu_aa.ModifierDegreeMin_Moving._:set_visible(false)
menu_aa.ModifierDegreeMax_Moving._:set_visible(false)
 menu_aa.YawModifierType_Moving._:set_visible(false)

menu_aa.Pitch_InAir._:set_visible(false)
menu_aa.YawBase_InAir._:set_visible(false)
menu_aa.YawModifier_InAir._:set_visible(false)
menu_aa.FakeLimitType_InAir._:set_visible(false)
menu_aa.FakeOptions_InAir._:set_visible(false)
menu_aa.LBYMode_InAir._:set_visible(false)
menu_aa.FreestandingDesync_InAir._:set_visible(false)
menu_aa.DesyncOnShot_InAir._:set_visible(false)
menu_aa.YawAddLeft_InAir._:set_visible(false)
menu_aa.YawAddRight_InAir._:set_visible(false)
menu_aa.ModifierDegree_InAir._:set_visible(false)
menu_aa.LeftLimit_InAir._:set_visible(false)
menu_aa.RightLimit_InAir._:set_visible(false)
menu_aa.ModifierDegreeMin_InAir._:set_visible(false)
menu_aa.ModifierDegreeMax_InAir._:set_visible(false)
menu_aa.YawModifierType_InAir._:set_visible(false)

menu_aa.Pitch_InAirDuck._:set_visible(false)
menu_aa.YawBase_InAirDuck._:set_visible(false)
menu_aa.YawModifier_InAirDuck._:set_visible(false)
menu_aa.FakeLimitType_InAirDuck._:set_visible(false)
menu_aa.FakeOptions_InAirDuck._:set_visible(false)
menu_aa.LBYMode_InAirDuck._:set_visible(false)
menu_aa.FreestandingDesync_InAirDuck._:set_visible(false)
menu_aa.DesyncOnShot_InAirDuck._:set_visible(false)
menu_aa.YawAddLeft_InAirDuck._:set_visible(false)
menu_aa.YawAddRight_InAirDuck._:set_visible(false)
menu_aa.ModifierDegree_InAirDuck._:set_visible(false)
menu_aa.LeftLimit_InAirDuck._:set_visible(false)
menu_aa.RightLimit_InAirDuck._:set_visible(false)
menu_aa.ModifierDegreeMin_InAirDuck._:set_visible(false)
menu_aa.ModifierDegreeMax_InAirDuck._:set_visible(false)
menu_aa.YawModifierType_InAirDuck._:set_visible(false)
end
end

local hitgroups = {
[0] = 'generic',
'head', 'chest', 'stomach',
'left arm', 'right arm',
'left leg', 'right leg',
'neck', 'generic', 'gear'}

function func:centerLogs(e)
if globals.is_connected == false or entity.get_local_player() == nil or
entity.get_local_player():is_alive() == false or not menu_cyrax.logs_switch._:get()
then return end
local target = entity.get(e.target)
local wanted_dmg = e.wanted_damage
local damage = e.damage
local wanted_hbx = hitgroups[e.wanted_hitgroup]
local hitchance = e.hitchance
local state = e.state
local bt = e.backtrack
if not target or target == nil then return end
local hitbox = hitgroups[e.hitgroup]
 if state == nil then
color_p("[Cyrax] ", gear_opt.logs_hit:get())
print_raw(string.format("Hit %s's %s [aimed = %s | damage: %i(%i) | hc:
%i | history: %i]", target:get_name(), hitbox, wanted_hbx, damage, wanted_dmg,
hitchance, bt))
else
color_p("[Cyrax] ", gear_opt.logs_miss:get())
print_raw(string.format("Missed shot at %s's %s due to %s [hc: %i |
history: %i]", target:get_name(), wanted_hbx, state, hitchance, bt))
end

if state == nil then

print_dev(string.format("Hit %s's %s [aimed = %s | damage: %i(%i) | hc:
%i | history: %i]", target:get_name(), hitbox, wanted_hbx, damage, wanted_dmg,
hitchance, bt))
else
print_dev(string.format("Missed shot at %s's %s due to %s [hc: %i |
history: %i]", target:get_name(), wanted_hbx, state, hitchance, bt))
end

end

entity_list_pointer = ffi.cast('void***', utils.create_interface('client.dll',

'VClientEntityList003'))
get_client_entity_fn = ffi.cast('GetClientEntity_4242425_t', entity_list_pointer[0]
[3])
function get_entity_address(ent_index)
local addr = get_client_entity_fn(entity_list_pointer, ent_index)
return addr
end

hook_helper = {
copy = function(dst, src, len)
return ffi.copy(ffi.cast('void*', dst), ffi.cast('const void*', src), len)
end,

virtual_protect = function(lpAddress, dwSize, flNewProtect, lpflOldProtect)

return ffi.C.VirtualProtect(ffi.cast('void*', lpAddress), dwSize,
flNewProtect, lpflOldProtect)
end,

virtual_alloc = function(lpAddress, dwSize, flAllocationType, flProtect,

blFree)
local alloc = ffi.C.VirtualAlloc(lpAddress, dwSize, flAllocationType,
flProtect)
if blFree then
table.insert(buff.free, function()
ffi.C.VirtualFree(alloc, 0, 0x8000)
end)
end
return ffi.cast('intptr_t', alloc)
end
}

buff = {free = {}}

vmt_hook = {hooks = {}}

function vmt_hook.new(vt)
 local new_hook = {}
local org_func = {}
local old_prot = ffi.new('unsigned long[1]')
local virtual_table = ffi.cast('intptr_t**', vt)[0]

new_hook.this = virtual_table
new_hook.hookMethod = function(cast, func, method)
org_func[method] = virtual_table[method]
hook_helper.virtual_protect(virtual_table + method, 4, 0x4, old_prot)

virtual_table[method] = ffi.cast('intptr_t', ffi.cast(cast, func))

hook_helper.virtual_protect(virtual_table + method, 4, old_prot[0], old_prot)

return ffi.cast(cast, org_func[method])

end

new_hook.unHookMethod = function(method)
hook_helper.virtual_protect(virtual_table + method, 4, 0x4, old_prot)
local alloc_addr = hook_helper.virtual_alloc(nil, 5, 0x1000, 0x40, false)
local trampoline_bytes = ffi.new('uint8_t[?]', 5, 0x90)

trampoline_bytes[0] = 0xE9
ffi.cast('int32_t*', trampoline_bytes + 1)[0] = org_func[method] -
tonumber(alloc_addr) - 5

hook_helper.copy(alloc_addr, trampoline_bytes, 5)
virtual_table[method] = ffi.cast('intptr_t', alloc_addr)

hook_helper.virtual_protect(virtual_table + method, 4, old_prot[0], old_prot)

org_func[method] = nil
end

new_hook.unHookAll = function()
for method, func in pairs(org_func) do
new_hook.unHookMethod(method)
end
end

table.insert(vmt_hook.hooks, new_hook.unHookAll)
return new_hook
end

conditional_aa.onuseAAEnabled = false
conditional_aa.standingAAEnabled = false
conditional_aa.crouchingAAEnabled = false
conditional_aa.slowwalkAAEnabled = false
conditional_aa.movingAAEnabled = false
conditional_aa.inairAAEnabled = false
conditional_aa.inairAAduckEnabled = false

function conditional_aa.distanceCheck(t)
if globals.is_connected == false or entity.get_local_player() == nil or
entity.get_local_player():is_alive() == false then return end
local localplayer = entity.get_local_player()
local origin = localplayer:get_eye_position()
local vec = vector(origin.x, origin.y, origin.z)

for _, v in pairs(t) do
if vec:dist(v.m_vecOrigin) < 100 then return false end
 end

return true
end

local scope = {}
scope.screen = render.screen_size()
scope.menu = {}
scope.menu.offset = 100
scope.anim_num = 0

function func:jumpscout_fix_f()
if globals.is_connected == false or entity.get_local_player() == nil or
entity.get_local_player():is_alive() == false or
menu_cyrax.jumpscout_switch._:get() == false then return end
local vel = entity.get_local_player().m_vecVelocity
local speed = math.sqrt(vel.x*vel.x + vel.y*vel.y)
ui.find("Miscellaneous", "Main", "Movement", "Air Strafe"):set(speed > 15)
end

function func:customscope()

if globals.is_connected == false or entity.get_local_player() == nil or

entity.get_local_player():is_alive() == false then return end

if not menu_cyrax.scope_switch._:get() or menu_cyrax.visuals_switch._:get()

== false then return vars.menu.remove_scope:set('Remove Overlay') end

vars.menu.remove_scope:set('Remove All')
local local_player = entity.get_local_player()
scope.anim_speed = 15

if not local_player or not local_player:is_alive() or not

local_player.m_bIsScoped then
scope.anim_num = func:lerp(scope.anim_num, 0, scope.anim_speed *
globals.frametime)
else
scope.anim_num = func:lerp(scope.anim_num, 1, scope.anim_speed *
globals.frametime)
end

scope.length = gear_opt.scope_length:get() * scope.anim_num

scope.offset = gear_opt.scope_offset:get() * scope.anim_num

scope.col_1 = gear_opt.scope_color1:get()
scope.col_2 = gear_opt.scope_color2:get()

scope.width = 1

scope.col_1.a = scope.col_1.a * scope.anim_num

scope.col_2.a = scope.col_2.a * scope.anim_num

scope.start_x = scope.screen.x / 2
scope.start_y = scope.screen.y / 2

--Left
render.gradient(vector(scope.start_x - scope.offset, scope.start_y),
vector(scope.start_x - scope.offset - scope.length, scope.start_y + scope.width),
scope.col_1, scope.col_2, scope.col_1, scope.col_2)

--Right
render.gradient(vector(scope.start_x + scope.offset, scope.start_y),
vector(scope.start_x + scope.offset + scope.length, scope.start_y + scope.width),
scope.col_1, scope.col_2, scope.col_1, scope.col_2)

--Down

render.gradient(vector(scope.start_x, scope.start_y + scope.offset),

vector(scope.start_x + scope.width, scope.start_y + scope.offset + scope.length),
scope.col_1, scope.col_1, scope.col_2, scope.col_2)

--Up
if not gear_opt.t_style:get() then
render.gradient(vector(scope.start_x, scope.start_y - scope.offset),
vector(scope.start_x + scope.width, scope.start_y - scope.offset - scope.length),
scope.col_1, scope.col_1, scope.col_2, scope.col_2)
end
end

function CheckFlag(player, ...)

local flagList = {...};
local flagValues = true;

if (type(flagList) == "table" and #flagList > 0) then

for i = 1, #flagList do
if (type(flagList[i]) == "table") then
if (bit.band(player.m_fFlags, bit.lshift(1, flagList[i][1])) ~= 0)
then flagValues = false; end
else
if (bit.band(player.m_fFlags, bit.lshift(1, flagList[i])) == 0)
then flagValues = false; end
end
end
end

return flagValues;
end

local estisus
if func:version() == "Debug" then
estisus = 3
elseif func:version() == "Beta" then
estisus = 0
elseif func:version() == "Live" then
estisus = -2
end

function func:cyrax_ind()

if globals.is_connected == false or entity.get_local_player() == nil or

entity.get_local_player():is_alive() == false or menu_cyrax.visuals_switch._:get()
== false or menu_cyrax.indicators_switch._:get() == false or
gear_opt.indicators_type:get() ~= 'Cyrax' then return end

local p = {
sc = render.screen_size(),
ver = func:version(),
 alpha = math.clamp(math.abs(1 * math.cos(2 * math.pi *
globals.curtime / 5)), 0.5, 1),
dyntext = "",
ex = "",
localplayer = entity.get_local_player(),
clr = {
r = gear_opt.indicators_color:get().r,
g = gear_opt.indicators_color:get().g,
b = gear_opt.indicators_color:get().b,
},
}
local speed = p.localplayer.m_vecVelocity
local velocity = speed:length()

if conditional_aa.onuseAAEnabled then
vars.ind.lavendu.textu = "using"
else
if CheckFlag(p.localplayer, {0}) or common.is_button_down(0x20) then
if not CheckFlag(p.localplayer, 1) then
vars.ind.lavendu.textu = "jumping"
else
vars.ind.lavendu.textu = "airduck"
end
else
if vars.menu.sw:get() then
vars.ind.lavendu.textu = "slowwalking"
else
if CheckFlag(p.localplayer, 1) then
vars.ind.lavendu.textu = "ducking"
else
if velocity >= 1.2 then
vars.ind.lavendu.textu = "running"
else
vars.ind.lavendu.textu = "standing"
end
end
end
end
end

if vars.menu.dt:get() and vars.menu.hs:get() then

p.ex = "dt"
elseif vars.menu.dt:get() and not vars.menu.hs:get() then
p.ex = "dt"
elseif not vars.menu.dt:get() and vars.menu.hs:get() then
p.ex = "os"
end

if p.localplayer.m_bIsScoped then
vars.ind.lavendu.anim[3][1] = func:lerp(vars.ind.lavendu.anim[3][1], 26
+ estisus, globals.frametime*15)
vars.ind.lavendu.anim[3][2] = func:lerp(vars.ind.lavendu.anim[3][2], 5,
globals.frametime*15)
vars.ind.lavendu.anim[3][3] = func:lerp(vars.ind.lavendu.anim[3][3],
10, globals.frametime*15)
vars.ind.lavendu.anim[2].dt = 0
vars.ind.lavendu.chestie = 0
else
vars.ind.lavendu.anim[3][1] = func:lerp(vars.ind.lavendu.anim[3][1], 0,
globals.frametime*15)
vars.ind.lavendu.anim[3][2] = func:lerp(vars.ind.lavendu.anim[3][2], -
texts(vars.font.skeet, 'o', vars.ind.lavendu.textu).x/2, globals.frametime*15)
vars.ind.lavendu.anim[3][3] = func:lerp(vars.ind.lavendu.anim[3][3], 0,
globals.frametime*15)
vars.ind.lavendu.chestie = 0
end

if vars.menu.dt:get() or vars.menu.hs:get() then

vars.ind.lavendu.anim[1].dt = math.clamp(vars.ind.lavendu.anim[1].dt +
1, 0, 10)
else
vars.ind.lavendu.anim[1].dt = math.clamp(vars.ind.lavendu.anim[1].dt -
1, 0, 10)
end

if ui.find("Aimbot", "Anti Aim", "Angles", "Freestanding"):get() then

vars.ind.lavendu.anim[1].fs = math.clamp(vars.ind.lavendu.anim[1].fs +
1, 0, 10)

if vars.menu.dt:get() or vars.menu.hs:get() then

vars.ind.lavendu.anim[2].dt =
math.clamp(vars.ind.lavendu.anim[2].dt + 0.5, 0, 5.5)
if p.localplayer.m_bIsScoped then
vars.ind.lavendu.anim[2].fs =
math.clamp(vars.ind.lavendu.anim[2].fs + 0.5, 0, 10.5)
else
vars.ind.lavendu.anim[2].fs =
math.clamp(vars.ind.lavendu.anim[2].fs + 0.5, 0, 5.5)
end
else
vars.ind.lavendu.anim[2].dt =
math.clamp(vars.ind.lavendu.anim[2].dt - 0.5, 0, 5.5)
vars.ind.lavendu.anim[2].fs =
math.clamp(vars.ind.lavendu.anim[2].fs - 0.5, 0, 5.5)
end

else
vars.ind.lavendu.anim[1].fs = math.clamp(vars.ind.lavendu.anim[1].fs -
1, 0, 10.5)
vars.ind.lavendu.anim[2].dt = math.clamp(vars.ind.lavendu.anim[2].dt -
0.5, 0, 5.5)
end

render.text(vars.font.skeet, vector(p.sc.x/2 - texts(p.ex, 'o',

vars.font.skeet).x/2 - 5 - vars.ind.lavendu.anim[2].dt + vars.ind.lavendu.anim[3]
[3], p.sc.y/2 + 30 + vars.ind.lavendu.anim[1].dt), color(255, 255, 255,
vars.ind.lavendu.anim[1].dt/10*255), nil, p.ex)
render.text(vars.font.skeet, vector(p.sc.x/2 - texts(vars.font.skeet, 'o',
"fs").x/2 + vars.ind.lavendu.anim[2].fs + vars.ind.lavendu.anim[3][3] +
vars.ind.lavendu.chestie, p.sc.y/2 + 30 + vars.ind.lavendu.anim[1].fs), color(255,
255, 255, vars.ind.lavendu.anim[1].fs/10*255), nil, "fs")

render.text(vars.font.skeet, vector(p.sc.x/2 - texts(vars.font.skeet, 'o',

"cyrax"..func:version()).x/2 + vars.ind.lavendu.anim[3][1], p.sc.y/2 + 20),
color(255, 255, 255, 255), nil, "cyrax")
render.text(vars.font.skeet, vector(p.sc.x/2 - texts(vars.font.skeet, 'o',
"cyrax"..func:version()).x/2 + texts(vars.font.skeet, 'o', "cyrax").x + 1 +
vars.ind.lavendu.anim[3][1], p.sc.y/2+ 20), color(p.clr.r, p.clr.g, p.clr.b,
p.alpha * 255), nil, p.ver)
render.text(vars.font.skeet, vector(p.sc.x/2 + vars.ind.lavendu.anim[3][2],
p.sc.y/2+ 30), color(255, 255, 255, 122), nil, vars.ind.lavendu.textu)

end

local red = 0
function func:cyrax_ind_2()
if globals.is_connected == false or entity.get_local_player() == nil or
entity.get_local_player():is_alive() == false or menu_cyrax.visuals_switch._:get()
== false or menu_cyrax.indicators_switch._:get() == false or
gear_opt.indicators_type:get() ~= 'Cyrax V2' then return end
local screen = render.screen_size()
local t = {
alpha = math.abs(1 * math.cos(2 * math.pi * globals.curtime / 4)),
dt_text = "dt",
lp = entity.get_local_player(),
color = {
dt = color(255 - red, red, 0, vars.ind.dt_alpha),
r = gear_opt.indicators_color:get().r,
g = gear_opt.indicators_color:get().g,
b = gear_opt.indicators_color:get().b,
},
charge = rage.exploit:get(),
desync = math.floor(aantiaim.get_desync_delta()),
}
local speed = t.lp.m_vecVelocity
local velocity = speed:length()

if t.lp.m_bIsScoped then
vars.ind.scope_smooth = func:lerp(vars.ind.scope_smooth, 1.91,
globals.frametime * 11)
else
vars.ind.scope_smooth = func:lerp(vars.ind.scope_smooth, 2,
globals.frametime * 11)
end

vars.ind.smooth = func:lerp(vars.ind.smooth, t.desync, globals.frametime*8)

if vars.menu.dt:get() then
vars.ind.dt_alpha = math.clamp(vars.ind.dt_alpha + 13, 0 , 255)
if t.charge ~= 1 then
red = math.clamp(red - 25, 0, 255)
else
red = math.clamp(red + 25, 0, 255)
end
else
red = math.clamp(red + 25, 0, 1)
vars.ind.dt_alpha = math.clamp(vars.ind.dt_alpha - 12, 0 , 255)
end

t.alpha = math.clamp(t.alpha, 0.25, 1)

if vars.menu.dt:get() and vars.menu.qp:get() then

t.dt_text = "it"
else
t.dt_text = "dt"
end
 if conditional_aa.onuseAAEnabled then
vars.ind.v2.cond_text = "using"
else
if CheckFlag(t.lp, {0}) or common.is_button_down(0x20) then
if not CheckFlag(t.lp, 1) then
vars.ind.v2.cond_text = "air"
else
vars.ind.v2.cond_text = "air+"
end
else
if vars.menu.sw:get() then
vars.ind.v2.cond_text = "slowwalk"
else
if CheckFlag(t.lp, 1) then
vars.ind.v2.cond_text = "duck"
else
if velocity >= 1.2 then
vars.ind.v2.cond_text = "running"
else
vars.ind.v2.cond_text = "standing"
end
end
end
end
end

render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth -
texts(vars.font.pixel, 'o', "cyrax" .. string.lower(func:version())).x/2,
screen.y/2 + 16), color(t.color.r, t.color.g, t.color.b, 255), nil, "cyrax")

render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth -
texts(vars.font.pixel, 'o', "cyrax" .. string.lower(func:version())).x/2 +
texts(vars.font.pixel, 'o', "cyrax").x + 1, screen.y/2 + 16), color(255, 255, 255,
t.alpha*255), nil, string.lower(func:version()))

render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth -
texts(vars.font.pixel, 'o',vars.ind.v2.cond_text).x/2, screen.y/2 + 25),
color(t.color.r, t.color.g, t.color.b, 255), nil, vars.ind.v2.cond_text)

render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth -
texts(vars.font.pixel, 'o', t.dt_text).x/2, screen.y/2 + 34), t.color.dt, nil,
t.dt_text)

render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth -
texts(vars.font.pixel, 'o', "baimosfssp").x/2 - 3, screen.y/2 + 34 +
vars.ind.dt_alpha / 28), color(255, 255, 255, vars.menu.body:get() ~= 'Default' and
255 or 122), nil, "baim")

render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth -
texts(vars.font.pixel, 'o', "baimosfssp").x/2 + texts(vars.font.pixel, 'o',
"baim").x - 1, screen.y/2 + 34 + vars.ind.dt_alpha / 28), color(255, 255, 255,
vars.menu.hs:get() and 255 or 122), nil, "os")

render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth -
texts(vars.font.pixel, 'o', "baimosfssp").x/2 + texts(vars.font.pixel, 'o',
"baimos").x + 1, screen.y/2 + 34 + vars.ind.dt_alpha / 28), color(255, 255, 255,
ui.find("Aimbot", "Anti Aim", "Angles", "Freestanding"):get() and 255 or 122), nil,
"fs")
 render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth -
texts(vars.font.pixel, 'o', "baimosfssp").x/2 + texts(vars.font.pixel, 'o',
"baimosfs").x + 3, screen.y/2 + 34 + vars.ind.dt_alpha / 28), color(255, 255, 255,
vars.menu.sp:get() ~= 'Default' and 255 or 122), nil, "sp")
end

function func:cyrax_ind_3()
if globals.is_connected == false or entity.get_local_player() == nil or
entity.get_local_player():is_alive() == false or menu_cyrax.visuals_switch._:get()
== false or menu_cyrax.indicators_switch._:get() == false or
gear_opt.indicators_type:get() ~= 'Cyrax V4' then return end
local screen = render.screen_size()
local t = {
alpha = math.abs(3 * math.cos(1 * math.pi * globals.curtime / 4)) * 255,
dyn_text = "aggresive",
dt_text = "dt",
lp = entity.get_local_player(),
players = entity.get_players(),
color = {
dt = color(255, 255, 255, vars.ind.dt_alpha),
alpha_side = aantiaim.get_inverter_state() and 255 or 122,
alpha_side2 = aantiaim.get_inverter_state() and 122 or 255,
fs_green = vars.menu.fd:get() and 0 or 255,
fs_blue = vars.menu.fd:get() and 0 or 255,
r = gear_opt.indicators_color:get().r,
g = gear_opt.indicators_color:get().g,
b = gear_opt.indicators_color:get().b,
},
charge = rage.exploit:get(),
desync = math.floor(aantiaim.get_desync_delta()),
}
local speed = t.lp.m_vecVelocity
local velocity = speed:length()
local a = {
color(t.color.r, t.color.g, t.color.b, 255 * math.abs(1 * math.cos(2 *
math.pi * globals.curtime + 10 / 4))),
color(t.color.r, t.color.g, t.color.b, 255 * math.abs(1 * math.cos(2 *
math.pi * globals.curtime + 8 / 4))),
color(t.color.r, t.color.g, t.color.b, 255 * math.abs(1 * math.cos(2 *
math.pi * globals.curtime + 6 / 4))),
color(t.color.r, t.color.g, t.color.b, 255 * math.abs(1 * math.cos(2 *
math.pi * globals.curtime + 4 / 4))),
color(t.color.r, t.color.g, t.color.b, 255 * math.abs(1 * math.cos(2 *
math.pi * globals.curtime + 2 / 4))),
}

if t.lp.m_bIsScoped then
vars.ind.scope_smooth = func:lerp(vars.ind.scope_smooth, 1.91,
globals.frametime * 11)
else
vars.ind.scope_smooth = func:lerp(vars.ind.scope_smooth, 2,
globals.frametime * 11)
end

vars.ind.smooth = func:lerp(vars.ind.smooth, t.desync, globals.frametime*8)

if vars.menu.dt:get() or vars.menu.hs:get() then

vars.ind.lavendu.anim[1].dt = math.clamp(vars.ind.lavendu.anim[1].dt +
1, 0, 10)
else
vars.ind.lavendu.anim[1].dt = math.clamp(vars.ind.lavendu.anim[1].dt -
1, 0, 10)
end

if ui.find("Aimbot", "Anti Aim", "Angles", "Freestanding"):get() then

vars.ind.lavendu.anim[1].fs = math.clamp(vars.ind.lavendu.anim[1].fs +
1, 0, 10)

if vars.menu.dt:get() or vars.menu.hs:get() then

vars.ind.lavendu.anim[2].dt =
math.clamp(vars.ind.lavendu.anim[2].dt + 0.5, 0, 5.5)
if t.lp.m_bIsScoped then
vars.ind.lavendu.anim[2].fs =
math.clamp(vars.ind.lavendu.anim[2].fs + 0.5, 0, 5.5)
else
vars.ind.lavendu.anim[2].fs =
math.clamp(vars.ind.lavendu.anim[2].fs + 0.5, 0, 5.5)
end
else
vars.ind.lavendu.anim[2].dt =
math.clamp(vars.ind.lavendu.anim[2].dt - 0.5, 0, 5.5)
vars.ind.lavendu.anim[2].fs =
math.clamp(vars.ind.lavendu.anim[2].fs - 0.5, 0, 5.5)
end

else
vars.ind.lavendu.anim[1].fs = math.clamp(vars.ind.lavendu.anim[1].fs -
1, 0, 10.5)
vars.ind.lavendu.anim[2].dt = math.clamp(vars.ind.lavendu.anim[2].dt -
0.5, 0, 5.5)
end

t.alpha = math.clamp(t.alpha, 25, 255)

vars.ind.smooth = math.clamp(vars.ind.smooth, 0, 19)

if vars.menu.fs:get() then
vars.ind.fs_alpha = math.clamp(vars.ind.fs_alpha + 12, 0 , 255)
else
vars.ind.fs_alpha = math.clamp(vars.ind.fs_alpha - 12, 0 , 255)
end
local os = 0
if vars.menu.dt:get() and vars.menu.hs:get() then
t.dt_text = "dt"
elseif vars.menu.dt:get() and not vars.menu.hs:get() then
t.dt_text = "dt"
elseif not vars.menu.dt:get() and vars.menu.hs:get() then
t.dt_text = "os"
os = -1
end

if conditional_aa.onuseAAEnabled then
t.dyn_text = "using"
else
if CheckFlag(t.lp, {0}) or common.is_button_down(0x20) then
if not CheckFlag(t.lp, 1) then
t.dyn_text = "jumping"
else
 t.dyn_text = "airduck"
end
else
if vars.menu.sw:get() then
t.dyn_text = "slowwalk"
else
if CheckFlag(t.lp, 1) then
t.dyn_text = "ducking"
else
if velocity >= 1.2 then
t.dyn_text = "running"
else
t.dyn_text = "standing"
end
end
end
end
end

render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth -
texts('os', 'o', vars.font.pixel).x/2 - 5 - vars.ind.lavendu.anim[2].dt +
vars.ind.lavendu.anim[3][3] + os, screen.y/2 + 30 + vars.ind.lavendu.anim[1].dt),
color(255, 255, 255, vars.ind.lavendu.anim[1].dt/10*255), nil, t.dt_text)
render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth -
texts(vars.font.pixel, 'o', "fs").x/2 + vars.ind.lavendu.anim[2].fs +
vars.ind.lavendu.anim[3][3] + vars.ind.lavendu.chestie, screen.y/2 + 30 +
vars.ind.lavendu.anim[1].fs), color(255, 255, 255,
vars.ind.lavendu.anim[1].fs/10*255), nil, "fs")

render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth -
texts(vars.font.pixel, 'o', "cyrax").x/2, screen.y/2 + 16), color(255, 255, 255,
255), nil, "cyrax")
render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth -
texts(vars.font.pixel, 'o', "cyrax").x/2, screen.y/2 + 16), color(255, 255, 255,
255), nil, string.format("\a%sc\a%sy\a%sr\a%sa\a%sx", a[1]:to_hex(), a[2]:to_hex(),
a[3]:to_hex(), a[4]:to_hex(), a[5]:to_hex()))

for i = 1, 5 do
render.rect_outline(vector(screen.x/vars.ind.scope_smooth - 19 - i,
screen.y/2 + 27 - i), vector(screen.x/vars.ind.scope_smooth + 19 + i, screen.y/2 +
31 + i), color(t.color.r, t.color.g, t.color.b, 0.15 * (1 - i / 5) * 255), 1, 5)
end

render.rect(vector(screen.x/vars.ind.scope_smooth - 20, screen.y/2 + 27),

vector(screen.x/vars.ind.scope_smooth + 20, screen.y/2 + 31), color(0, 0, 0, 122),
1)

render.gradient(vector(screen.x/vars.ind.scope_smooth - 19, screen.y/2 + 28),

vector(screen.x/vars.ind.scope_smooth + vars.ind.smooth, screen.y/2 + 30),
color(t.color.r, t.color.g, t.color.b, 255), color(t.color.r, t.color.g, t.color.b,
0), color(t.color.r, t.color.g, t.color.b, 255), color(t.color.r, t.color.g,
t.color.b, 0), 1)

render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth -
texts(vars.font.pixel, 'o', t.dyn_text).x/2, screen.y/2 + 30), color(t.color.r,
t.color.g, t.color.b, t.alpha), nil, t.dyn_text)

end
function func:cyrax_ind_4()

if globals.is_connected == false or entity.get_local_player() == nil or

entity.get_local_player():is_alive() == false or menu_cyrax.visuals_switch._:get()
== false or menu_cyrax.indicators_switch._:get() == false or
gear_opt.indicators_type:get() ~= 'Cyrax V3' then return end

local screen = render.screen_size()

local localplayer = entity.get_local_player()
local speed = localplayer.m_vecVelocity
local velocity = speed:length()
local t = {
alpha = math.abs(1 * math.cos(2 * math.pi * globals.curtime / 4)),
dyn_text = "aggresive",
charge = rage.exploit:get(),
desync = math.floor(aantiaim.get_desync_delta()),
clr = {
r = gear_opt.indicators_color:get().r,
g = gear_opt.indicators_color:get().g,
b = gear_opt.indicators_color:get().b,
},
text = func:version(),
dt = "",
}

if conditional_aa.onuseAAEnabled then
vars.ind.v2.cond_text = "using"
else
if CheckFlag(localplayer, {0}) or common.is_button_down(0x20) then
if not CheckFlag(localplayer, 1) then
vars.ind.v2.cond_text = "jumping"
else
vars.ind.v2.cond_text = "airduck"
end
else
if vars.menu.sw:get() then
vars.ind.v2.cond_text = "slowwalking"
else
if CheckFlag(localplayer, 1) then
vars.ind.v2.cond_text = "ducking"
else
if velocity >= 1.2 then
vars.ind.v2.cond_text = "running"
else
vars.ind.v2.cond_text = "standing"
end
end
end
end
end

if vars.menu.dt:get() then
if vars.menu.qp:get() then
t.dt = "idealtick"
else
t.dt = "doubletap"
end
end
 vars.ind.smooth = func:lerp(vars.ind.smooth, math.clamp(t.desync*8, 0, 30),
globals.frametime*8)

for i = 1, 5 do
render.rect_outline(vector(screen.x/2 + 4 - i, screen.y/2 + 26 - i),
vector(screen.x/2 + 57 + i, screen.y/2 + 31 + i), color(t.clr.r, t.clr.g, t.clr.b,
0.15 * (1 - i / 5) * 255), 1, 5)
end

render.text(vars.font.pixel, vector(screen.x/2 + 5, screen.y/2 + 16),

color(t.clr.r, t.clr.g, t.clr.b, 255), nil, "Cyrax")
render.text(vars.font.pixel, vector(screen.x/2 + 5 + texts(vars.font.pixel,
'o', "Cyrax").x, screen.y/2 + 16), color(255, 255, 255, t.alpha * 255), nil,
t.text)
render.text(vars.font.pixel, vector(screen.x/2 + 5, screen.y/2 + 30),
color(t.clr.r, t.clr.g, t.clr.b, 255), nil, vars.ind.v2.cond_text)
render.text(vars.font.pixel, vector(screen.x/2 + 5, screen.y/2 +
vars.ind.v2.p[1] - 1), color(255, 255, 255, vars.ind.v2.a[1][3] * 255), nil, t.dt)
render.text(vars.font.pixel, vector(screen.x/2 + 5, screen.y/2 +
vars.ind.v2.p[2] - 1), color(255, 255, 255, vars.ind.v2.a[2] * 255), nil,
"hideshots")
render.text(vars.font.pixel, vector(screen.x/2 + 5, screen.y/2 +
vars.ind.v2.p[3] - 1), color(255, 255, 255, vars.ind.v2.a[3] * 255), nil,
"fakeduck")

render.rect(vector(screen.x/2 + 5, screen.y/2 + 27), vector(screen.x/2 + 57,

screen.y/2 + 32), color(0, 0, 0, 255), 2)
render.gradient(vector(screen.x/2 + 6, screen.y/2 + 28), vector(screen.x/2 +
25 + vars.ind.smooth, screen.y/2 + 31), color(t.clr.r, t.clr.g, t.clr.b, 255),
color(0, 0, 0, 0), color(t.clr.r, t.clr.g, t.clr.b, 255), color(0, 0, 0, 0), 2)

if vars.menu.dt:get() and not vars.menu.fd:get() then

if t.charge ~= 1 then
vars.ind.v2.a[1][1] = math.clamp(vars.ind.v2.a[1][1] + 0.036, 0,
1)
vars.ind.v2.a[1][2] = math.clamp(vars.ind.v2.a[1][2] - 0.036, 0,
1)
else
vars.ind.v2.a[1][1] = math.clamp(vars.ind.v2.a[1][1] - 0.036, 0,
1)
vars.ind.v2.a[1][2] = math.clamp(vars.ind.v2.a[1][2] + 0.036, 0,
1)
end
vars.ind.v2.p[2] = func:lerp(vars.ind.v2.p[2], 52,
globals.frametime*20)
if rage.exploit:get() == 1 then
vars.ind.v2.a[1][3] = math.clamp(vars.ind.v2.a[1][3] + 0.036, 0,
1)
else
vars.ind.v2.a[1][3] = math.clamp(vars.ind.v2.a[1][3] - 0.036,
0.1, 1)
end
else
vars.ind.v2.p[2] = func:lerp(vars.ind.v2.p[2], 40,
globals.frametime*20)
vars.ind.v2.a[1][3] = math.clamp(vars.ind.v2.a[1][3] - 0.036, 0, 1)
end
 if vars.menu.hs:get() and not vars.menu.dt:get() and not vars.menu.fd:get()
then
vars.ind.v2.a[2] = math.clamp(vars.ind.v2.a[2] + 0.036, 0, 1)
else
vars.ind.v2.a[2] = math.clamp(vars.ind.v2.a[2] - 0.036, 0, 1)
end

if vars.menu.fd:get() then
vars.ind.v2.a[3] = math.clamp(vars.ind.v2.a[3] + 0.036, 0, 1)
vars.ind.v2.p[2] = func:lerp(vars.ind.v2.p[2], 52,
globals.frametime*20)
vars.ind.v2.a[1][3] = math.clamp(vars.ind.v2.a[1][3] - 0.036, 0, 1)
vars.ind.v2.a[2] = math.clamp(vars.ind.v2.a[2] - 0.036, 0, 1)
vars.ind.v2.p[1] = func:lerp(vars.ind.v2.p[1], 52,
globals.frametime*20)
else
vars.ind.v2.a[3] = math.clamp(vars.ind.v2.a[3] - 0.036, 0, 1)
vars.ind.v2.p[1] = func:lerp(vars.ind.v2.p[1], 40,
globals.frametime*20)
end

end
gear_opt.logs_miss_what:set_visible(false)
function func:screenLogs(e)
if globals.is_connected == false or entity.get_local_player():is_alive() ==
false then return end
if not menu_cyrax.logs_switch._:get() or not gear_opt.screen_logs:get() then
return end
local target = entity.get(e.target)
local wanted_dmg = e.wanted_damage
local damage = e.damage
local wanted_hbx = hitgroups[e.wanted_hitgroup]
local hitchance = e.hitchance
local state = e.state
local bt = e.backtrack
local hitbox = hitgroups[e.hitgroup]

if e.state == nil then

table.insert(tbl, #tbl+1, {text = string.format("\a%s[Cyrax] \a%sHit
%s's \a%s%s \a%s[aimed = %s | damage: %i(%i) | hc: %i | history: %i]",
gear_opt.logs_hit:get():to_hex(), gear_opt.logs_miss_what:get():to_hex(),
target:get_name(), gear_opt.logs_hit:get():to_hex(), hitbox,
gear_opt.logs_miss_what:get():to_hex(), wanted_hbx, damage, wanted_dmg, hitchance,
bt), realtime = globals.realtime, math.floor(globals.curtime), 255, clr =
gear_opt.logs_hit:get()})
else
table.insert(tbl, #tbl+1, {text = string.format("\a%s[Cyrax] \a%sMissed
shot at %s's \a%s%s \a%sdue to \a%s%s \a%s[hc: %i | history: %i]",
gear_opt.logs_miss:get():to_hex(), gear_opt.logs_miss_what:get():to_hex(),
target:get_name(), gear_opt.logs_miss:get():to_hex(), wanted_hbx,
gear_opt.logs_miss_what:get():to_hex(), gear_opt.logs_miss:get():to_hex(), state,
gear_opt.logs_miss_what:get():to_hex(), hitchance, bt), realtime =
globals.realtime, math.floor(globals.curtime), 255, clr =
gear_opt.logs_miss:get()})
end
end
local cleartbl = function()
if #tbl ~= 0 then
 if globals.is_connected == false or globals.curtime == 0 then
table.remove(tbl, #tbl)
end
if #tbl > 5 then
table.remove(tbl, 1)
end
for i = 1, #tbl do
if tbl[i] == nil then
return
end
if tbl[i][1] + 4 > math.floor(globals.curtime) then
return
end
tbl[i][2] = tbl[i][2] - math.floor(globals.frametime * 340)

if tbl[i][2] < 0 then

table.remove(tbl, i)
end
end
end
end
function func:drawscreenLogs()
cleartbl()
local x = render.screen_size().x/2
local total_width = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
local used_width = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
local anim = globals.frametime * 10
for k, v in pairs(tbl) do
local c = v.clr or color(255, 255, 255, 255)
local text_width = texts(1, nil, v.text).x
total_width[k] = total_width[k] + text_width
local in_ = math.min((globals.realtime - v.realtime)*2, 1)
local out = math.max(((globals.realtime - 3.8) - v.realtime)*3, 0)
local cur_x = x - total_width[k] / 2 + used_width[k]

render.rect(vector(cur_x - 8, 897 + k * 30 + (in_-out) * 10),

vector(cur_x + text_width + 9, 917 + k * 30 + (in_-out) * 10), color(0, 0, 0,
math.clamp((in_-out) * 255, 0, 30)), 5)

render.text(1, vector(cur_x, 900 + k * 30 + (in_-out) * 10), color(255,

255, 255, (in_-out) * 255), nil, v.text)

for i = 1, 5 do
render.rect_outline(vector(cur_x - 8 - i, 897 + k * 30 - i +
(in_-out) * 10), vector(cur_x + text_width + 9 + i, 917 + k * 30 + i + (in_-out) *
10), color(c.r, c.g, c.b, (1 - i / 5) * math.clamp((in_-out) * 255, 0, 50)), 1, 10)
end

render.rect_outline(vector(cur_x - 8, 897 + k * 30 + (in_-out) * 10),

vector(cur_x + text_width + 9, 917 + k * 30 + (in_-out) * 10), color(c.r, c.g, c.b,
math.clamp((in_-out) * 255, 0, 255)), 1, 5)
end
end

local phrases = {
"dont talking pls",
"when u miss, cry u dont hev cyrax.tech",
"you think you are is good but im best 1",
"fokin dog, get ownet by Создатель js rezolver",
 "if im lose = my team is dog",
"never talking bad to me again, im always top1",
"umad that you're miss? hs dog",
"vico (top1 eu) vs all kelbs on hvh.",
"you is mad that im ur papi?",
"im will rape u're mother after i killed you",
"stay mad that im unhitable",
"god night brother, cya next raund ;)",
"get executed from presidend of argentina",
"you thinking ur have chencse vs boss?",
"i killed gejmsense, now im kill you",
"by luckbaysed config, cya twitter bro o/",
"cy@ https://gamesense.pub/forums/viewforum.php?id=6",
"╭∩╮(◣_◢)╭∩╮(its fuck)",
"dont play vs me on train, im live there -.-",
"by top1 uzbekistan holder umed?",
"courage for play de_shortnuke vs me, my home there.",
"bich.. dont test g4ngst3r in me.",
"im rich princ here, dont toxic dog.",
"for all thet say gamesense best, im try on parsec and is dog.",
"WEAK DOG sanchezj vs ru bossman (owned on mein map)",
"im want gamesense only for animbrejker, neverlose always top.",
"this dog brandog thinking hes top, but reality say no.",
"fawk you foking treny",
"ur think ur good but its falsee.",
"topdog nepbot get baits 24/7 -.-",
"who this bot malva? im own him 9-0",
"im beat all romania dogs with 1 finker",
"im rejp this dog noobers with no problems",
"gamesense vico vs all -.-",
"irelevent dog jompan try to stay popular but fail",
"im user beta and ur dont, stay mad.",
"dont talking, no cyrax tech no talk pls",
"when u miss, cry u dont hev cyrax.tech",
"you think you are is good but cyrax is best",
"fkn dog, get own by cyrax js rezolver",
"if you luse = no cyrax issue",
"never talking bad to me again, cyrax boosing me to top1",
"umad that you're miss? get cyrax d0g",
"stay med that im unhitable ft cyrax",
"get executed from cyrax technology",
"you thinking ur have chencse vs cyrax?",
"first i killed gejmsense, now cyrax kill you",
"by cyrax boss aa, cya twitter bro o/",
"cy@ https://en.neverlose.cc/market/item?id=17YLeZ",
"courage for test resolve me. cyrax always boosting",
}

function func:get_phrase()
return phrases[utils.random_int(1, #phrases)]:gsub('"', '')
end

function func:killsay(event)
if globals.is_connected == false or entity.get_local_player() == nil or
entity.get_local_player():is_alive() == false or not
menu_cyrax.killsay_switch._:get() then return end
local me = entity.get_local_player()
local attackere = entity.get(event.attacker, true)
 if me == attackere then
utils.console_exec('say "' .. func:get_phrase() .. '"')
end
end

function func:anti_aim_bossule(cmd)

if globals.is_connected == false or entity.get_local_player() == nil or

entity.get_local_player():is_alive() == false or not menu_aa.Switch_AntiAim._:get()
then return end
local localplayer = entity.get_local_player()
local speed = localplayer.m_vecVelocity
local velocity = speed:length()

if common.is_button_down(0x45) then
conditional_aa.onuseAAEnabled = true
else
conditional_aa.onuseAAEnabled = false
if CheckFlag(localplayer, {0}) or common.is_button_down(0x20) then
if not CheckFlag(localplayer, 1) then
conditional_aa.inairAAEnabled = true
conditional_aa.inairAAduckEnabled = false
else
conditional_aa.inairAAduckEnabled = true
conditional_aa.inairAAEnabled = false
end
else
conditional_aa.inairAAEnabled = false
conditional_aa.inairAAduckEnabled = false
if vars.menu.sw:get() then
conditional_aa.slowwalkAAEnabled = true
else
conditional_aa.slowwalkAAEnabled = false
if CheckFlag(localplayer, 1) then
conditional_aa.crouchingAAEnabled = true
else
conditional_aa.crouchingAAEnabled = false
if velocity >= 1.2 then
conditional_aa.movingAAEnabled = true
conditional_aa.standingAAEnabled = false
else
conditional_aa.movingAAEnabled = false
conditional_aa.standingAAEnabled = true
end
end
end
end
end

if conditional_aa.standingAAEnabled then

conditional_aa.pitch:set(menu_aa.Pitch_Standing._:get())

if aantiaim.get_inverter_state() then

conditional_aa.yawadd:set(menu_aa.YawAddLeft_Standing._:get())
else

conditional_aa.yawadd:set(menu_aa.YawAddRight_Standing._:get())
 end

conditional_aa.lbymode:set(menu_aa.LBYMode_Standing._:get())

conditional_aa.yawmodifier:set(menu_aa.YawModifier_Standing._:get())

if menu_aa.YawModifierType_Standing._:get() == 'Default' then

conditional_aa.modifierdegree:set(menu_aa.ModifierDegree_Standing._:get())
else

conditional_aa.modifierdegree:set(utils.random_int(menu_aa.ModifierDegreeMin_Standi
ng._:get(), menu_aa.ModifierDegreeMax_Standing._:get()))
end

if menu_aa.FakeLimitType_Standing._:get() == 'Static' then

conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_Standing._:get())

conditional_aa.fakelimitright:set(menu_aa.RightLimit_Standing._:get())
elseif menu_aa.FakeLimitType_Standing._:get() == 'Jitter' then
if utils.random_int(0,1) == 1 then

conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_Standing._:get())

conditional_aa.fakelimitright:set(menu_aa.RightLimit_Standing._:get())
else
conditional_aa.fakelimitleft:set(18)
conditional_aa.fakelimitright:set(18)
end
elseif menu_aa.FakeLimitType_Standing._:get() == 'Random Jitter' then
conditional_aa.fakelimitleft:set(utils.random_int(0,
menu_aa.LeftLimit_Standing._:get()))
conditional_aa.fakelimitright:set(utils.random_int(0,
menu_aa.RightLimit_Standing._:get()))
end

conditional_aa.fakeoptions:set(menu_aa.FakeOptions_Standing._:get())

conditional_aa.freestandingdesync:set(menu_aa.FreestandingDesync_Standing._:get())
conditional_aa.desynconshot:set(menu_aa.DesyncOnShot_Standing._:get())

if menu_aa.YawBase_Standing._:get() ~= 'Disabled' then

if menu_aa.YawBase_Standing._:get() == 'At Target' then
conditional_aa.yawbase:set('At Target')
else
conditional_aa.yawbase:set('Local View')
for k, v in pairs(yawbases) do
if menu_aa.YawBase_Standing._:get() == tostring(k)
then
conditional_aa.yawadd:set(v)
end
end
end
end
 end

if conditional_aa.slowwalkAAEnabled then

conditional_aa.pitch:set(menu_aa.Pitch_Slowwalk._:get())

if aantiaim.get_inverter_state() then

conditional_aa.yawadd:set(menu_aa.YawAddLeft_Slowwalk._:get())
else

conditional_aa.yawadd:set(menu_aa.YawAddRight_Slowwalk._:get())
end

conditional_aa.yawmodifier:set(menu_aa.YawModifier_Slowwalk._:get())

if menu_aa.YawModifierType_Slowwalk._:get() == 'Default' then

conditional_aa.modifierdegree:set(menu_aa.ModifierDegree_Slowwalk._:get())
else

conditional_aa.modifierdegree:set(utils.random_int(menu_aa.ModifierDegreeMin_Slowwa
lk._:get(), menu_aa.ModifierDegreeMax_Slowwalk._:get()))
end

if menu_aa.FakeLimitType_Slowwalk._:get() == 'Static' then

conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_Slowwalk._:get())

conditional_aa.fakelimitright:set(menu_aa.RightLimit_Slowwalk._:get())
elseif menu_aa.FakeLimitType_Slowwalk._:get() == 'Jitter' then
if utils.random_int(0,1) == 1 then

conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_Slowwalk._:get())

conditional_aa.fakelimitright:set(menu_aa.RightLimit_Slowwalk._:get())
else
conditional_aa.fakelimitleft:set(18)
conditional_aa.fakelimitright:set(18)
end
elseif menu_aa.FakeLimitType_Slowwalk._:get() == 'Random Jitter' then
conditional_aa.fakelimitleft:set(utils.random_int(0,
menu_aa.LeftLimit_Slowwalk._:get()))
conditional_aa.fakelimitright:set(utils.random_int(0,
menu_aa.RightLimit_Slowwalk._:get()))
end

conditional_aa.fakeoptions:set(menu_aa.FakeOptions_Slowwalk._:get())

conditional_aa.lbymode:set(menu_aa.LBYMode_Slowwalk._:get())

conditional_aa.freestandingdesync:set(menu_aa.FreestandingDesync_Slowwalk._:get())
conditional_aa.desynconshot:set(menu_aa.DesyncOnShot_Slowwalk._:get())

if menu_aa.YawBase_Slowwalk._:get() ~= 'Disabled' then

 if menu_aa.YawBase_Slowwalk._:get() == 'At Target' then
conditional_aa.yawbase:set('At Target')
else
for k, v in pairs(yawbases) do
conditional_aa.yawbase:set('Local View')
if menu_aa.YawBase_Slowwalk._:get() == tostring(k)
then
conditional_aa.yawadd:set(v)
end
end
end
end
end

if conditional_aa.movingAAEnabled then

conditional_aa.pitch:set(menu_aa.Pitch_Moving._:get())

if aantiaim.get_inverter_state() then

conditional_aa.yawadd:set(menu_aa.YawAddLeft_Moving._:get())
else

conditional_aa.yawadd:set(menu_aa.YawAddRight_Moving._:get())
end

conditional_aa.yawmodifier:set(menu_aa.YawModifier_Moving._:get())

if menu_aa.YawModifierType_Moving._:get() == 'Default' then

conditional_aa.modifierdegree:set(menu_aa.ModifierDegree_Moving._:get())
else

conditional_aa.modifierdegree:set(utils.random_int(menu_aa.ModifierDegreeMin_Moving
._:get(), menu_aa.ModifierDegreeMax_Moving._:get()))
end

if menu_aa.FakeLimitType_Moving._:get() == 'Static' then

conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_Moving._:get())

conditional_aa.fakelimitright:set(menu_aa.RightLimit_Moving._:get())
elseif menu_aa.FakeLimitType_Moving._:get() == 'Jitter' then
if utils.random_int(0,1) == 1 then

conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_Moving._:get())

conditional_aa.fakelimitright:set(menu_aa.RightLimit_Moving._:get())
else
conditional_aa.fakelimitleft:set(18)
conditional_aa.fakelimitright:set(18)
end
elseif menu_aa.FakeLimitType_Moving._:get() == 'Random Jitter' then
conditional_aa.fakelimitleft:set(utils.random_int(0,
menu_aa.LeftLimit_Moving._:get()))
conditional_aa.fakelimitright:set(utils.random_int(0,
menu_aa.RightLimit_Moving._:get()))
end
 conditional_aa.fakeoptions:set(menu_aa.FakeOptions_Moving._:get())

conditional_aa.lbymode:set(menu_aa.LBYMode_Moving._:get())

conditional_aa.freestandingdesync:set(menu_aa.FreestandingDesync_Moving._:get())
conditional_aa.desynconshot:set(menu_aa.DesyncOnShot_Moving._:get())

if menu_aa.YawBase_Moving._:get() ~= 'Disabled' then

if menu_aa.YawBase_Moving._:get() == 'At Target' then
conditional_aa.yawbase:set('At Target')
else
for k, v in pairs(yawbases) do
conditional_aa.yawbase:set('Local View')
if menu_aa.YawBase_Moving._:get() == tostring(k) then
conditional_aa.yawadd:set(v)
end
end
end
end
end

if conditional_aa.inairAAEnabled then

conditional_aa.pitch:set(menu_aa.Pitch_InAir._:get())

if aantiaim.get_inverter_state() then

conditional_aa.yawadd:set(menu_aa.YawAddLeft_InAir._:get())
else

conditional_aa.yawadd:set(menu_aa.YawAddRight_InAir._:get())
end

conditional_aa.yawmodifier:set(menu_aa.YawModifier_InAir._:get())

if menu_aa.YawModifierType_InAir._:get() == 'Default' then

conditional_aa.modifierdegree:set(menu_aa.ModifierDegree_InAir._:get())
else

conditional_aa.modifierdegree:set(utils.random_int(menu_aa.ModifierDegreeMin_InAir.
_:get(), menu_aa.ModifierDegreeMax_InAir._:get()))
end

if menu_aa.FakeLimitType_InAir._:get() == 'Static' then

conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_InAir._:get())

conditional_aa.fakelimitright:set(menu_aa.RightLimit_InAir._:get())
elseif menu_aa.FakeLimitType_InAir._:get() == 'Jitter' then
if utils.random_int(0,1) == 1 then

conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_InAir._:get())

conditional_aa.fakelimitright:set(menu_aa.RightLimit_InAir._:get())
 else
conditional_aa.fakelimitleft:set(18)
conditional_aa.fakelimitright:set(18)
end
elseif menu_aa.FakeLimitType_InAir._:get() == 'Random Jitter' then
conditional_aa.fakelimitleft:set(utils.random_int(0,
menu_aa.LeftLimit_InAir._:get()))
conditional_aa.fakelimitright:set(utils.random_int(0,
menu_aa.RightLimit_InAir._:get()))
end

conditional_aa.fakeoptions:set(menu_aa.FakeOptions_InAir._:get())

conditional_aa.lbymode:set(menu_aa.LBYMode_InAir._:get())

conditional_aa.freestandingdesync:set(menu_aa.FreestandingDesync_InAir._:get())
conditional_aa.desynconshot:set(menu_aa.DesyncOnShot_InAir._:get())

if menu_aa.YawBase_InAir._:get() ~= 'Disabled' then

if menu_aa.YawBase_InAir._:get() == 'At Target' then
conditional_aa.yawbase:set('At Target')
else
for k, v in pairs(yawbases) do
conditional_aa.yawbase:set('Local View')
if menu_aa.YawBase_InAir._:get() == tostring(k) then
conditional_aa.yawadd:set(v)
end
end
end
end
end

if conditional_aa.inairAAduckEnabled then

conditional_aa.pitch:set(menu_aa.Pitch_InAirDuck._:get())

if aantiaim.get_inverter_state() then

conditional_aa.yawadd:set(menu_aa.YawAddLeft_InAirDuck._:get())
else

conditional_aa.yawadd:set(menu_aa.YawAddRight_InAirDuck._:get())
end

conditional_aa.yawmodifier:set(menu_aa.YawModifier_InAirDuck._:get())

if menu_aa.YawModifierType_InAirDuck._:get() == 'Default' then

conditional_aa.modifierdegree:set(menu_aa.ModifierDegree_InAirDuck._:get())
else

conditional_aa.modifierdegree:set(utils.random_int(menu_aa.ModifierDegreeMin_InAirD
uck._:get(), menu_aa.ModifierDegreeMax_InAirDuck._:get()))
end

if menu_aa.FakeLimitType_InAirDuck._:get() == 'Static' then

 conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_InAirDuck._:get())

conditional_aa.fakelimitright:set(menu_aa.RightLimit_InAirDuck._:get())
elseif menu_aa.FakeLimitType_InAirDuck._:get() == 'Jitter' then
if utils.random_int(0,1) == 1 then

conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_InAirDuck._:get())

conditional_aa.fakelimitright:set(menu_aa.RightLimit_InAirDuck._:get())
else
conditional_aa.fakelimitleft:set(18)
conditional_aa.fakelimitright:set(18)
end
elseif menu_aa.FakeLimitType_InAirDuck._:get() == 'Random Jitter' then
conditional_aa.fakelimitleft:set(utils.random_int(0,
menu_aa.LeftLimit_InAirDuck._:get()))
conditional_aa.fakelimitright:set(utils.random_int(0,
menu_aa.RightLimit_InAirDuck._:get()))
end

conditional_aa.fakeoptions:set(menu_aa.FakeOptions_InAirDuck._:get())

conditional_aa.lbymode:set(menu_aa.LBYMode_InAirDuck._:get())

conditional_aa.freestandingdesync:set(menu_aa.FreestandingDesync_InAirDuck._:get())
conditional_aa.desynconshot:set(menu_aa.DesyncOnShot_InAirDuck._:get())

if menu_aa.YawBase_InAirDuck._:get() ~= 'Disabled' then

if menu_aa.YawBase_InAirDuck._:get() == 'At Target' then
conditional_aa.yawbase:set('At Target')
else
for k, v in pairs(yawbases) do
conditional_aa.yawbase:set('Local View')
if menu_aa.YawBase_InAirDuck._:get() == tostring(k)
then
conditional_aa.yawadd:set(v)
end
end
end
end
end

if conditional_aa.crouchingAAEnabled then

conditional_aa.pitch:set(menu_aa.Pitch_Crouching._:get())

if aantiaim.get_inverter_state() then

conditional_aa.yawadd:set(menu_aa.YawAddLeft_Crouching._:get())
else

conditional_aa.yawadd:set(menu_aa.YawAddRight_Crouching._:get())
end

conditional_aa.lbymode:set(menu_aa.LBYMode_Crouching._:get())
 conditional_aa.yawmodifier:set(menu_aa.YawModifier_Crouching._:get())

if menu_aa.YawModifierType_Crouching._:get() == 'Default' then

conditional_aa.modifierdegree:set(menu_aa.ModifierDegree_Crouching._:get())
else

conditional_aa.modifierdegree:set(utils.random_int(menu_aa.ModifierDegreeMin_Crouch
ing._:get(), menu_aa.ModifierDegreeMax_Crouching._:get()))
end

if menu_aa.FakeLimitType_Crouching._:get() == 'Static' then

conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_Crouching._:get())

conditional_aa.fakelimitright:set(menu_aa.RightLimit_Crouching._:get())
elseif menu_aa.FakeLimitType_Crouching._:get() == 'Jitter' then
if utils.random_int(0,1) == 1 then

conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_Crouching._:get())

conditional_aa.fakelimitright:set(menu_aa.RightLimit_Crouching._:get())
else
conditional_aa.fakelimitleft:set(18)
conditional_aa.fakelimitright:set(18)
end
elseif menu_aa.FakeLimitType_Crouching._:get() == 'Random Jitter' then
conditional_aa.fakelimitleft:set(utils.random_int(0,
menu_aa.LeftLimit_Crouching._:get()))
conditional_aa.fakelimitright:set(utils.random_int(0,
menu_aa.RightLimit_Crouching._:get()))
end

conditional_aa.fakeoptions:set(menu_aa.FakeOptions_Crouching._:get())

conditional_aa.freestandingdesync:set(menu_aa.FreestandingDesync_Crouching._:get())
conditional_aa.desynconshot:set(menu_aa.DesyncOnShot_Crouching._:get())

if menu_aa.YawBase_Crouching._:get() ~= 'Disabled' then

if menu_aa.YawBase_Crouching._:get() == 'At Target' then
conditional_aa.yawbase:set('At Target')
else
for k, v in pairs(yawbases) do
conditional_aa.yawbase:set('Local View')
if menu_aa.YawBase_Crouching._:get() == tostring(k)
then
conditional_aa.yawadd:set(v)
end
end
end
end
end

if override_yaw:get() ~= 'Disabled' then

for k, v in pairs(yawbases) do
conditional_aa.yawbase:set('Local View')
 if override_yaw:get() == tostring(k) then
conditional_aa.yawadd:set(v)
end
end
end

end

alpha_k = 1
width_k = 0
width_ka = 0
data_k = {
[''] = {alpha_k = 0}
}
drag = false

local render_window = function(x, y, w, h, coloru, shadow_color, outline_color)

local r, g, b, a = coloru.r, coloru.g, coloru.b, coloru.a
local r1, g1, b1, a1 = shadow_color.r, shadow_color.g, shadow_color.b,
shadow_color.a
local r2, g2, b2, a2 = outline_color.r, outline_color.g, outline_color.b,
outline_color.a

render.circle_outline(vector(x + 4, y + 4), color(r, g, b, 255), 4, 165, 0.35,

1)

render.rect(vector(x + 4, y), vector(w - 5, y+1), color(r, g, b, 255))

render.circle_outline(vector(w - 4, y + 4), color(r, g, b, 255), 4, 260, 0.35,
1)

render.gradient(vector(x, y + 4), vector(x + 1, h - 6), color(r, g, b, 255),

color(r, g, b, 255), color(r, g, b, 0), color(r, g, b, 0))
render.gradient(vector(w - 1, y + 4), vector(w, h - 6), color(r, g, b, 255),
color(r, g, b, 255), color(r, g, b, 0), color(r, g, b, 0))

render.rect(vector(x, y), vector(w, h), color(r2, g2, b2, (80 / 255) *

gear_opt.solus_clr:get().a), 5)

for i = 1, 5 do
render.rect_outline(vector(x - i, y - i), vector(w + i, h + i), color(r, g,
b, 0.15 * (1 - i / 5) * 255), 1, 5)
end

render.rect(vector(x+1, y+1), vector(w-1, h-1), color(0, 0, 0,

gear_opt.solus_clr:get().a), 5)

end

function func:getbinds()
local binds = {}
local cheatbinds = ui.get_binds()

for i = 1, #cheatbinds do
table.insert(binds, 1, cheatbinds[i])
end
return binds
end

local keybind_names = {
 ['Double Tap'] = 'Double tap',
['Hide Shots'] = 'On shot anti-aim',
['Slow Walk'] = 'Slow motion',
['Edge Jump'] = 'Jump at edge',
['Fake Ping'] = 'Ping spike',
['Override Resolver'] = 'Resolver override',
['Fake Duck'] = 'Duck peek assist',
['Minimum Damage'] = 'Damage override',
['Auto Peek'] = 'Quick peek assist',
['Body Aim'] = 'Force body aim',
['Safe Points'] = 'Safe points',
['Yaw Base'] = 'Yaw base',
['Enable Thirdperson'] = 'Thirdperson',
['Manual Yaw Base'] = 'Yaw base',
}

function upper_to_lower(str)
str1 = string.sub(str, 2, #str)
str2 = string.sub(str, 1, 1)
return str2:upper()..str1:lower()
end

local render_solus = function(x2, y2, w, h, name, font)

local name_size = render.measure_text(font, nil, name)
render_window(x2, y2, x2 + w + 3, y2 + h + 2, color(gear_opt.solus_clr:get().r,
gear_opt.solus_clr:get().g, gear_opt.solus_clr:get().b, 255),
color(gear_opt.solus_clr:get().r, gear_opt.solus_clr:get().g,
gear_opt.solus_clr:get().b, 255), color(gear_opt.solus_clr:get().r,
gear_opt.solus_clr:get().g, gear_opt.solus_clr:get().b, 255))
render.text(font, vector(x2+1 + w / 2 + 1 - name_size.x / 2, y2 + 2),
color(255,255,255, 255), nil, name)
end

function func:solus_keybinds()
if not gear_opt.solus_binds:get() or menu_cyrax.visuals_switch._:get() == false
or not menu_cyrax.solus_switch._:get() then return end
local x_k, y_k = gear_opt.solus_1:get(),gear_opt.solus_2:get()
local max_width = 0
local frametime = globals.frametime * 16
local add_y = 0
local total_width = 66
local active_binds = {}
local bind = func:getbinds()
for i = 1, #bind do
local binds = bind[i]
local bind_name = keybind_names[binds.name] == nil and
upper_to_lower(binds.name) or keybind_names[binds.name]

local bind_state = binds.mode

if bind_state == 2 then
bind_state = 'toggled'
elseif bind_state == 1 then
bind_state = 'holding'
end
if binds.name == "Minimum Damage" then
bind_state = binds.value
end

if data_k[bind_name] == nil then

 data_k[bind_name] = {alpha_k = 0}
end
--if (ui.get_alpha() > 0.9) then
-- bind_name = 'Menu toggled'
--end
data_k[bind_name].alpha_k = solus_lerp(frametime,
data_k[bind_name].alpha_k,binds.active and 1 or 0)
local bind_state_size = render.measure_text(vars.font.verdana, nil,
bind_state)
local bind_name_size = render.measure_text(vars.font.verdana, nil,
bind_name)

render.text(vars.font.verdana, vector(x_k+4, y_k + 21 + add_y), color(0, 0,

0, data_k[bind_name].alpha_k*255), nil, bind_name)
render.text(vars.font.verdana, vector(x_k+1 + (width_ka - bind_state_size.x
- 8), y_k + 21 + add_y), color(0, 0, 0, data_k[bind_name].alpha_k*255), nil,
'['..bind_state..']')

render.text(vars.font.verdana, vector(x_k+3, y_k + 20 + add_y), color(255,

255, 255, data_k[bind_name].alpha_k*255), nil, bind_name)
render.text(vars.font.verdana, vector(x_k + (width_ka - bind_state_size.x-
8), y_k + 20 + add_y), color(255, 255, 255, data_k[bind_name].alpha_k*255), nil,
'['..bind_state..']')

add_y = add_y + 16 * data_k[bind_name].alpha_k

local width_k = bind_state_size.x + bind_name_size.x + 18

if width_k > 150-11 then
if width_k > max_width then
max_width = width_k
end
end
if binds.active then
table.insert(active_binds, binds)
end
end
alpha_k = solus_lerp(frametime,alpha_k, ((ui.get_alpha() > 0.9) or
#active_binds > 0) and 1 or 0)
width_ka = solus_lerp(frametime,width_ka,math.max(max_width, 150-11))

if (ui.get_alpha() > 0.5) or #active_binds > 0 then

render_solus(x_k, y_k, width_ka, 16, 'keybinds', 11, vars.font.verdana)

local mouse = ui.get_mouse_position()

if common.is_button_down(1) and (ui.get_alpha() > 0.9) then
if mouse.x >= x_k and mouse.y >= y_k and mouse.x <= x_k + width_ka and
mouse.y <= y_k + 18 or drag then
if not drag then
drag = true
else
gear_opt.solus_1:set(mouse.x - math.floor(width_ka / 2))
gear_opt.solus_2:set(mouse.y - 8)
end
end
else
drag = false
end
end
end

function func:solus_watermark()
if not gear_opt.solus_watermark:get() or menu_cyrax.visuals_switch._:get() ==
false or not menu_cyrax.solus_switch._:get() then return end
lua_name = string.format("cyrax.tech")
user_name = common.get_username()
time = common.get_date("%H:%M:%S")
watermark_text = string.format("%s | %s | %s", lua_name, user_name, time)

if globals.is_in_game then
local ping = utils.net_channel().avg_latency[0]*1000
final_latency = ('delay: %dms'):format(ping)
watermark_text = string.format("%s | %s | %s | %s", lua_name, user_name,
final_latency, time)
end

cock_size = render.measure_text(vars.font.verdana, nil, watermark_text)

render_solus(render.screen_size().x - cock_size.x - 15, 3, cock_size.x + 5, 16,
watermark_text, 11, vars.font.verdana)
end
local function gradient_text(r1, g1, b1, a1, r2, g2, b2, a2, text)
local output = ''
local len = #text-1
local rinc = (r2 - r1) / len
local ginc = (g2 - g1) / len
local binc = (b2 - b1) / len
local ainc = (a2 - a1) / len
for i=1, len+1 do
output = output .. ('\a%02x%02x%02x%02x%s'):format(r1, g1, b1, a1,
text:sub(i, i))
r1 = r1 + rinc
g1 = g1 + ginc
b1 = b1 + binc
a1 = a1 + ainc
end
return output
end

function func:watermark()
if not menu_cyrax.watermark_switch._:get() or not
menu_cyrax.visuals_switch._:get() then return end
local alpha = math.abs(1 * math.cos(2 * math.pi * (globals.curtime + 3) / 5))
* 255
local alpha2 = math.abs(1 * math.cos(2 * math.pi * globals.curtime / 5)) *
255
local amangas = gradient_text(gear_opt.wm_color:get().r,
gear_opt.wm_color:get().g, gear_opt.wm_color:get().b, alpha, 255, 255, 255, 0,
string.format('>/cyrax anti aim technologies [%s]/<',
string.lower(func:version())))
local amangas2 = gradient_text(255, 255, 255, 0, gear_opt.wm_color:get().r,
gear_opt.wm_color:get().g, gear_opt.wm_color:get().b, alpha2,
string.format('>/cyrax anti aim technologies [%s]/<',
string.lower(func:version())))
local amangas3 = gradient_text(gear_opt.wm_color:get().r,
gear_opt.wm_color:get().g, gear_opt.wm_color:get().b, 255,
gear_opt.wm_color2:get().r, gear_opt.wm_color2:get().g, gear_opt.wm_color2:get().b,
255, string.format('>/cyrax anti aim technologies [%s]/<',
string.lower(func:version())))
 if gear_opt.animate:get() then
render.text(1, vector(10, 450), color(0, 0, 0), nil,
string.format('>/cyrax anti aim technologies [%s]/<',
string.lower(func:version())))
render.text(1, vector(10, 450), color(0, 0, 0), nil, amangas)
render.text(1, vector(10, 450), color(0, 0, 0), nil, amangas2)
gear_opt.wm_color2:set_visible(false)
else
gear_opt.wm_color2:set_visible(true)
render.text(1, vector(10, 450), color(0, 0, 0), nil, amangas3)
end
end

local alpha123 = 0
local time = anim_switch:get() and math.floor(globals.realtime) or 0

function func:loading()
local screen = render.screen_size()
if math.floor(globals.realtime) - time > 8 or not anim_switch:get() then
return end

if globals.realtime - time > 5 then

alpha123 = math.clamp(alpha123 - 1, 0, 50)
else
alpha123 = math.clamp(alpha123 + 1, 0, 50)
end

render.rect(vector(0, 0), vector(screen.x, screen.y), color(245, 202, 182,

alpha123))

render.texture(gif, vector(screen.x/2.8, screen.y/4), vector(540, 540),

color(255, 255, 255, alpha123 * 5.5))

end

hooked_function = nil
ground_ticks, end_time = 1, 0
function updateCSA_hk(thisptr, edx)
if entity.get_local_player() == nil or ffi.cast('uintptr_t', thisptr) == nil
then return end
hooked_function(thisptr, edx)
if gear_opt.anim:get("Static Legs") and menu_cyrax.animbreaker_switch._:get()
then
ffi.cast('float*', ffi.cast('uintptr_t', thisptr) + 10104)[6] = 1
end
if gear_opt.anim:get("Leg Breaker") and menu_cyrax.animbreaker_switch._:get()
then
ffi.cast('float*', ffi.cast('uintptr_t', thisptr) + 10104)[0] = 1
conditional_aa.legmovement:set('Sliding')
end
end

function anim_state_hook()
local local_player = entity.get_local_player()
if not local_player then return end

local local_player_ptr = get_entity_address(local_player:get_index())

if not local_player_ptr or hooked_function then return end
 local C_CSPLAYER = vmt_hook.new(local_player_ptr)
hooked_function = C_CSPLAYER.hookMethod('void(__fastcall*)(void*, void*)',
updateCSA_hk, 224)
end

local handleSaveConfig = {
switch = function(el)
return {
name = el.name,
element = el.element,
value = el._:get()
}
end,

slider = function(el)
return {
name = el.name,
element = el.element,
value = el._:get()
}
end,

color_picker = function(el)
local clr = el._:get()
return {
name = el.name,
element = el.element,
color = {
r = clr.r,
g = clr.g,
b = clr.b,
a = clr.a
}
}
end,

combo = function(el)
return {
name = el.name,
element = el.element,
value = el._:get()
}
end,

selectable = function(el)
return {
name = el.name,
element = el.element,
value = el._:get()
}
end

local handleLoadConfig = {
switch = function(el)
menu_aa[el.name]._:set(el.value)
end,
 slider = function(el)
menu_aa[el.name]._:set(el.value)
end,

color_picker = function(el)
local clr = init(el.color.r, el.color.g, el.color.b, el.color.a)
menu_aa[el.name]._:set(clr)
end,

combo = function(el)
menu_aa[el.name]._:set(el.value)
end,

selectable = function(el)
pcall(function() return menu_aa[el.name]._:set(el.value) end)
end

gear_opt.export:set_callback(function()

local config = {}

for key, el in pairs(menu_aa) do

if el.element == "Button" then goto continue end
table.insert(config, handleSaveConfig[el.element](el))
::continue::
end

clipboard.set(base64.encode(json.stringify(config)))
print_dev("Cyrax - Config saved to clipboard")

table.insert(tbl, #tbl+1, {text = string.format("\a%s[Cyrax] \a%sConfig \a

%sExported", gear_opt.logs_hit:get():to_hex(),
gear_opt.logs_miss_what:get():to_hex(), gear_opt.logs_hit:get():to_hex(),
gear_opt.logs_miss_what:get():to_hex()), realtime = globals.realtime,
math.floor(globals.curtime), 255, clr = gear_opt.logs_hit:get()})
end)

gear_opt.import:set_callback(function()
local status, config = pcall(function() return
json.parse(base64.decode(clipboard.get())) end)

if not status or status == nil then

color_p("Cyrax: Failed to load config\n", color(1, 0, 0, 1))
print_dev("Cyrax - Failed to load config")
table.insert(tbl, #tbl+1, {text = string.format("\a%s[Cyrax] Failed \a
%sto \a%sImport \a%sConfig", gear_opt.logs_miss:get():to_hex(),
gear_opt.logs_miss_what:get():to_hex(), gear_opt.logs_miss:get():to_hex(),
gear_opt.logs_miss_what:get():to_hex()), realtime = globals.realtime,
math.floor(globals.curtime), 255, clr = gear_opt.logs_hit:get()})
return end

for key, el in pairs(config) do

if el.element == "Button" then goto continue end
handleLoadConfig[el.element](el)
::continue::
end
print_dev("Cyrax - Config loaded")
 table.insert(tbl, #tbl+1, {text = string.format("\a%s[Cyrax] \a%sConfig \a
%sImported", gear_opt.logs_hit:get():to_hex(),
gear_opt.logs_miss_what:get():to_hex(), gear_opt.logs_hit:get():to_hex(),
gear_opt.logs_miss_what:get():to_hex()), realtime = globals.realtime,
math.floor(globals.curtime), 255, clr = gear_opt.logs_hit:get()})
menu_aa.YawBase_InAir._:set('At Target')
end)

gear_opt.default:set_callback(function()

local status, config = pcall(function() return

json.parse(base64.decode(network.get('https://pastes.io/raw/7fr1wkdx5e'))) end)

if not status or status == nil then

color_p("Cyrax: Failed to load config\n", color(1, 0, 0, 1))
return end

for key, el in pairs(config) do

if el.element == "Button" then goto continue end
handleLoadConfig[el.element](el)
::continue::
end
print_dev("Cyrax - Default config loaded")
menu_aa.YawBase_InAir._:set('At Target')
table.insert(tbl, #tbl+1, {text = string.format("\a%s[Cyrax] \a%sDefault
Config \a%sLoaded", gear_opt.logs_hit:get():to_hex(),
gear_opt.logs_miss_what:get():to_hex(), gear_opt.logs_hit:get():to_hex(),
gear_opt.logs_miss_what:get():to_hex()), realtime = globals.realtime,
math.floor(globals.curtime), 255, clr = gear_opt.logs_hit:get()})
end)

function callbacks.render()
func:customscope()
func:jumpscout_fix_f()
func:cyrax_ind()
func:cyrax_ind_2()
func:cyrax_ind_3()
func:cyrax_ind_4()
if globals.realtime > 60 then func:loading() end
func:funnydog()
func:solus_keybinds()
func:drawscreenLogs()
func:solus_watermark()
func:watermark()
local anim = math.abs(1 * math.cos(2 * math.pi * globals.curtime / 14)) * 11
ui.sidebar("\aFFD5BBFF" .. str:sub(1, anim), 'moon')
end
function callbacks.pre_render()
cyraxUI.visibility()
end
function callbacks.createmove()
end

function callbacks.player_death(event)
func:killsay(event)
end

function callbacks.createmove_run(cmd)
anim_state_hook()
 func:anti_aim_bossule(cmd)
end

function callbacks.aim_fire(e)
end

function callbacks.aim_ack(e)
func:centerLogs(e)
func:screenLogs(e)
end

events.render:set(callbacks.render)
events.pre_render:set(callbacks.pre_render)
events.aim_ack:set(callbacks.aim_ack)
events.aim_fire:set(callbacks.aim_fire)
events.player_death:set(callbacks.player_death)
events.createmove:set(callbacks.createmove)
events.createmove_run:set(callbacks.createmove_run)
events.shutdown:set(function()
for _, reset_function in ipairs(vmt_hook.hooks) do
reset_function()
end
end)