--- BLOCK #0 1-102, warpins: 1 ---
derp = "PARTIAL LUA SOURCE by Grampa Sexy Ted Stevens @ http://steamcommunity.com/id/grampasexytedstevens/ \n\tCongrats that you found this, its about damn time! Be sure to check out our product @ CitizenHack.me for updates and support :)\n"
AT = {}
AT.nigs = {}
AT.vars = {
	FRIENDS_STEAM = 0,
	AIMBOT_ON = 0,
	AIMBOT_FOV = 50,
	ESP_ENT_DIST = 40000000000.0,
	CHAMS_ON = 0,
	SHOW_MENU = true,
	AIMBOT_SMOOTHING = 0.1,
	ESP_ON = 0,
	CHAMS_DIST = 400000000,
	ESP_DEBUG = 0,
	ESP_DIST = 400000000,
	AIMBOT_SMOOTH = 0,
	BINDS = {
		{
			"NONE",
			0
		},
		[2] = {
			"INSERT",
			72
		},
		[3] = {
			"NONE",
			0
		},
		[4] = {
			"NONE",
			0
		}
	},
	FRIENDS = {},
	ESP_ENTS = {}
}
AT.consolelogs = {}
AT.fonts = {}
AT.Teams = {}
_surface = {}
_R = {}
_R.Entity = {}
_R.Player = {}
_R.IMaterial = {}
_R.Vector = {}
_R.CUserCmd = {}
_R.Angle = {}
_R.Weapon = {}
_R.VMatrix = {}
g = {}
g.game = {}
g.render = {}
g.surface = {}
g.table = {}
g.vgui = {}
g.math = {}
g.ents = {}
g.player = {}
g.cam = {}
g.input = {}
g.gui = {}
g.util = {}
g.string = {}
g.engine = {}
g.debug = {}
mlol = nigtese6
ME = nil

function duh(t)
	--- BLOCK #0 1-11, warpins: 1 ---
	tbl = {}

	mlol("debug.setmetatable")(tbl, {
		__index = function (t2, k)
			--- BLOCK #0 1-13, warpins: 1 ---
			d = mlol(mlol("table.concat")({
				t,
				k
			}, "."))
			--- END OF BLOCK #0 ---

			slot2 = if d then
			JUMP TO BLOCK #1
			else
			JUMP TO BLOCK #2
			end


			--- BLOCK #1 14-15, warpins: 1 ---
			tbl[k] = d
			--- END OF BLOCK #1 ---

			FLOW; TARGET BLOCK #2


			--- BLOCK #2 16-17, warpins: 2 ---
			--- END OF BLOCK #2 ---

			slot3 = if not d then
			JUMP TO BLOCK #3
			else
			JUMP TO BLOCK #4
			end


			--- BLOCK #3 18-18, warpins: 1 ---
			slot3 = nil

			--- END OF BLOCK #3 ---

			FLOW; TARGET BLOCK #4


			--- BLOCK #4 19-19, warpins: 2 ---
			return slot3
			--- END OF BLOCK #4 ---



		end
	})

	return tbl
	--- END OF BLOCK #0 ---



end

mlol("debug.setmetatable")(_R, {
	__index = function (t, k)
		--- BLOCK #0 1-5, warpins: 1 ---
		d = mlol(k)
		--- END OF BLOCK #0 ---

		slot2 = if d then
		JUMP TO BLOCK #1
		else
		JUMP TO BLOCK #2
		end


		--- BLOCK #1 6-7, warpins: 1 ---
		_R[k] = d
		--- END OF BLOCK #1 ---

		FLOW; TARGET BLOCK #2


		--- BLOCK #2 8-9, warpins: 2 ---
		--- END OF BLOCK #2 ---

		slot3 = if not d then
		JUMP TO BLOCK #3
		else
		JUMP TO BLOCK #4
		end


		--- BLOCK #3 10-10, warpins: 1 ---
		slot3 = nil

		--- END OF BLOCK #3 ---

		FLOW; TARGET BLOCK #4


		--- BLOCK #4 11-11, warpins: 2 ---
		return slot3
		--- END OF BLOCK #4 ---



	end
})
mlol("debug.setmetatable")(g, {
	__index = function (t, k)
		--- BLOCK #0 1-5, warpins: 1 ---
		d = mlol(k)
		--- END OF BLOCK #0 ---

		slot2 = if d then
		JUMP TO BLOCK #1
		else
		JUMP TO BLOCK #2
		end


		--- BLOCK #1 6-7, warpins: 1 ---
		g[k] = d
		--- END OF BLOCK #1 ---

		FLOW; TARGET BLOCK #2


		--- BLOCK #2 8-9, warpins: 2 ---
		--- END OF BLOCK #2 ---

		slot3 = if not d then
		JUMP TO BLOCK #3
		else
		JUMP TO BLOCK #4
		end


		--- BLOCK #3 10-10, warpins: 1 ---
		slot3 = nil

		--- END OF BLOCK #3 ---

		FLOW; TARGET BLOCK #4


		--- BLOCK #4 11-11, warpins: 2 ---
		return slot3
		--- END OF BLOCK #4 ---



	end
})

function lolss(t, s)
	--- BLOCK #0 1-12, warpins: 1 ---
	t[s] = {}

	mlol("debug.setmetatable")(t[s], {
		__index = function (t2, k)
			--- BLOCK #0 1-13, warpins: 1 ---
			d = mlol(mlol("table.concat")({
				s,
				k
			}, "."))
			--- END OF BLOCK #0 ---

			slot2 = if d then
			JUMP TO BLOCK #1
			else
			JUMP TO BLOCK #2
			end


			--- BLOCK #1 14-14, warpins: 1 ---
			t2[k] = d
			--- END OF BLOCK #1 ---

			FLOW; TARGET BLOCK #2


			--- BLOCK #2 15-16, warpins: 2 ---
			--- END OF BLOCK #2 ---

			slot3 = if not d then
			JUMP TO BLOCK #3
			else
			JUMP TO BLOCK #4
			end


			--- BLOCK #3 17-17, warpins: 1 ---
			slot3 = nil

			--- END OF BLOCK #3 ---

			FLOW; TARGET BLOCK #4


			--- BLOCK #4 18-18, warpins: 2 ---
			return slot3
			--- END OF BLOCK #4 ---



		end
	})

	return
	--- END OF BLOCK #0 ---



end

pairs = mlol("pairs")

--- END OF BLOCK #0 ---

for k, v in pairs(_R)

LOOP BLOCK #1
GO OUT TO BLOCK #3


--- BLOCK #1 103-106, warpins: 1 ---
lolss(_R, k)
--- END OF BLOCK #1 ---

FLOW; TARGET BLOCK #2


--- BLOCK #2 107-108, warpins: 2 ---
--- END OF BLOCK #2 ---

UNCONDITIONAL JUMP; TARGET BLOCK #0


--- BLOCK #3 109-112, warpins: 1 ---
--- END OF BLOCK #3 ---

for k, v in pairs(g)

LOOP BLOCK #4
GO OUT TO BLOCK #6


--- BLOCK #4 113-116, warpins: 1 ---
lolss(g, k)

--- END OF BLOCK #4 ---

FLOW; TARGET BLOCK #5


--- BLOCK #5 117-118, warpins: 2 ---
--- END OF BLOCK #5 ---

UNCONDITIONAL JUMP; TARGET BLOCK #3


--- BLOCK #6 119-739, warpins: 1 ---
Angle = mlol("Angle")
Vector = mlol("Vector")
Entity = mlol("Vector")
_surface = duh("surface")
table = duh("table")
_vgui = duh("vgui")
fl = duh("file")
dbug = duh("debug")
AT.weapons = duh("weapons")
pall = g.player.GetAll
eall = g.ents.GetAll
mplayers = g.game.MaxPlayers()

function pall()
	--- BLOCK #0 1-5, warpins: 1 ---
	ptbl = {}
	--- END OF BLOCK #0 ---

	for i=1, mplayers, 1
	LOOP BLOCK #1
	GO OUT TO BLOCK #4

	--- BLOCK #1 6-16, warpins: 2 ---
	ent = g.Entity(i)

	--- END OF BLOCK #1 ---

	slot6 = if _R.Entity.IsValid(ent)

	 then
	JUMP TO BLOCK #2
	else
	JUMP TO BLOCK #3
	end


	--- BLOCK #2 17-17, warpins: 1 ---
	ptbl[i] = ent

	--- END OF BLOCK #2 ---

	FLOW; TARGET BLOCK #3


	--- BLOCK #3 18-18, warpins: 2 ---
	--- END OF BLOCK #3 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #0


	--- BLOCK #4 19-19, warpins: 1 ---
	return ptbl
	--- END OF BLOCK #4 ---



end

function eall()
	--- BLOCK #0 1-5, warpins: 1 ---
	ptbl = {}
	--- END OF BLOCK #0 ---

	for i=1, 8192, 1
	LOOP BLOCK #1
	GO OUT TO BLOCK #4

	--- BLOCK #1 6-16, warpins: 2 ---
	ent = g.Entity(i)

	--- END OF BLOCK #1 ---

	slot6 = if _R.Entity.IsValid(ent)

	 then
	JUMP TO BLOCK #2
	else
	JUMP TO BLOCK #3
	end


	--- BLOCK #2 17-17, warpins: 1 ---
	ptbl[i] = ent

	--- END OF BLOCK #2 ---

	FLOW; TARGET BLOCK #3


	--- BLOCK #3 18-18, warpins: 2 ---
	--- END OF BLOCK #3 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #0


	--- BLOCK #4 19-19, warpins: 1 ---
	return ptbl
	--- END OF BLOCK #4 ---



end

ScrW = g.ScrW
ScrH = g.ScrH

function print(m)
	--- BLOCK #0 1-11, warpins: 1 ---
	g.MsgC({
		g = 255,
		a = 255,
		b = 255,
		r = 255
	}, g.tostring(m) .. "\n")

	return
	--- END OF BLOCK #0 ---



end

g.print = print
dgm = g.debug.getmetatable
istable = g.istable

function tcopy(t, lookup_table)
	--- BLOCK #0 1-2, warpins: 1 ---
	--- END OF BLOCK #0 ---

	if t == nil then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 3-4, warpins: 1 ---
	return nil

	--- END OF BLOCK #1 ---

	FLOW; TARGET BLOCK #2


	--- BLOCK #2 5-9, warpins: 2 ---
	copy = {}

	--- END OF BLOCK #2 ---

	for i, v in pairs(t)

	LOOP BLOCK #3
	GO OUT TO BLOCK #11


	--- BLOCK #3 10-14, warpins: 1 ---
	--- END OF BLOCK #3 ---

	slot8 = if not istable(v)

	 then
	JUMP TO BLOCK #4
	else
	JUMP TO BLOCK #5
	end


	--- BLOCK #4 15-16, warpins: 1 ---
	copy[i] = v
	--- END OF BLOCK #4 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #10


	--- BLOCK #5 17-18, warpins: 1 ---
	--- END OF BLOCK #5 ---

	slot1 = if not lookup_table then
	JUMP TO BLOCK #6
	else
	JUMP TO BLOCK #7
	end


	--- BLOCK #6 19-19, warpins: 1 ---
	lookup_table = {}
	--- END OF BLOCK #6 ---

	FLOW; TARGET BLOCK #7


	--- BLOCK #7 20-23, warpins: 2 ---
	lookup_table[t] = copy
	--- END OF BLOCK #7 ---

	slot8 = if lookup_table[v] then
	JUMP TO BLOCK #8
	else
	JUMP TO BLOCK #9
	end


	--- BLOCK #8 24-26, warpins: 1 ---
	copy[i] = lookup_table[v]
	--- END OF BLOCK #8 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #10


	--- BLOCK #9 27-31, warpins: 1 ---
	copy[i] = tcopy(v, lookup_table)

	--- END OF BLOCK #9 ---

	FLOW; TARGET BLOCK #10


	--- BLOCK #10 32-33, warpins: 4 ---
	--- END OF BLOCK #10 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #2


	--- BLOCK #11 34-34, warpins: 1 ---
	return copy
	--- END OF BLOCK #11 ---



end

g.tonumber = g.tonumber
g.tostring = g.tostring
g.math.abs = g.math.abs
g.math.ceil = g.math.ceil
g.math.floor = g.math.floor
g.math.random = g.math.random
g.math.randomseed = g.math.randomseed
g.math.min = g.math.min
g.math.sqrt = g.math.sqrt
g.string.sub = g.string.sub
g.string.gsub = g.string.gsub
g.string.len = g.string.len
g.string.lower = g.string.lower
g.rawget = g.rawget
SS_DID = false
IGNORE_FRAME = false
lastpos = g.Vector()
lastang = g.Angle()
lastscan = 0
copy = {}
cones = {}
nullvec = g.Vector()*-1
special = {}
clumpspread = {}
lastbulletseed = 0
pp = false
NEXtframe = 0
bname = nil
LastQuery = 0
did = false
realnig = nigtest
IGNFS = {}
ndsfdsf = {}

function nigtest(num, dat, ...)
	--- BLOCK #0 1-6, warpins: 1 ---
	--- END OF BLOCK #0 ---

	if g.type(dat)

	 == "function" then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #1 7-14, warpins: 1 ---
	IGNFS[dat] = true
	slot2 = ndsfdsf
	--- END OF BLOCK #1 ---

	slot3 = if not ndsfdsf[num] then
	JUMP TO BLOCK #2
	else
	JUMP TO BLOCK #3
	end


	--- BLOCK #2 15-20, warpins: 1 ---
	slot3 = g.math.random(1319386064, 1519386064)
	--- END OF BLOCK #2 ---

	FLOW; TARGET BLOCK #3


	--- BLOCK #3 21-21, warpins: 2 ---
	slot2[dat] = slot3

	--- END OF BLOCK #3 ---

	FLOW; TARGET BLOCK #4


	--- BLOCK #4 22-27, warpins: 2 ---
	realnig(num, dat, ...)

	return
	--- END OF BLOCK #4 ---



end

nigtest(3, function (n, ...)
	--- BLOCK #0 1-2, warpins: 1 ---
	--- END OF BLOCK #0 ---

	slot0 = if not n then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 3-3, warpins: 1 ---
	return
	--- END OF BLOCK #1 ---

	FLOW; TARGET BLOCK #2


	--- BLOCK #2 4-8, warpins: 2 ---
	--- END OF BLOCK #2 ---

	slot1 = if AT.nigs[n] then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #3 9-13, warpins: 1 ---
	return AT.nigs[n](...)
	--- END OF BLOCK #3 ---

	FLOW; TARGET BLOCK #4


	--- BLOCK #4 14-14, warpins: 2 ---
	return
	--- END OF BLOCK #4 ---



end)

AT.rndstr = nigtese5
AT.loadvars = nigtest5
AT.st = nigtest6
AT.st2 = nigtese1
AT.jmp = nigtest7
AT.dm2 = nigtest8
AT.wd = nigtest9
AT.ms = nigtest0
AT.sn = nigtese0
AT.getmodel = nigtese2
AT.meid = AT_JENNES
AT.uid = AT_JAMESBOND
AT.mid = AT_JAMESNIG
AT.EYEPOS = nigtese10
AT.getmap = nigtese3
AT.igc = nigtese4
AT.rstr = niggerjew
g.cam.Start2D = function ()
	--- BLOCK #0 1-5, warpins: 1 ---
	return g.cam.Start({
		type = "2D"
	})
	--- END OF BLOCK #0 ---



end
g.cam.Start3D = function (pos, ang, fov, x, y, w, h, znear, zfar)
	--- BLOCK #0 1-7, warpins: 1 ---
	tab = {}
	tab.type = "3D"
	tab.origin = pos
	tab.angles = ang
	--- END OF BLOCK #0 ---

	if fov ~= nil then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 8-8, warpins: 1 ---
	tab.fov = fov
	--- END OF BLOCK #1 ---

	FLOW; TARGET BLOCK #2


	--- BLOCK #2 9-10, warpins: 2 ---
	--- END OF BLOCK #2 ---

	if x ~= nil then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #7
	end


	--- BLOCK #3 11-12, warpins: 1 ---
	--- END OF BLOCK #3 ---

	if y ~= nil then
	JUMP TO BLOCK #4
	else
	JUMP TO BLOCK #7
	end


	--- BLOCK #4 13-14, warpins: 1 ---
	--- END OF BLOCK #4 ---

	if w ~= nil then
	JUMP TO BLOCK #5
	else
	JUMP TO BLOCK #7
	end


	--- BLOCK #5 15-16, warpins: 1 ---
	--- END OF BLOCK #5 ---

	if h ~= nil then
	JUMP TO BLOCK #6
	else
	JUMP TO BLOCK #7
	end


	--- BLOCK #6 17-22, warpins: 1 ---
	tab.x = x
	tab.y = y
	tab.w = w
	tab.h = h
	tab.aspect = w/h
	--- END OF BLOCK #6 ---

	FLOW; TARGET BLOCK #7


	--- BLOCK #7 23-24, warpins: 5 ---
	--- END OF BLOCK #7 ---

	if znear ~= nil then
	JUMP TO BLOCK #8
	else
	JUMP TO BLOCK #10
	end


	--- BLOCK #8 25-26, warpins: 1 ---
	--- END OF BLOCK #8 ---

	if zfar ~= nil then
	JUMP TO BLOCK #9
	else
	JUMP TO BLOCK #10
	end


	--- BLOCK #9 27-28, warpins: 1 ---
	tab.znear = znear
	tab.zfar = zfar

	--- END OF BLOCK #9 ---

	FLOW; TARGET BLOCK #10


	--- BLOCK #10 29-33, warpins: 3 ---
	return g.cam.Start(tab)
	--- END OF BLOCK #10 ---



end
g.Color = function (r, gg, b, a)
	--- BLOCK #0 1-2, warpins: 1 ---
	--- END OF BLOCK #0 ---

	slot3 = if not a then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 3-3, warpins: 1 ---
	a = 255

	--- END OF BLOCK #1 ---

	FLOW; TARGET BLOCK #2


	--- BLOCK #2 4-45, warpins: 2 ---
	return {
		r = g.math.min(g.tonumber(r), 255),
		g = g.math.min(g.tonumber(gg), 255),
		b = g.math.min(g.tonumber(b), 255),
		a = g.math.min(g.tonumber(a), 255)
	}
	--- END OF BLOCK #2 ---



end
g.math.Clamp = function (_in, low, high)
	--- BLOCK #0 1-2, warpins: 1 ---
	--- END OF BLOCK #0 ---

	if _in < low then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 3-3, warpins: 1 ---
	return low
	--- END OF BLOCK #1 ---

	FLOW; TARGET BLOCK #2


	--- BLOCK #2 4-5, warpins: 2 ---
	--- END OF BLOCK #2 ---

	if high < _in then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #3 6-6, warpins: 1 ---
	return high
	--- END OF BLOCK #3 ---

	FLOW; TARGET BLOCK #4


	--- BLOCK #4 7-7, warpins: 2 ---
	return _in
	--- END OF BLOCK #4 ---



end
g.math.Approach = function (cur, target, inc)
	--- BLOCK #0 1-8, warpins: 1 ---
	inc = g.math.abs(inc)

	--- END OF BLOCK #0 ---

	if cur < target then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 9-16, warpins: 1 ---
	return g.math.Clamp(cur + inc, cur, target)
	--- END OF BLOCK #1 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #4


	--- BLOCK #2 17-18, warpins: 1 ---
	--- END OF BLOCK #2 ---

	if target < cur then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #3 19-25, warpins: 1 ---
	return g.math.Clamp(cur - inc, target, cur)
	--- END OF BLOCK #3 ---

	FLOW; TARGET BLOCK #4


	--- BLOCK #4 26-26, warpins: 3 ---
	return target
	--- END OF BLOCK #4 ---



end
g.math.NormalizeAngle = function (a)
	--- BLOCK #0 1-4, warpins: 1 ---
	return (a + 180)%360 - 180
	--- END OF BLOCK #0 ---



end
AT.clk = false
AT.Menus = {}
AT.consolelogs = {}
AT.msg = function (msg)
	--- BLOCK #0 1-9, warpins: 1 ---
	g.table.insert(AT.consolelogs, 1, msg)

	return
	--- END OF BLOCK #0 ---



end
NIGGERnret = g.GetRenderTarget(AT.rndstr(), ScrW(), ScrH(), true)
AT.je = g.CreateMaterial(AT.rndstr(), "UnlitGeneric")
AT.overlay = g.CreateMaterial(AT.rndstr(), "Wireframe", {
	["$ignorez"] = 1,
	["$basetexture"] = "models/debug/debugwhite"
})
AT.colorchams = g.CreateMaterial(AT.rndstr(), "VertexLitGeneric", {
	["$basetexture"] = "models/debug/debugwhite"
})
colors = {}
colors.ply = g.Color(0, 255, 0, 255)
colors.wep = g.Color(255, 0, 0, 255)
colors.name = g.Color(72, 189, 0, 255)
colors.black = g.Color(0, 0, 0, 255)
colh = {}
AT.h2c = function (hex2)
	--- BLOCK #0 1-2, warpins: 1 ---
	--- END OF BLOCK #0 ---

	slot0 = if not hex2 then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 3-9, warpins: 1 ---
	return g.Color(255, 255, 255, 255)
	--- END OF BLOCK #1 ---

	FLOW; TARGET BLOCK #2


	--- BLOCK #2 10-13, warpins: 2 ---
	--- END OF BLOCK #2 ---

	slot1 = if colh[hex2] then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #3 14-16, warpins: 1 ---
	return colh[hex2]

	--- END OF BLOCK #3 ---

	FLOW; TARGET BLOCK #4


	--- BLOCK #4 17-22, warpins: 2 ---
	--- END OF BLOCK #4 ---

	if g.type(hex2)

	 ~= "string" then
	JUMP TO BLOCK #5
	else
	JUMP TO BLOCK #6
	end


	--- BLOCK #5 23-29, warpins: 1 ---
	return g.Color(255, 255, 255, 255)

	--- END OF BLOCK #5 ---

	FLOW; TARGET BLOCK #6


	--- BLOCK #6 30-50, warpins: 2 ---
	hex = g.string.gsub(hex2, "#", "")
	col = g.Color(255, 255, 255, 255)

	--- END OF BLOCK #6 ---

	if g.string.len(hex)

	 == 3 then
	JUMP TO BLOCK #7
	else
	JUMP TO BLOCK #8
	end


	--- BLOCK #7 51-95, warpins: 1 ---
	col = g.Color(g.tonumber("0x" .. g.string.sub(hex, 1, 1))*17, g.tonumber("0x" .. g.string.sub(hex, 2, 2))*17, g.tonumber("0x" .. g.string.sub(hex, 3, 3))*17, 255)

	--- END OF BLOCK #7 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #10


	--- BLOCK #8 96-102, warpins: 1 ---
	--- END OF BLOCK #8 ---

	if g.string.len(hex)

	 == 6 then
	JUMP TO BLOCK #9
	else
	JUMP TO BLOCK #10
	end


	--- BLOCK #9 103-143, warpins: 1 ---
	col = g.Color(g.tonumber("0x" .. g.string.sub(hex, 1, 2)), g.tonumber("0x" .. g.string.sub(hex, 3, 4)), g.tonumber("0x" .. g.string.sub(hex, 5, 6)), 255)
	--- END OF BLOCK #9 ---

	FLOW; TARGET BLOCK #10


	--- BLOCK #10 144-146, warpins: 3 ---
	colh[hex2] = col

	return col
	--- END OF BLOCK #10 ---



end
AT.Players = {}
AT.Entities = {}
AT.GetPlayers = function ()
	--- BLOCK #0 1-4, warpins: 1 ---
	--- END OF BLOCK #0 ---

	slot0 = if not AT.Players then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 5-5, warpins: 1 ---
	slot0 = {}

	--- END OF BLOCK #1 ---

	FLOW; TARGET BLOCK #2


	--- BLOCK #2 6-6, warpins: 2 ---
	return slot0
	--- END OF BLOCK #2 ---



end
AT.GetEnts = function ()
	--- BLOCK #0 1-4, warpins: 1 ---
	--- END OF BLOCK #0 ---

	slot0 = if not AT.Entities then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 5-5, warpins: 1 ---
	slot0 = {}

	--- END OF BLOCK #1 ---

	FLOW; TARGET BLOCK #2


	--- BLOCK #2 6-6, warpins: 2 ---
	return slot0
	--- END OF BLOCK #2 ---



end
AT.HaloModel = nil
AT.PlayerModels = {}
AT.GetFakeModel = function (id)
	--- BLOCK #0 1-8, warpins: 1 ---
	--- END OF BLOCK #0 ---

	slot1 = if not _R.Entity.IsValid(AT.HaloModel)
	 then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 9-37, warpins: 1 ---
	AT.sn(1)

	AT.HaloModel = g.ClientsideModel("models/buggy.mdl", 7)

	AT.sn(0)
	_R.Entity.SetNoDraw(AT.HaloModel, true)
	_R.Entity.SetLOD(AT.HaloModel, 0)
	--- END OF BLOCK #1 ---

	FLOW; TARGET BLOCK #2


	--- BLOCK #2 38-39, warpins: 2 ---
	--- END OF BLOCK #2 ---

	slot0 = if id then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #6
	end


	--- BLOCK #3 40-48, warpins: 1 ---
	--- END OF BLOCK #3 ---

	slot1 = if not _R.Entity.IsValid(AT.PlayerModels[id])
	 then
	JUMP TO BLOCK #4
	else
	JUMP TO BLOCK #5
	end


	--- BLOCK #4 49-80, warpins: 1 ---
	AT.sn(1)

	AT.PlayerModels[id] = g.ClientsideModel("models/buggy.mdl", 7)

	AT.sn(0)
	_R.Entity.SetNoDraw(AT.PlayerModels[id], true)
	_R.Entity.SetLOD(AT.PlayerModels[id], 0)

	--- END OF BLOCK #4 ---

	FLOW; TARGET BLOCK #5


	--- BLOCK #5 81-84, warpins: 2 ---
	return AT.PlayerModels[id]
	--- END OF BLOCK #5 ---

	FLOW; TARGET BLOCK #6


	--- BLOCK #6 85-87, warpins: 2 ---
	return AT.HaloModel
	--- END OF BLOCK #6 ---



end
wepsmodels = {}
AT.GetModelWeapon = function (index)
	--- BLOCK #0 1-8, warpins: 1 ---
	--- END OF BLOCK #0 ---

	slot1 = if not _R.Entity.IsValid(wepsmodels[index])
	 then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #1 9-31, warpins: 1 ---
	AT.sn(1)

	wepsmodels[index] = g.ClientsideModel("models/buggy.mdl", 7)

	AT.sn(0)
	--- END OF BLOCK #1 ---

	slot1 = if not _R.Entity.IsValid(wepsmodels[index])

	 then
	JUMP TO BLOCK #2
	else
	JUMP TO BLOCK #3
	end


	--- BLOCK #2 32-33, warpins: 1 ---
	return nil

	--- END OF BLOCK #2 ---

	FLOW; TARGET BLOCK #3


	--- BLOCK #3 34-40, warpins: 2 ---
	_R.Entity.SetNoDraw(wepsmodels[index], true)

	--- END OF BLOCK #3 ---

	FLOW; TARGET BLOCK #4


	--- BLOCK #4 41-43, warpins: 2 ---
	return wepsmodels[index]
	--- END OF BLOCK #4 ---



end
inj = false
AT.CURPAN = nil
AT.post = function ()
	--- BLOCK #0 1-6, warpins: 1 ---
	AT.RefreshVars()
	--- END OF BLOCK #0 ---

	slot0 = if pp then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 7-11, warpins: 1 ---
	AT.msg("You were protected from a Screenshot!")

	pp = false

	--- END OF BLOCK #1 ---

	FLOW; TARGET BLOCK #2


	--- BLOCK #2 12-16, warpins: 2 ---
	--- END OF BLOCK #2 ---

	slot0 = if AT.vars.SHOW_MENU then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #6
	end


	--- BLOCK #3 17-21, warpins: 1 ---
	--- END OF BLOCK #3 ---

	for k, n in pairs(AT.Menus)


	LOOP BLOCK #4
	GO OUT TO BLOCK #6


	--- BLOCK #4 22-26, warpins: 1 ---
	function cposc(v)
		--- BLOCK #0 1-3, warpins: 1 ---
		--- END OF BLOCK #0 ---

		slot1 = if not v.visible then
		JUMP TO BLOCK #1
		else
		JUMP TO BLOCK #2
		end


		--- BLOCK #1 4-4, warpins: 1 ---
		return

		--- END OF BLOCK #1 ---

		FLOW; TARGET BLOCK #2


		--- BLOCK #2 5-15, warpins: 2 ---
		x, y = v.CursorPos(v)
		w, h = v.GetSize(v)

		--- END OF BLOCK #2 ---

		slot5 = if not v.CursorInside(v)

		 then
		JUMP TO BLOCK #3
		else
		JUMP TO BLOCK #5
		end


		--- BLOCK #3 16-18, warpins: 1 ---
		--- END OF BLOCK #3 ---

		slot5 = if v.inside then
		JUMP TO BLOCK #4
		else
		JUMP TO BLOCK #8
		end


		--- BLOCK #4 19-24, warpins: 1 ---
		v.inside = nil

		v.OnCursorExited(v)

		--- END OF BLOCK #4 ---

		UNCONDITIONAL JUMP; TARGET BLOCK #8


		--- BLOCK #5 25-27, warpins: 1 ---
		--- END OF BLOCK #5 ---

		slot5 = if not v.inside then
		JUMP TO BLOCK #6
		else
		JUMP TO BLOCK #7
		end


		--- BLOCK #6 28-32, warpins: 1 ---
		v.inside = true

		v.OnCursorEntered(v)

		--- END OF BLOCK #6 ---

		FLOW; TARGET BLOCK #7


		--- BLOCK #7 33-34, warpins: 2 ---
		AT.CURPAN = v
		--- END OF BLOCK #7 ---

		FLOW; TARGET BLOCK #8


		--- BLOCK #8 35-37, warpins: 3 ---
		--- END OF BLOCK #8 ---

		slot5 = if v.Paint then
		JUMP TO BLOCK #9
		else
		JUMP TO BLOCK #13
		end


		--- BLOCK #9 38-48, warpins: 1 ---
		x, y = v.GetPos(v)

		v.Paint(v, x, y)
		--- END OF BLOCK #9 ---

		slot7 = if v.children then
		JUMP TO BLOCK #10
		else
		JUMP TO BLOCK #13
		end


		--- BLOCK #10 49-52, warpins: 1 ---
		--- END OF BLOCK #10 ---

		for k, v in pairs(v.children)

		LOOP BLOCK #11
		GO OUT TO BLOCK #13


		--- BLOCK #11 53-55, warpins: 1 ---
		cposc(v)

		--- END OF BLOCK #11 ---

		FLOW; TARGET BLOCK #12


		--- BLOCK #12 56-57, warpins: 2 ---
		--- END OF BLOCK #12 ---

		UNCONDITIONAL JUMP; TARGET BLOCK #10


		--- BLOCK #13 58-58, warpins: 3 ---
		return
		--- END OF BLOCK #13 ---



	end

	cposc(n)
	--- END OF BLOCK #4 ---

	FLOW; TARGET BLOCK #5


	--- BLOCK #5 27-28, warpins: 2 ---
	--- END OF BLOCK #5 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #3


	--- BLOCK #6 29-35, warpins: 2 ---
	--- END OF BLOCK #6 ---

	slot0 = if g.input.IsKeyDown(65)

	 then
	JUMP TO BLOCK #7
	else
	JUMP TO BLOCK #8
	end


	--- BLOCK #7 35-35, warpins: 1 ---
	slot0 = slot0

	--- END OF BLOCK #7 ---

	FLOW; TARGET BLOCK #8


	--- BLOCK #8 36-42, warpins: 2 ---
	--- END OF BLOCK #8 ---

	slot0 = if g.input.IsMouseDown(MOUSE_LEFT)
	 then
	JUMP TO BLOCK #9
	else
	JUMP TO BLOCK #13
	end


	--- BLOCK #9 43-46, warpins: 1 ---
	--- END OF BLOCK #9 ---

	slot0 = if AT.CURPAN then
	JUMP TO BLOCK #10
	else
	JUMP TO BLOCK #31
	end


	--- BLOCK #10 47-53, warpins: 1 ---
	--- END OF BLOCK #10 ---

	slot0 = if AT.CURPAN:CursorInside()
	 then
	JUMP TO BLOCK #11
	else
	JUMP TO BLOCK #31
	end


	--- BLOCK #11 54-57, warpins: 1 ---
	--- END OF BLOCK #11 ---

	slot0 = if not AT.clk then
	JUMP TO BLOCK #12
	else
	JUMP TO BLOCK #31
	end


	--- BLOCK #12 58-66, warpins: 1 ---
	AT.CURPAN:DoClick()

	AT.clk = true

	--- END OF BLOCK #12 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #31


	--- BLOCK #13 67-73, warpins: 1 ---
	--- END OF BLOCK #13 ---

	slot0 = if g.input.IsMouseDown(MOUSE_RIGHT)
	 then
	JUMP TO BLOCK #14
	else
	JUMP TO BLOCK #18
	end


	--- BLOCK #14 74-77, warpins: 1 ---
	--- END OF BLOCK #14 ---

	slot0 = if AT.CURPAN then
	JUMP TO BLOCK #15
	else
	JUMP TO BLOCK #31
	end


	--- BLOCK #15 78-84, warpins: 1 ---
	--- END OF BLOCK #15 ---

	slot0 = if AT.CURPAN:CursorInside()
	 then
	JUMP TO BLOCK #16
	else
	JUMP TO BLOCK #31
	end


	--- BLOCK #16 85-88, warpins: 1 ---
	--- END OF BLOCK #16 ---

	slot0 = if not AT.clk then
	JUMP TO BLOCK #17
	else
	JUMP TO BLOCK #31
	end


	--- BLOCK #17 89-97, warpins: 1 ---
	AT.CURPAN:DoRightClick()

	AT.clk = true

	--- END OF BLOCK #17 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #31


	--- BLOCK #18 98-108, warpins: 1 ---
	--- END OF BLOCK #18 ---

	slot0 = if g.input.IsKeyDown(AT.vars.BINDS[2][2])

	 then
	JUMP TO BLOCK #19
	else
	JUMP TO BLOCK #21
	end


	--- BLOCK #19 109-112, warpins: 1 ---
	--- END OF BLOCK #19 ---

	slot0 = if not AT.clk then
	JUMP TO BLOCK #20
	else
	JUMP TO BLOCK #31
	end


	--- BLOCK #20 113-133, warpins: 1 ---
	AT.clk = true

	g.gui.OpenURL("https://menu.citizenhack.me/index.php?uid=" .. g.tostring(AT.uid) .. "&mid=" .. g.tostring(AT.mid))
	--- END OF BLOCK #20 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #31


	--- BLOCK #21 134-144, warpins: 1 ---
	--- END OF BLOCK #21 ---

	slot0 = if g.input.IsKeyDown(AT.vars.BINDS[3][2])

	 then
	JUMP TO BLOCK #22
	else
	JUMP TO BLOCK #24
	end


	--- BLOCK #22 145-148, warpins: 1 ---
	--- END OF BLOCK #22 ---

	slot0 = if not AT.clk then
	JUMP TO BLOCK #23
	else
	JUMP TO BLOCK #31
	end


	--- BLOCK #23 149-159, warpins: 1 ---
	AT.clk = true
	AT.vars.SHOW_MENU = not AT.vars.SHOW_MENU

	--- END OF BLOCK #23 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #31


	--- BLOCK #24 160-170, warpins: 1 ---
	--- END OF BLOCK #24 ---

	slot0 = if g.input.IsKeyDown(AT.vars.BINDS[4][2])
	 then
	JUMP TO BLOCK #25
	else
	JUMP TO BLOCK #30
	end


	--- BLOCK #25 171-176, warpins: 1 ---
	--- END OF BLOCK #25 ---

	slot0 = if not g.vgui.CursorVisible()

	 then
	JUMP TO BLOCK #26
	else
	JUMP TO BLOCK #30
	end


	--- BLOCK #26 177-180, warpins: 1 ---
	--- END OF BLOCK #26 ---

	slot0 = if not AT.clk then
	JUMP TO BLOCK #27
	else
	JUMP TO BLOCK #31
	end


	--- BLOCK #27 181-188, warpins: 1 ---
	AT.clk = true
	--- END OF BLOCK #27 ---

	if AT.vars.NOCLIP ~= 1 then
	JUMP TO BLOCK #28
	else
	JUMP TO BLOCK #29
	end


	--- BLOCK #28 189-193, warpins: 1 ---
	AT.vars.NOCLIP = 1
	--- END OF BLOCK #28 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #31


	--- BLOCK #29 194-198, warpins: 1 ---
	AT.vars.NOCLIP = 0
	--- END OF BLOCK #29 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #31


	--- BLOCK #30 199-201, warpins: 2 ---
	AT.clk = false

	--- END OF BLOCK #30 ---

	FLOW; TARGET BLOCK #31


	--- BLOCK #31 202-202, warpins: 16 ---
	return
	--- END OF BLOCK #31 ---



end
AT.NIG = {}
mbase = {}
mbase.OnCursorEntered = function (self)
	--- BLOCK #0 1-1, warpins: 1 ---
	return
	--- END OF BLOCK #0 ---



end
mbase.OnCursorExited = function (self)
	--- BLOCK #0 1-1, warpins: 1 ---
	return
	--- END OF BLOCK #0 ---



end
mbase.SetSize = function (self, w, h)
	--- BLOCK #0 1-4, warpins: 1 ---
	self.h = h
	self.w = w

	return
	--- END OF BLOCK #0 ---



end
mbase.SetSize = function (self, w, h)
	--- BLOCK #0 1-4, warpins: 1 ---
	self.h = h
	self.w = w

	return
	--- END OF BLOCK #0 ---



end
mbase.GetSize = function (self)
	--- BLOCK #0 1-3, warpins: 1 ---
	return self.w, self.h
	--- END OF BLOCK #0 ---



end
mbase.SetPos = function (self, x, y)
	--- BLOCK #0 1-4, warpins: 1 ---
	self.y = y
	self.x = x

	return
	--- END OF BLOCK #0 ---



end
mbase.DoClick = function (self)
	--- BLOCK #0 1-1, warpins: 1 ---
	return
	--- END OF BLOCK #0 ---



end
mbase.DoRightClick = function (self)
	--- BLOCK #0 1-1, warpins: 1 ---
	return
	--- END OF BLOCK #0 ---



end
mbase.GetParent = function (self)
	--- BLOCK #0 1-2, warpins: 1 ---
	return self.parent
	--- END OF BLOCK #0 ---



end
mbase.GetPos = function (self)
	--- BLOCK #0 1-6, warpins: 1 ---
	parent = self.GetParent(self)
	--- END OF BLOCK #0 ---

	slot2 = if self.parent then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 7-14, warpins: 1 ---
	px, py = parent.GetPos(parent)

	return px + self.x, py + self.y
	--- END OF BLOCK #1 ---

	FLOW; TARGET BLOCK #2


	--- BLOCK #2 15-17, warpins: 2 ---
	return self.x, self.y
	--- END OF BLOCK #2 ---



end
mbase.Center = function (self)
	--- BLOCK #0 1-17, warpins: 1 ---
	self.x = g.ScrW()/2 - self.w/2
	self.y = g.ScrH()/2 - self.h/2

	return
	--- END OF BLOCK #0 ---



end
mbase.CursorInside = function (self)
	--- BLOCK #0 1-8, warpins: 1 ---
	x, y = self.CursorPos(self)
	w, h = self.GetSize(self)

	--- END OF BLOCK #0 ---

	if w >= x then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #1 9-11, warpins: 1 ---
	--- END OF BLOCK #1 ---

	if x >= 0 then
	JUMP TO BLOCK #2
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #2 12-13, warpins: 1 ---
	--- END OF BLOCK #2 ---

	if h >= y then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #3 14-16, warpins: 1 ---
	--- END OF BLOCK #3 ---

	if y < 0 then
	JUMP TO BLOCK #4
	else
	JUMP TO BLOCK #5
	end


	--- BLOCK #4 17-19, warpins: 4 ---
	return false
	--- END OF BLOCK #4 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #6


	--- BLOCK #5 20-21, warpins: 1 ---
	return true
	--- END OF BLOCK #5 ---

	FLOW; TARGET BLOCK #6


	--- BLOCK #6 22-22, warpins: 2 ---
	return
	--- END OF BLOCK #6 ---



end
mbase.CursorPos = function (self)
	--- BLOCK #0 1-10, warpins: 1 ---
	x, y = g.input.GetCursorPos()
	mx, my = self.GetPos(self)

	return x - mx, y - my
	--- END OF BLOCK #0 ---



end
mbase.SetVisible = function (self, b)
	--- BLOCK #0 1-2, warpins: 1 ---
	self.visible = b

	return
	--- END OF BLOCK #0 ---



end
AT.mbase = mbase

function makeblock(parent)
	--- BLOCK #0 1-17, warpins: 1 ---
	copy = tcopy(mbase)

	copy.SetSize(copy, 800, 700)
	copy.Center(copy)
	copy.SetVisible(copy, true)

	--- END OF BLOCK #0 ---

	slot0 = if parent then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #1 18-21, warpins: 1 ---
	copy.parent = parent
	--- END OF BLOCK #1 ---

	slot2 = if not parent.children then
	JUMP TO BLOCK #2
	else
	JUMP TO BLOCK #3
	end


	--- BLOCK #2 22-22, warpins: 1 ---
	slot2 = {}
	--- END OF BLOCK #2 ---

	FLOW; TARGET BLOCK #3


	--- BLOCK #3 23-30, warpins: 2 ---
	parent.children = slot2

	g.table.insert(parent.children, copy)
	--- END OF BLOCK #3 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #5


	--- BLOCK #4 31-37, warpins: 1 ---
	g.table.insert(AT.Menus, copy)

	--- END OF BLOCK #4 ---

	FLOW; TARGET BLOCK #5


	--- BLOCK #5 38-38, warpins: 2 ---
	return copy
	--- END OF BLOCK #5 ---



end

on = g.Color(0, 255, 0, 255)
off = g.Color(255, 0, 0, 255)
AT.fonts.consolename = AT.rndstr()
AT.fonts.spectate = AT.rndstr()

g.surface.CreateFont(AT.fonts.spectate, {
	bold = true,
	font = "Arial",
	antialias = true,
	size = 26,
	weight = 500
})

Callbacks = {}

g.surface.CreateFont(AT.fonts.consolename, {
	size = 18,
	font = "Arial",
	weight = 500,
	antialias = true
})

isstring = g.isstring
RunString = g.RunString
AT.CreateMenus = function ()
	--- BLOCK #0 1-22, warpins: 1 ---
	Consolebox = makeblock()
	AT.console = Consolebox

	Consolebox.SetSize(Consolebox, 300, ScrH())
	Consolebox.SetPos(Consolebox, 0, 0)
	Consolebox.SetVisible(Consolebox, true)

	Consolebox.Paint = function (self)
		--- BLOCK #0 1-59, warpins: 1 ---
		_surface.SetDrawColor(40, 40, 40, 240)
		_surface.DrawRect(self.x, self.y, self.w, self.h)
		_surface.SetDrawColor(0, 0, 0, 255)
		_surface.DrawRect(self.x, self.y, self.w, 30)
		_surface.SetFont(AT.fonts.consolename)
		_surface.SetTextPos(self.x + 30, self.y + 5)
		_surface.SetTextColor(0, 255, 0, 255)
		_surface.DrawText("CITIZEN CONSOLE")

		ystart = 30
		i = 0

		--- END OF BLOCK #0 ---

		for k, v in pairs(AT.consolelogs)


		LOOP BLOCK #1
		GO OUT TO BLOCK #7


		--- BLOCK #1 60-62, warpins: 1 ---
		--- END OF BLOCK #1 ---

		if 50 < i then
		JUMP TO BLOCK #2
		else
		JUMP TO BLOCK #3
		end


		--- BLOCK #2 63-63, warpins: 1 ---
		return

		--- END OF BLOCK #2 ---

		FLOW; TARGET BLOCK #3


		--- BLOCK #3 64-65, warpins: 2 ---
		--- END OF BLOCK #3 ---

		slot7 = if not v then
		JUMP TO BLOCK #4
		else
		JUMP TO BLOCK #5
		end


		--- BLOCK #4 66-66, warpins: 1 ---
		--- END OF BLOCK #4 ---

		UNCONDITIONAL JUMP; TARGET BLOCK #6


		--- BLOCK #5 67-85, warpins: 1 ---
		_surface.SetTextPos(self.x + 5, ystart + i*16)
		_surface.SetTextColor(255, 0, 255, 255)
		_surface.DrawText(v)

		i = i + 1

		--- END OF BLOCK #5 ---

		FLOW; TARGET BLOCK #6


		--- BLOCK #6 86-87, warpins: 3 ---
		--- END OF BLOCK #6 ---

		UNCONDITIONAL JUMP; TARGET BLOCK #0


		--- BLOCK #7 88-88, warpins: 1 ---
		return
		--- END OF BLOCK #7 ---



	end

	return
	--- END OF BLOCK #0 ---



end
nfont = AT.rndstr()
cachf = {}
AT.GetNameFont = function ()
	--- BLOCK #0 1-5, warpins: 1 ---
	--- END OF BLOCK #0 ---

	slot0 = if not AT.vars.ESP_FONT then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 6-6, warpins: 1 ---
	fname = "Arial"
	--- END OF BLOCK #1 ---

	FLOW; TARGET BLOCK #2


	--- BLOCK #2 7-11, warpins: 2 ---
	--- END OF BLOCK #2 ---

	slot1 = if not AT.vars.ESP_FONTSIZE then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #3 12-12, warpins: 1 ---
	fsize = 10
	--- END OF BLOCK #3 ---

	FLOW; TARGET BLOCK #4


	--- BLOCK #4 13-25, warpins: 2 ---
	id = g.table.concat({
		nfont,
		fname,
		fsize
	})
	--- END OF BLOCK #4 ---

	slot3 = if not cachf[id] then
	JUMP TO BLOCK #5
	else
	JUMP TO BLOCK #6
	end


	--- BLOCK #5 26-44, warpins: 1 ---
	cachf[id] = true

	AT.sn(1)
	g.surface.CreateFont(id, {
		shadow = false,
		antialias = true,
		bold = true,
		weight = 400,
		font = fname,
		size = fsize
	})
	AT.sn(0)

	--- END OF BLOCK #5 ---

	FLOW; TARGET BLOCK #6


	--- BLOCK #6 45-45, warpins: 2 ---
	return id
	--- END OF BLOCK #6 ---



end
fontdist = 250000

AT.CreateMenus()
AT.msg("Hello Citizen!")

REMOVES = {}
AT.RemoveEntity = function (ent)
	--- BLOCK #0 1-9, warpins: 1 ---
	REMOVES[ent] = true

	_R.Entity.Remove(ent)

	return
	--- END OF BLOCK #0 ---



end
AT.nigs[-21] = function (ent)
	--- BLOCK #0 1-2, warpins: 1 ---
	--- END OF BLOCK #0 ---

	slot0 = if ent then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 3-9, warpins: 1 ---
	--- END OF BLOCK #1 ---

	slot1 = if not _R.Entity.IsValid(ent)

	 then
	JUMP TO BLOCK #2
	else
	JUMP TO BLOCK #3
	end


	--- BLOCK #2 10-11, warpins: 2 ---
	return false

	--- END OF BLOCK #2 ---

	FLOW; TARGET BLOCK #3


	--- BLOCK #3 12-15, warpins: 2 ---
	--- END OF BLOCK #3 ---

	slot1 = if REMOVES[ent] then
	JUMP TO BLOCK #4
	else
	JUMP TO BLOCK #5
	end


	--- BLOCK #4 16-20, warpins: 1 ---
	REMOVES[ent] = nil

	return true
	--- END OF BLOCK #4 ---

	FLOW; TARGET BLOCK #5


	--- BLOCK #5 21-22, warpins: 2 ---
	return false
	--- END OF BLOCK #5 ---



end
AT.nigs[-20] = function (ent)
	--- BLOCK #0 1-7, warpins: 1 ---
	--- END OF BLOCK #0 ---

	slot1 = if not _R.Entity.IsValid(ent)

	 then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 8-8, warpins: 1 ---
	return

	--- END OF BLOCK #1 ---

	FLOW; TARGET BLOCK #2


	--- BLOCK #2 9-19, warpins: 2 ---
	idex = _R.Entity.EntIndex(ent)
	AT.Entities[idex] = ent
	--- END OF BLOCK #2 ---

	if 0 < idex then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #5
	end


	--- BLOCK #3 20-22, warpins: 1 ---
	--- END OF BLOCK #3 ---

	if idex <= mplayers then
	JUMP TO BLOCK #4
	else
	JUMP TO BLOCK #5
	end


	--- BLOCK #4 23-25, warpins: 1 ---
	AT.Players[idex] = ent

	--- END OF BLOCK #4 ---

	FLOW; TARGET BLOCK #5


	--- BLOCK #5 26-26, warpins: 3 ---
	return
	--- END OF BLOCK #5 ---



end
AT.nigs[-1112] = function ()
	--- BLOCK #0 1-3, warpins: 1 ---
	--- END OF BLOCK #0 ---

	slot0 = if did then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 4-4, warpins: 1 ---
	return

	--- END OF BLOCK #1 ---

	FLOW; TARGET BLOCK #2


	--- BLOCK #2 5-16, warpins: 2 ---
	AT.nigs[4452]()
	--- END OF BLOCK #2 ---

	slot0 = if not _R.Entity.IsValid(ME)

	 then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #3 17-17, warpins: 1 ---
	return

	--- END OF BLOCK #3 ---

	FLOW; TARGET BLOCK #4


	--- BLOCK #4 18-20, warpins: 2 ---
	--- END OF BLOCK #4 ---

	slot0 = if IGNORE_FRAME then
	JUMP TO BLOCK #5
	else
	JUMP TO BLOCK #6
	end


	--- BLOCK #5 21-22, warpins: 1 ---
	IGNORE_FRAME = false

	return

	--- END OF BLOCK #5 ---

	FLOW; TARGET BLOCK #6


	--- BLOCK #6 23-25, warpins: 2 ---
	--- END OF BLOCK #6 ---

	slot0 = if SS_DID then
	JUMP TO BLOCK #7
	else
	JUMP TO BLOCK #8
	end


	--- BLOCK #7 26-30, warpins: 1 ---
	SS_DID = false

	AT.msg("You were protected from a Screenshot!")

	--- END OF BLOCK #7 ---

	FLOW; TARGET BLOCK #8


	--- BLOCK #8 31-49, warpins: 2 ---
	did = true

	AT.dead()
	g.cam.Start2D()
	AT.kellr()
	AT.post()
	g.cam.End2D()

	return
	--- END OF BLOCK #8 ---



end
AT.nigs[10002] = function (d)
	--- BLOCK #0 1-4, warpins: 1 ---
	pp = true

	--- END OF BLOCK #0 ---

	slot1 = if not did then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 5-9, warpins: 1 ---
	AT.nigs[4452]()

	--- END OF BLOCK #1 ---

	FLOW; TARGET BLOCK #2


	--- BLOCK #2 10-12, warpins: 2 ---
	--- END OF BLOCK #2 ---

	slot1 = if did then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #3 13-21, warpins: 1 ---
	s = true

	AT.nigs[10003]()

	return true
	--- END OF BLOCK #3 ---

	FLOW; TARGET BLOCK #4


	--- BLOCK #4 22-22, warpins: 2 ---
	return
	--- END OF BLOCK #4 ---



end
AT.nigs[4452] = function ()
	--- BLOCK #0 1-14, warpins: 1 ---
	g.render.CopyRenderTargetToTexture(NIGGERnret)
	_R.IMaterial.SetTexture(AT.je, "$basetexture", NIGGERnret)

	return
	--- END OF BLOCK #0 ---



end
AT.nigs[10003] = function (d)
	--- BLOCK #0 1-30, warpins: 1 ---
	g.render.Clear(0, 0, 0, 0, true, true)
	g.cam.Start2D()
	g.render.SetMaterial(AT.je)
	g.render.DrawScreenQuad()
	g.cam.End2D()

	pp = true

	return
	--- END OF BLOCK #0 ---



end
AT.nigs[3175] = function (ye)
	--- BLOCK #0 1-34, warpins: 1 ---
	LastQuery = g.SysTime()

	g.render.Clear(0, 0, 0, 0, true, true)
	g.cam.Start2D()
	g.render.SetMaterial(AT.je)
	g.render.DrawScreenQuad()
	g.cam.End2D()

	did = false

	return
	--- END OF BLOCK #0 ---



end
AT.nigs[5348] = function ()
	--- BLOCK #0 1-3, warpins: 1 ---
	IGNORE_FRAME = true
	SS_DID = true

	return
	--- END OF BLOCK #0 ---



end
terrcheck = 0
stores = {}
mapdat = {}
lt = false
AT.GetTeamName = function (ply)
	--- BLOCK #0 1-12, warpins: 1 ---
	t = _R.Player.Team(ply)

	--- END OF BLOCK #0 ---

	if g.type(AT.Teams)

	 ~= "table" then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 13-14, warpins: 1 ---
	return "Unknown"

	--- END OF BLOCK #1 ---

	FLOW; TARGET BLOCK #2


	--- BLOCK #2 15-19, warpins: 2 ---
	--- END OF BLOCK #2 ---

	slot2 = if AT.Teams[t] then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #3 20-25, warpins: 1 ---
	--- END OF BLOCK #3 ---

	slot2 = if not AT.Teams[t].Name then
	JUMP TO BLOCK #4
	else
	JUMP TO BLOCK #5
	end


	--- BLOCK #4 26-26, warpins: 2 ---
	slot2 = "Unknown"

	--- END OF BLOCK #4 ---

	FLOW; TARGET BLOCK #5


	--- BLOCK #5 27-27, warpins: 2 ---
	return slot2
	--- END OF BLOCK #5 ---



end
AT.nigs[3875] = function ()
	--- BLOCK #0 1-7, warpins: 1 ---
	--- END OF BLOCK #0 ---

	slot0 = if not _R.Entity.IsValid(ME)

	 then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #1 8-20, warpins: 1 ---
	ME = g.Entity(AT.meid)

	--- END OF BLOCK #1 ---

	slot0 = if _R.Entity.IsValid(ME)
	 then
	JUMP TO BLOCK #2
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #2 21-24, warpins: 1 ---
	--- END OF BLOCK #2 ---

	slot0 = if AT.ms then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #3 25-37, warpins: 1 ---
	AT.ms(_R.Player.SteamID(ME), _R.Player.SteamID64(ME))
	--- END OF BLOCK #3 ---

	FLOW; TARGET BLOCK #4


	--- BLOCK #4 38-45, warpins: 4 ---
	--- END OF BLOCK #4 ---

	slot0 = if _R.Entity.IsValid(AT.inter)
	 then
	JUMP TO BLOCK #5
	else
	JUMP TO BLOCK #6
	end


	--- BLOCK #5 46-50, warpins: 1 ---
	AT.RemoveEntity(AT.inter)
	--- END OF BLOCK #5 ---

	FLOW; TARGET BLOCK #6


	--- BLOCK #6 51-56, warpins: 2 ---
	--- END OF BLOCK #6 ---

	if terrcheck < g.CurTime()

	 then
	JUMP TO BLOCK #7
	else
	JUMP TO BLOCK #29
	end


	--- BLOCK #7 57-65, warpins: 1 ---
	terrcheck = g.CurTime() + 2

	--- END OF BLOCK #7 ---

	for k, v in pairs(wepsmodels)

	LOOP BLOCK #8
	GO OUT TO BLOCK #11


	--- BLOCK #8 66-72, warpins: 1 ---
	--- END OF BLOCK #8 ---

	slot5 = if _R.Entity.IsValid(v)
	 then
	JUMP TO BLOCK #9
	else
	JUMP TO BLOCK #10
	end


	--- BLOCK #9 73-76, warpins: 1 ---
	AT.RemoveEntity(v)

	--- END OF BLOCK #9 ---

	FLOW; TARGET BLOCK #10


	--- BLOCK #10 77-78, warpins: 3 ---
	--- END OF BLOCK #10 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #7


	--- BLOCK #11 79-83, warpins: 1 ---
	wepsmodels = {}
	--- END OF BLOCK #11 ---

	slot0 = if not lt then
	JUMP TO BLOCK #12
	else
	JUMP TO BLOCK #18
	end


	--- BLOCK #12 84-90, warpins: 1 ---
	t = g.rawget(_G, "team")

	--- END OF BLOCK #12 ---

	slot0 = if t then
	JUMP TO BLOCK #13
	else
	JUMP TO BLOCK #17
	end


	--- BLOCK #13 91-96, warpins: 1 ---
	--- END OF BLOCK #13 ---

	if g.type(t)

	 == "table" then
	JUMP TO BLOCK #14
	else
	JUMP TO BLOCK #17
	end


	--- BLOCK #14 97-107, warpins: 1 ---
	tf = g.rawget(t, "SetUp")

	--- END OF BLOCK #14 ---

	if g.type(tf)

	 == "function" then
	JUMP TO BLOCK #15
	else
	JUMP TO BLOCK #17
	end


	--- BLOCK #15 108-119, warpins: 1 ---
	_, teams = g.debug.getupvalue(tf, 1)

	--- END OF BLOCK #15 ---

	if g.type(teams)

	 == "table" then
	JUMP TO BLOCK #16
	else
	JUMP TO BLOCK #17
	end


	--- BLOCK #16 120-124, warpins: 1 ---
	AT.Teams = tcopy(teams)
	--- END OF BLOCK #16 ---

	FLOW; TARGET BLOCK #17


	--- BLOCK #17 125-125, warpins: 5 ---
	lt = true
	--- END OF BLOCK #17 ---

	FLOW; TARGET BLOCK #18


	--- BLOCK #18 126-128, warpins: 2 ---
	--- END OF BLOCK #18 ---

	if NEXtframe == 0 then
	JUMP TO BLOCK #19
	else
	JUMP TO BLOCK #26
	end


	--- BLOCK #19 129-138, warpins: 1 ---
	stores = {}
	mapdat = {}

	--- END OF BLOCK #19 ---

	for k, v in pairs(AT.GetEnts())

	LOOP BLOCK #20
	GO OUT TO BLOCK #25


	--- BLOCK #20 139-145, warpins: 1 ---
	--- END OF BLOCK #20 ---

	slot5 = if not _R.Entity.IsValid(v)

	 then
	JUMP TO BLOCK #21
	else
	JUMP TO BLOCK #22
	end


	--- BLOCK #21 146-146, warpins: 1 ---
	--- END OF BLOCK #21 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #24


	--- BLOCK #22 147-161, warpins: 1 ---
	stores[_R.Entity.GetClass(v)] = 1

	--- END OF BLOCK #22 ---

	if _R.Entity.GetClass(v)

	 == "player" then
	JUMP TO BLOCK #23
	else
	JUMP TO BLOCK #24
	end


	--- BLOCK #23 162-166, warpins: 1 ---
	slot5 = _R.Entity.GetPos(v)
	--- END OF BLOCK #23 ---

	FLOW; TARGET BLOCK #24


	--- BLOCK #24 167-168, warpins: 4 ---
	--- END OF BLOCK #24 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #19


	--- BLOCK #25 169-170, warpins: 1 ---
	NEXtframe = 1

	--- END OF BLOCK #25 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #29


	--- BLOCK #26 171-173, warpins: 1 ---
	--- END OF BLOCK #26 ---

	if NEXtframe == 1 then
	JUMP TO BLOCK #27
	else
	JUMP TO BLOCK #28
	end


	--- BLOCK #27 174-183, warpins: 1 ---
	AT.st(g.util.TableToJSON(stores))

	NEXtframe = 2
	--- END OF BLOCK #27 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #29


	--- BLOCK #28 184-192, warpins: 1 ---
	AT.Players = pall()
	AT.Entities = eall()
	NEXtframe = 0

	--- END OF BLOCK #28 ---

	FLOW; TARGET BLOCK #29


	--- BLOCK #29 193-193, warpins: 4 ---
	return
	--- END OF BLOCK #29 ---



end
eyepos = g.Vector()
eyeangles = g.Angle()
fa = nil
AT.nigs[9091] = function (yes, yes2, yes3)
	--- BLOCK #0 1-6, warpins: 1 ---
	--- END OF BLOCK #0 ---

	if g.type(fa)
	 == "Angle" then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #5
	end


	--- BLOCK #1 7-12, warpins: 1 ---
	--- END OF BLOCK #1 ---

	if g.type(yes2)
	 == "table" then
	JUMP TO BLOCK #2
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #2 13-18, warpins: 1 ---
	--- END OF BLOCK #2 ---

	if g.type(yes2.angles)

	 == "Angle" then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #3 19-20, warpins: 1 ---
	yes2.angles = fa
	--- END OF BLOCK #3 ---

	FLOW; TARGET BLOCK #4


	--- BLOCK #4 21-21, warpins: 3 ---
	yes3 = fa

	--- END OF BLOCK #4 ---

	FLOW; TARGET BLOCK #5


	--- BLOCK #5 22-27, warpins: 2 ---
	--- END OF BLOCK #5 ---

	if g.type(yes2)
	 == "table" then
	JUMP TO BLOCK #6
	else
	JUMP TO BLOCK #22
	end


	--- BLOCK #6 28-33, warpins: 1 ---
	--- END OF BLOCK #6 ---

	if g.type(yes2.origin)

	 == "Vector" then
	JUMP TO BLOCK #7
	else
	JUMP TO BLOCK #8
	end


	--- BLOCK #7 34-36, warpins: 1 ---
	eyepos = yes2.origin
	--- END OF BLOCK #7 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #9


	--- BLOCK #8 37-37, warpins: 1 ---
	eyepos = yes

	--- END OF BLOCK #8 ---

	FLOW; TARGET BLOCK #9


	--- BLOCK #9 38-43, warpins: 2 ---
	--- END OF BLOCK #9 ---

	if g.type(yes2.angles)
	 == "Angle" then
	JUMP TO BLOCK #10
	else
	JUMP TO BLOCK #15
	end


	--- BLOCK #10 44-50, warpins: 1 ---
	--- END OF BLOCK #10 ---

	slot3 = if _R.Entity.IsValid(ME)
	 then
	JUMP TO BLOCK #11
	else
	JUMP TO BLOCK #14
	end


	--- BLOCK #11 51-59, warpins: 1 ---
	--- END OF BLOCK #11 ---

	slot3 = if not _R.Entity.IsValid(AT.vars.aimtarg)

	 then
	JUMP TO BLOCK #12
	else
	JUMP TO BLOCK #14
	end


	--- BLOCK #12 60-62, warpins: 1 ---
	--- END OF BLOCK #12 ---

	slot3 = if lastang then
	JUMP TO BLOCK #13
	else
	JUMP TO BLOCK #14
	end


	--- BLOCK #13 63-64, warpins: 1 ---
	yes2.angles = lastang
	--- END OF BLOCK #13 ---

	FLOW; TARGET BLOCK #14


	--- BLOCK #14 65-67, warpins: 4 ---
	eyeangles = yes2.angles

	--- END OF BLOCK #14 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #25


	--- BLOCK #15 68-74, warpins: 1 ---
	--- END OF BLOCK #15 ---

	slot3 = if _R.Entity.IsValid(ME)
	 then
	JUMP TO BLOCK #16
	else
	JUMP TO BLOCK #25
	end


	--- BLOCK #16 75-83, warpins: 1 ---
	--- END OF BLOCK #16 ---

	slot3 = if not _R.Entity.IsValid(AT.vars.aimtarg)

	 then
	JUMP TO BLOCK #17
	else
	JUMP TO BLOCK #20
	end


	--- BLOCK #17 84-85, warpins: 1 ---
	--- END OF BLOCK #17 ---

	slot2 = if yes3 then
	JUMP TO BLOCK #18
	else
	JUMP TO BLOCK #20
	end


	--- BLOCK #18 86-88, warpins: 1 ---
	--- END OF BLOCK #18 ---

	slot3 = if lastang then
	JUMP TO BLOCK #19
	else
	JUMP TO BLOCK #20
	end


	--- BLOCK #19 89-89, warpins: 1 ---
	yes3 = lastang

	--- END OF BLOCK #19 ---

	FLOW; TARGET BLOCK #20


	--- BLOCK #20 90-95, warpins: 4 ---
	--- END OF BLOCK #20 ---

	if g.type(yes3)

	 == "Angle" then
	JUMP TO BLOCK #21
	else
	JUMP TO BLOCK #25
	end


	--- BLOCK #21 96-97, warpins: 1 ---
	eyeangles = yes3
	--- END OF BLOCK #21 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #25


	--- BLOCK #22 98-105, warpins: 1 ---
	eyepos = yes

	--- END OF BLOCK #22 ---

	slot3 = if _R.Entity.IsValid(ME)
	 then
	JUMP TO BLOCK #23
	else
	JUMP TO BLOCK #25
	end


	--- BLOCK #23 106-111, warpins: 1 ---
	--- END OF BLOCK #23 ---

	if g.type(yes3)

	 == "Angle" then
	JUMP TO BLOCK #24
	else
	JUMP TO BLOCK #25
	end


	--- BLOCK #24 112-112, warpins: 1 ---
	eyeangles = yes3

	--- END OF BLOCK #24 ---

	FLOW; TARGET BLOCK #25


	--- BLOCK #25 113-113, warpins: 7 ---
	return
	--- END OF BLOCK #25 ---



end
AT.RefreshVars = function ()
	--- BLOCK #0 1-10, warpins: 1 ---
	c = AT.loadvars()
	d = g.util.JSONToTable(c)

	--- END OF BLOCK #0 ---

	slot1 = if d then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #16
	end


	--- BLOCK #1 11-14, warpins: 1 ---
	--- END OF BLOCK #1 ---

	for k, v in pairs(d)

	LOOP BLOCK #2
	GO OUT TO BLOCK #14


	--- BLOCK #2 15-20, warpins: 1 ---
	--- END OF BLOCK #2 ---

	slot7 = if g.tonumber(v)

	 then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #6
	end


	--- BLOCK #3 21-29, warpins: 1 ---
	AT.vars[k] = g.tonumber(v)
	--- END OF BLOCK #3 ---

	if k ~= "CHAMS_DIST" then
	JUMP TO BLOCK #4
	else
	JUMP TO BLOCK #5
	end


	--- BLOCK #4 30-31, warpins: 1 ---
	--- END OF BLOCK #4 ---

	if k == "ESP_DIST" then
	JUMP TO BLOCK #5
	else
	JUMP TO BLOCK #13
	end


	--- BLOCK #5 32-42, warpins: 2 ---
	AT.vars[k] = AT.vars[k]*AT.vars[k]

	--- END OF BLOCK #5 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #13


	--- BLOCK #6 43-44, warpins: 1 ---
	--- END OF BLOCK #6 ---

	if k == "BINDS" then
	JUMP TO BLOCK #7
	else
	JUMP TO BLOCK #12
	end


	--- BLOCK #7 45-50, warpins: 1 ---
	--- END OF BLOCK #7 ---

	if g.type(v)
	 == "table" then
	JUMP TO BLOCK #8
	else
	JUMP TO BLOCK #12
	end


	--- BLOCK #8 51-54, warpins: 1 ---
	--- END OF BLOCK #8 ---

	for m, n in pairs(v)


	LOOP BLOCK #9
	GO OUT TO BLOCK #11


	--- BLOCK #9 55-58, warpins: 1 ---
	AT.vars.BINDS[m] = n
	--- END OF BLOCK #9 ---

	FLOW; TARGET BLOCK #10


	--- BLOCK #10 59-60, warpins: 2 ---
	--- END OF BLOCK #10 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #8


	--- BLOCK #11 61-61, warpins: 1 ---
	--- END OF BLOCK #11 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #13


	--- BLOCK #12 62-64, warpins: 2 ---
	AT.vars[k] = v
	--- END OF BLOCK #12 ---

	FLOW; TARGET BLOCK #13


	--- BLOCK #13 65-66, warpins: 5 ---
	--- END OF BLOCK #13 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #1


	--- BLOCK #14 67-71, warpins: 1 ---
	--- END OF BLOCK #14 ---

	if AT.vars.AIMBOT_AIMZONE == "default" then
	JUMP TO BLOCK #15
	else
	JUMP TO BLOCK #16
	end


	--- BLOCK #15 72-75, warpins: 1 ---
	AT.vars.AIMBOT_AIMZONE = nil

	--- END OF BLOCK #15 ---

	FLOW; TARGET BLOCK #16


	--- BLOCK #16 76-76, warpins: 3 ---
	return
	--- END OF BLOCK #16 ---



end
AT.GetPlayerName = function (ply)
	--- BLOCK #0 1-3, warpins: 1 ---
	name = nil

	--- END OF BLOCK #0 ---

	slot1 = if not name then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 4-8, warpins: 1 ---
	return _R.Player.Nick(ply)
	--- END OF BLOCK #1 ---

	FLOW; TARGET BLOCK #2


	--- BLOCK #2 9-9, warpins: 2 ---
	return name
	--- END OF BLOCK #2 ---



end
AT.IsFriend = function (ent)
	--- BLOCK #0 1-7, warpins: 1 ---
	--- END OF BLOCK #0 ---

	if _R.Entity.GetClass(ent)

	 ~= "player" then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 8-9, warpins: 1 ---
	return false

	--- END OF BLOCK #1 ---

	FLOW; TARGET BLOCK #2


	--- BLOCK #2 10-20, warpins: 2 ---
	--- END OF BLOCK #2 ---

	slot1 = if AT.vars.FRIENDS[_R.Player.SteamID(ent)

	] then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #3 21-22, warpins: 1 ---
	return true

	--- END OF BLOCK #3 ---

	FLOW; TARGET BLOCK #4


	--- BLOCK #4 23-27, warpins: 2 ---
	--- END OF BLOCK #4 ---

	if AT.vars.FRIENDS_STEAM == 1 then
	JUMP TO BLOCK #5
	else
	JUMP TO BLOCK #7
	end


	--- BLOCK #5 28-34, warpins: 1 ---
	--- END OF BLOCK #5 ---

	if _R.Player.GetFriendStatus(ent)

	 == "friend" then
	JUMP TO BLOCK #6
	else
	JUMP TO BLOCK #7
	end


	--- BLOCK #6 35-36, warpins: 1 ---
	return true

	--- END OF BLOCK #6 ---

	FLOW; TARGET BLOCK #7


	--- BLOCK #7 37-41, warpins: 3 ---
	--- END OF BLOCK #7 ---

	if AT.vars.FRIENDS_TEAM == 1 then
	JUMP TO BLOCK #8
	else
	JUMP TO BLOCK #10
	end


	--- BLOCK #8 42-53, warpins: 1 ---
	--- END OF BLOCK #8 ---

	if _R.Player.Team(ME)
	 == _R.Player.Team(ent)

	 then
	JUMP TO BLOCK #9
	else
	JUMP TO BLOCK #10
	end


	--- BLOCK #9 54-55, warpins: 1 ---
	return true
	--- END OF BLOCK #9 ---

	FLOW; TARGET BLOCK #10


	--- BLOCK #10 56-57, warpins: 3 ---
	return false
	--- END OF BLOCK #10 ---



end
fontdist = 250000
tcache = {}
AT.GetTextSize = function (txt, font)
	--- BLOCK #0 1-4, warpins: 1 ---
	--- END OF BLOCK #0 ---

	slot2 = if tcache[font] then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #3
	end


	--- BLOCK #1 5-9, warpins: 1 ---
	--- END OF BLOCK #1 ---

	slot2 = if tcache[font][txt] then
	JUMP TO BLOCK #2
	else
	JUMP TO BLOCK #3
	end


	--- BLOCK #2 10-18, warpins: 1 ---
	return tcache[font][txt].x, tcache[font][txt].y

	--- END OF BLOCK #2 ---

	FLOW; TARGET BLOCK #3


	--- BLOCK #3 19-23, warpins: 3 ---
	slot2 = tcache
	--- END OF BLOCK #3 ---

	slot3 = if not tcache[font] then
	JUMP TO BLOCK #4
	else
	JUMP TO BLOCK #5
	end


	--- BLOCK #4 24-24, warpins: 1 ---
	slot3 = {}
	--- END OF BLOCK #4 ---

	FLOW; TARGET BLOCK #5


	--- BLOCK #5 25-42, warpins: 2 ---
	slot2[font] = slot3

	_surface.SetFont(font)

	x, y = _surface.GetTextSize(txt)
	tcache[font][txt] = {
		x = x,
		y = y
	}

	return x, y
	--- END OF BLOCK #5 ---



end
nfont = AT.rndstr()
cachf = {}
AT.GetNameFont = function ()
	--- BLOCK #0 1-5, warpins: 1 ---
	--- END OF BLOCK #0 ---

	slot0 = if not AT.vars.ESP_FONT then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 6-6, warpins: 1 ---
	fname = "Arial"
	--- END OF BLOCK #1 ---

	FLOW; TARGET BLOCK #2


	--- BLOCK #2 7-11, warpins: 2 ---
	--- END OF BLOCK #2 ---

	slot1 = if not AT.vars.ESP_FONTSIZE then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #3 12-12, warpins: 1 ---
	fsize = 10
	--- END OF BLOCK #3 ---

	FLOW; TARGET BLOCK #4


	--- BLOCK #4 13-25, warpins: 2 ---
	id = g.table.concat({
		nfont,
		fname,
		fsize
	})
	--- END OF BLOCK #4 ---

	slot3 = if not cachf[id] then
	JUMP TO BLOCK #5
	else
	JUMP TO BLOCK #6
	end


	--- BLOCK #5 26-44, warpins: 1 ---
	cachf[id] = true

	AT.sn(1)
	g.surface.CreateFont(id, {
		shadow = false,
		antialias = true,
		bold = true,
		weight = 400,
		font = fname,
		size = fsize
	})
	AT.sn(0)

	--- END OF BLOCK #5 ---

	FLOW; TARGET BLOCK #6


	--- BLOCK #6 45-45, warpins: 2 ---
	return id
	--- END OF BLOCK #6 ---



end
kdist2 = 3243601
wepdist = 40000
AT.kellr = function ()
	--- BLOCK #0 1-5, warpins: 1 ---
	--- END OF BLOCK #0 ---

	if AT.vars.ESP_DEBUG == 0 then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 6-6, warpins: 1 ---
	--- END OF BLOCK #1 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #5


	--- BLOCK #2 7-43, warpins: 1 ---
	trace = g.util.TraceLine({
		start = _R.Entity.EyePos(ME),
		endpos = _R.Entity.EyePos(ME) + _R.Angle.Forward(_R.Entity.EyeAngles(ME))*10000,
		filter = ME
	})

	--- END OF BLOCK #2 ---

	slot1 = if _R.Entity.IsValid(trace.Entity)

	 then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #5
	end


	--- BLOCK #3 44-59, warpins: 1 ---
	entc = _R.Entity.GetClass(trace.Entity)
	pos = _R.Vector.ToScreen(_R.Entity.GetPos(trace.Entity))
	--- END OF BLOCK #3 ---

	slot2 = if pos then
	JUMP TO BLOCK #4
	else
	JUMP TO BLOCK #5
	end


	--- BLOCK #4 60-113, warpins: 1 ---
	w, h = AT.GetTextSize(entc, AT.fonts.consolename)

	_surface.SetFont(AT.fonts.consolename)
	_surface.SetTextPos(pos.x - w/2, pos.y - h)
	_surface.SetTextColor(colors.black)
	_surface.DrawText(entc)
	_surface.SetTextPos(pos.x - w/2 + 1, (pos.y + 1) - h)
	_surface.SetTextColor(g.Color(255, 255, 0, 255))
	_surface.DrawText(entc)

	--- END OF BLOCK #4 ---

	FLOW; TARGET BLOCK #5


	--- BLOCK #5 114-118, warpins: 4 ---
	--- END OF BLOCK #5 ---

	if AT.vars.ESP_ON ~= 1 then
	JUMP TO BLOCK #6
	else
	JUMP TO BLOCK #8
	end


	--- BLOCK #6 119-123, warpins: 1 ---
	--- END OF BLOCK #6 ---

	if AT.vars.ESP_HEALTH ~= 1 then
	JUMP TO BLOCK #7
	else
	JUMP TO BLOCK #8
	end


	--- BLOCK #7 124-124, warpins: 1 ---
	return

	--- END OF BLOCK #7 ---

	FLOW; TARGET BLOCK #8


	--- BLOCK #8 125-131, warpins: 3 ---
	specs = {}

	--- END OF BLOCK #8 ---

	for k, v in pairs(AT.GetPlayers())

	LOOP BLOCK #9
	GO OUT TO BLOCK #56


	--- BLOCK #9 132-138, warpins: 1 ---
	--- END OF BLOCK #9 ---

	slot6 = if _R.Entity.IsValid(v)
	 then
	JUMP TO BLOCK #10
	else
	JUMP TO BLOCK #55
	end


	--- BLOCK #10 139-141, warpins: 1 ---
	--- END OF BLOCK #10 ---

	if v ~= ME then
	JUMP TO BLOCK #11
	else
	JUMP TO BLOCK #55
	end


	--- BLOCK #11 142-152, warpins: 1 ---
	--- END OF BLOCK #11 ---

	slot6 = if _R.Entity.IsValid(_R.Player.GetObserverTarget(v))
	 then
	JUMP TO BLOCK #12
	else
	JUMP TO BLOCK #14
	end


	--- BLOCK #12 153-160, warpins: 1 ---
	--- END OF BLOCK #12 ---

	if _R.Player.GetObserverTarget(v)
	 == ME then
	JUMP TO BLOCK #13
	else
	JUMP TO BLOCK #14
	end


	--- BLOCK #13 161-170, warpins: 1 ---
	g.table.insert(specs, _R.Player.Nick(v))

	--- END OF BLOCK #13 ---

	FLOW; TARGET BLOCK #14


	--- BLOCK #14 171-178, warpins: 3 ---
	hp = _R.Entity.Health(v)
	--- END OF BLOCK #14 ---

	if 0 >= hp then
	JUMP TO BLOCK #15
	else
	JUMP TO BLOCK #16
	end


	--- BLOCK #15 179-180, warpins: 1 ---
	slot7 = false
	--- END OF BLOCK #15 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #17


	--- BLOCK #16 181-181, warpins: 1 ---
	alive = true
	--- END OF BLOCK #16 ---

	FLOW; TARGET BLOCK #17


	--- BLOCK #17 182-183, warpins: 2 ---
	--- END OF BLOCK #17 ---

	slot7 = if not alive then
	JUMP TO BLOCK #18
	else
	JUMP TO BLOCK #19
	end


	--- BLOCK #18 184-184, warpins: 1 ---
	--- END OF BLOCK #18 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #55


	--- BLOCK #19 185-219, warpins: 1 ---
	pos = _R.Vector.ToScreen(_R.Entity.EyePos(v) + g.Vector(0, 0, 5))
	dist = _R.Vector.DistToSqr(_R.Entity.GetPos(v), _R.Entity.GetPos(ME))
	--- END OF BLOCK #19 ---

	if AT.vars.ESP_DIST < dist then
	JUMP TO BLOCK #20
	else
	JUMP TO BLOCK #21
	end


	--- BLOCK #20 220-220, warpins: 1 ---
	--- END OF BLOCK #20 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #55


	--- BLOCK #21 221-232, warpins: 1 ---
	font = AT.GetNameFont()

	_surface.SetFont(font)
	--- END OF BLOCK #21 ---

	if AT.vars.ESP_TEAM == 1 then
	JUMP TO BLOCK #22
	else
	JUMP TO BLOCK #24
	end


	--- BLOCK #22 233-242, warpins: 1 ---
	--- END OF BLOCK #22 ---

	slot11 = if AT.Teams[_R.Player.Team(v)
	] then
	JUMP TO BLOCK #23
	else
	JUMP TO BLOCK #24
	end


	--- BLOCK #23 243-253, warpins: 1 ---
	--- END OF BLOCK #23 ---

	slot11 = if not AT.Teams[_R.Player.Team(v)
	].Color then
	JUMP TO BLOCK #24
	else
	JUMP TO BLOCK #30
	end


	--- BLOCK #24 254-258, warpins: 3 ---
	--- END OF BLOCK #24 ---

	slot11 = if AT.vars.color_friend then
	JUMP TO BLOCK #25
	else
	JUMP TO BLOCK #27
	end


	--- BLOCK #25 259-264, warpins: 1 ---
	--- END OF BLOCK #25 ---

	slot11 = if AT.IsFriend(v)
	 then
	JUMP TO BLOCK #26
	else
	JUMP TO BLOCK #27
	end


	--- BLOCK #26 265-272, warpins: 1 ---
	--- END OF BLOCK #26 ---

	slot11 = if not AT.h2c(AT.vars.color_friend)
	 then
	JUMP TO BLOCK #27
	else
	JUMP TO BLOCK #30
	end


	--- BLOCK #27 273-277, warpins: 3 ---
	--- END OF BLOCK #27 ---

	slot11 = if AT.vars.color_player then
	JUMP TO BLOCK #28
	else
	JUMP TO BLOCK #29
	end


	--- BLOCK #28 278-285, warpins: 1 ---
	--- END OF BLOCK #28 ---

	slot11 = if not AT.h2c(AT.vars.color_player)

	 then
	JUMP TO BLOCK #29
	else
	JUMP TO BLOCK #30
	end


	--- BLOCK #29 286-287, warpins: 2 ---
	col = colors.ply
	--- END OF BLOCK #29 ---

	FLOW; TARGET BLOCK #30


	--- BLOCK #30 288-292, warpins: 4 ---
	--- END OF BLOCK #30 ---

	if AT.vars.ESP_ON == 1 then
	JUMP TO BLOCK #31
	else
	JUMP TO BLOCK #34
	end


	--- BLOCK #31 293-330, warpins: 1 ---
	name = AT.GetPlayerName(v)
	w, h = AT.GetTextSize(name, font)

	_surface.SetTextPos(pos.x - w/2, pos.y - h)
	_surface.SetTextColor(colors.black)
	_surface.DrawText(name)
	_surface.SetTextPos(pos.x - w/2 + 1, (pos.y + 1) - h)

	--- END OF BLOCK #31 ---

	slot7 = if not alive then
	JUMP TO BLOCK #32
	else
	JUMP TO BLOCK #33
	end


	--- BLOCK #32 331-332, warpins: 1 ---
	col.a = 160

	--- END OF BLOCK #32 ---

	FLOW; TARGET BLOCK #33


	--- BLOCK #33 333-340, warpins: 2 ---
	_surface.SetTextColor(col)
	_surface.DrawText(name)

	--- END OF BLOCK #33 ---

	FLOW; TARGET BLOCK #34


	--- BLOCK #34 341-345, warpins: 2 ---
	--- END OF BLOCK #34 ---

	if AT.vars.ESP_HEALTH == 1 then
	JUMP TO BLOCK #35
	else
	JUMP TO BLOCK #42
	end


	--- BLOCK #35 346-350, warpins: 1 ---
	slot12 = g.table.concat
	--- END OF BLOCK #35 ---

	slot7 = if alive then
	JUMP TO BLOCK #36
	else
	JUMP TO BLOCK #37
	end


	--- BLOCK #36 351-354, warpins: 1 ---
	--- END OF BLOCK #36 ---

	slot13 = if not {
		"HP: ",
		hp
	} then
	JUMP TO BLOCK #37
	else
	JUMP TO BLOCK #38
	end


	--- BLOCK #37 355-355, warpins: 2 ---
	slot13 = {
		"DEAD"
	}
	--- END OF BLOCK #37 ---

	FLOW; TARGET BLOCK #38


	--- BLOCK #38 356-394, warpins: 2 ---
	HP = slot12(slot13)
	w2, h2 = AT.GetTextSize(HP, font)

	_surface.SetTextPos(pos.x - w2/2, pos.y - h2*2)
	_surface.SetTextColor(colors.black)
	_surface.DrawText(HP)
	_surface.SetTextPos(pos.x - w2/2 + 1, (pos.y + 1) - h2*2)

	slot15 = _surface.SetTextColor

	--- END OF BLOCK #38 ---

	slot7 = if alive then
	JUMP TO BLOCK #39
	else
	JUMP TO BLOCK #40
	end


	--- BLOCK #39 395-403, warpins: 1 ---
	--- END OF BLOCK #39 ---

	slot16 = if not g.Color(0, 200, 0, 255)

	 then
	JUMP TO BLOCK #40
	else
	JUMP TO BLOCK #41
	end


	--- BLOCK #40 404-410, warpins: 2 ---
	slot16 = g.Color(255, 0, 0, 255)

	--- END OF BLOCK #40 ---

	FLOW; TARGET BLOCK #41


	--- BLOCK #41 411-415, warpins: 2 ---
	slot15(slot16)
	_surface.DrawText(HP)

	--- END OF BLOCK #41 ---

	FLOW; TARGET BLOCK #42


	--- BLOCK #42 416-420, warpins: 2 ---
	--- END OF BLOCK #42 ---

	if AT.vars.ESP_TEAMNAME == 1 then
	JUMP TO BLOCK #43
	else
	JUMP TO BLOCK #44
	end


	--- BLOCK #43 421-466, warpins: 1 ---
	HP = AT.GetTeamName(v)
	w2, h2 = AT.GetTextSize(HP, font)

	_surface.SetTextPos(pos.x - w2/2, pos.y - h2*3)
	_surface.SetTextColor(colors.black)
	_surface.DrawText(HP)
	_surface.SetTextPos(pos.x - w2/2 + 1, (pos.y + 1) - h2*3)
	_surface.SetTextColor(col)
	_surface.DrawText(HP)
	--- END OF BLOCK #43 ---

	FLOW; TARGET BLOCK #44


	--- BLOCK #44 467-468, warpins: 2 ---
	--- END OF BLOCK #44 ---

	slot7 = if alive then
	JUMP TO BLOCK #45
	else
	JUMP TO BLOCK #55
	end


	--- BLOCK #45 469-473, warpins: 1 ---
	--- END OF BLOCK #45 ---

	if AT.vars.ESP_SHOWWEPS == 1 then
	JUMP TO BLOCK #46
	else
	JUMP TO BLOCK #55
	end


	--- BLOCK #46 474-476, warpins: 1 ---
	--- END OF BLOCK #46 ---

	if dist <= wepdist then
	JUMP TO BLOCK #47
	else
	JUMP TO BLOCK #55
	end


	--- BLOCK #47 477-490, warpins: 1 ---
	_surface.SetFont(font)

	weps = _R.Player.GetWeapons(v)

	--- END OF BLOCK #47 ---

	slot13 = if AT.vars.color_weapon then
	JUMP TO BLOCK #48
	else
	JUMP TO BLOCK #49
	end


	--- BLOCK #48 491-498, warpins: 1 ---
	--- END OF BLOCK #48 ---

	slot13 = if not AT.h2c(AT.vars.color_weapon)

	 then
	JUMP TO BLOCK #49
	else
	JUMP TO BLOCK #50
	end


	--- BLOCK #49 499-500, warpins: 2 ---
	colwep = colors.wep

	--- END OF BLOCK #49 ---

	FLOW; TARGET BLOCK #50


	--- BLOCK #50 501-504, warpins: 2 ---
	--- END OF BLOCK #50 ---

	for k, wep in pairs(weps)


	LOOP BLOCK #51
	GO OUT TO BLOCK #55


	--- BLOCK #51 505-516, warpins: 1 ---
	pos = _R.Vector.ToScreen(_R.Entity.GetPos(wep))
	--- END OF BLOCK #51 ---

	slot8 = if not pos then
	JUMP TO BLOCK #52
	else
	JUMP TO BLOCK #53
	end


	--- BLOCK #52 517-517, warpins: 1 ---
	--- END OF BLOCK #52 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #54


	--- BLOCK #53 518-564, warpins: 1 ---
	t = _R.Entity.GetClass(wep)
	w2, h2 = AT.GetTextSize(t, font)

	_surface.SetTextPos(pos.x - w2/2 - 1, (pos.y + h2*k) - 1)
	_surface.SetTextColor(colors.black)
	_surface.DrawText(t)
	_surface.SetTextPos(pos.x - w2/2, pos.y + h2*k)
	_surface.SetTextColor(colwep)
	_surface.DrawText(t)

	--- END OF BLOCK #53 ---

	FLOW; TARGET BLOCK #54


	--- BLOCK #54 565-566, warpins: 3 ---
	--- END OF BLOCK #54 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #50


	--- BLOCK #55 567-568, warpins: 9 ---
	--- END OF BLOCK #55 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #8


	--- BLOCK #56 569-572, warpins: 1 ---
	--- END OF BLOCK #56 ---

	if 0 < #specs then
	JUMP TO BLOCK #57
	else
	JUMP TO BLOCK #58
	end


	--- BLOCK #57 573-642, warpins: 1 ---
	list = "You are being spectated by: " .. g.table.concat(specs, ", ")
	w, h = AT.GetTextSize(list, AT.fonts.spectate)

	_surface.SetFont(AT.fonts.spectate)
	_surface.SetTextColor(g.Color(0, 0, 0, 255))
	_surface.SetTextPos(g.ScrW()/2 - w/2 + 1, 51)
	_surface.DrawText(list)
	_surface.SetTextColor(g.Color(255, 0, 0, 255))
	_surface.SetTextPos(g.ScrW()/2 - w/2, 50)
	_surface.DrawText(list)

	--- END OF BLOCK #57 ---

	FLOW; TARGET BLOCK #58


	--- BLOCK #58 643-643, warpins: 2 ---
	return
	--- END OF BLOCK #58 ---



end
skelly = {}
skelly[1] = {
	"ValveBiped.Bip01_Pelvis",
	"ValveBiped.Bip01_Spine4"
}
skelly[2] = {
	"ValveBiped.Bip01_Pelvis",
	"ValveBiped.Bip01_L_Calf"
}
skelly[3] = {
	"ValveBiped.Bip01_Pelvis",
	"ValveBiped.Bip01_R_Calf"
}
skelly[4] = {
	"ValveBiped.Bip01_L_Calf",
	"ValveBiped.Bip01_L_Foot"
}
skelly[5] = {
	"ValveBiped.Bip01_R_Calf",
	"ValveBiped.Bip01_R_Foot"
}
skelly[6] = {
	"ValveBiped.Bip01_Spine4",
	"ValveBiped.Bip01_R_Forearm"
}
skelly[7] = {
	"ValveBiped.Bip01_Spine4",
	"ValveBiped.Bip01_L_Forearm"
}
skelly[8] = {
	"ValveBiped.Bip01_R_Forearm",
	"ValveBiped.Bip01_R_Hand"
}
skelly[9] = {
	"ValveBiped.Bip01_L_Forearm",
	"ValveBiped.Bip01_L_Hand"
}
cust = nil
AT.NoRender = {}
col = nil
AT.dead = function ()
	--- BLOCK #0 1-20, warpins: 1 ---
	g.cam.Start3D(eyepos, eyeangles)
	g.render.SetBlend(1)

	AT.NoRender = {}

	--- END OF BLOCK #0 ---

	for k, v in pairs(AT.GetEnts())

	LOOP BLOCK #1
	GO OUT TO BLOCK #64


	--- BLOCK #1 21-27, warpins: 1 ---
	--- END OF BLOCK #1 ---

	slot5 = if not _R.Entity.IsValid(v)
	 then
	JUMP TO BLOCK #2
	else
	JUMP TO BLOCK #3
	end


	--- BLOCK #2 28-28, warpins: 1 ---
	--- END OF BLOCK #2 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #63


	--- BLOCK #3 29-48, warpins: 1 ---
	AT.sn(1)

	pos = _R.Vector.ToScreen(_R.Entity.GetPos(v))

	AT.sn(0)

	--- END OF BLOCK #3 ---

	slot6 = if not pos.visible then
	JUMP TO BLOCK #4
	else
	JUMP TO BLOCK #5
	end


	--- BLOCK #4 49-53, warpins: 1 ---
	AT.NoRender[k] = 1

	--- END OF BLOCK #4 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #63


	--- BLOCK #5 54-59, warpins: 1 ---
	--- END OF BLOCK #5 ---

	if 0 < AT.vars.CHAMS_ON then
	JUMP TO BLOCK #6
	else
	JUMP TO BLOCK #60
	end


	--- BLOCK #6 60-66, warpins: 1 ---
	--- END OF BLOCK #6 ---

	slot6 = if _R.Entity.IsValid(v)
	 then
	JUMP TO BLOCK #7
	else
	JUMP TO BLOCK #60
	end


	--- BLOCK #7 67-69, warpins: 1 ---
	--- END OF BLOCK #7 ---

	if v ~= ME then
	JUMP TO BLOCK #8
	else
	JUMP TO BLOCK #60
	end


	--- BLOCK #8 70-76, warpins: 1 ---
	--- END OF BLOCK #8 ---

	if _R.Entity.GetClass(v)
	 == "player" then
	JUMP TO BLOCK #9
	else
	JUMP TO BLOCK #60
	end


	--- BLOCK #9 77-84, warpins: 1 ---
	--- END OF BLOCK #9 ---

	if 0 < _R.Entity.Health(v)

	 then
	JUMP TO BLOCK #10
	else
	JUMP TO BLOCK #60
	end


	--- BLOCK #10 85-103, warpins: 1 ---
	dist = _R.Vector.DistToSqr(_R.Entity.GetPos(v), _R.Entity.GetPos(ME))
	--- END OF BLOCK #10 ---

	if AT.vars.CHAMS_DIST < dist then
	JUMP TO BLOCK #11
	else
	JUMP TO BLOCK #12
	end


	--- BLOCK #11 104-108, warpins: 1 ---
	AT.NoRender[k] = 1

	--- END OF BLOCK #11 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #63


	--- BLOCK #12 109-113, warpins: 1 ---
	--- END OF BLOCK #12 ---

	if AT.vars.ESP_TEAM == 1 then
	JUMP TO BLOCK #13
	else
	JUMP TO BLOCK #15
	end


	--- BLOCK #13 114-123, warpins: 1 ---
	--- END OF BLOCK #13 ---

	slot7 = if AT.Teams[_R.Player.Team(v)
	] then
	JUMP TO BLOCK #14
	else
	JUMP TO BLOCK #15
	end


	--- BLOCK #14 124-134, warpins: 1 ---
	--- END OF BLOCK #14 ---

	slot7 = if not AT.Teams[_R.Player.Team(v)
	].Color then
	JUMP TO BLOCK #15
	else
	JUMP TO BLOCK #21
	end


	--- BLOCK #15 135-139, warpins: 3 ---
	--- END OF BLOCK #15 ---

	slot7 = if AT.vars.color_friend then
	JUMP TO BLOCK #16
	else
	JUMP TO BLOCK #18
	end


	--- BLOCK #16 140-145, warpins: 1 ---
	--- END OF BLOCK #16 ---

	slot7 = if AT.IsFriend(v)
	 then
	JUMP TO BLOCK #17
	else
	JUMP TO BLOCK #18
	end


	--- BLOCK #17 146-153, warpins: 1 ---
	--- END OF BLOCK #17 ---

	slot7 = if not AT.h2c(AT.vars.color_friend)
	 then
	JUMP TO BLOCK #18
	else
	JUMP TO BLOCK #21
	end


	--- BLOCK #18 154-158, warpins: 3 ---
	--- END OF BLOCK #18 ---

	slot7 = if AT.vars.color_player then
	JUMP TO BLOCK #19
	else
	JUMP TO BLOCK #20
	end


	--- BLOCK #19 159-166, warpins: 1 ---
	--- END OF BLOCK #19 ---

	slot7 = if not AT.h2c(AT.vars.color_player)

	 then
	JUMP TO BLOCK #20
	else
	JUMP TO BLOCK #21
	end


	--- BLOCK #20 167-168, warpins: 2 ---
	slot7 = colors.ply
	--- END OF BLOCK #20 ---

	FLOW; TARGET BLOCK #21


	--- BLOCK #21 169-174, warpins: 4 ---
	col = slot7

	--- END OF BLOCK #21 ---

	if AT.vars.CHAMS_ON == 1 then
	JUMP TO BLOCK #22
	else
	JUMP TO BLOCK #31
	end


	--- BLOCK #22 175-178, warpins: 1 ---
	--- END OF BLOCK #22 ---

	for m, n in pairs(skelly)


	LOOP BLOCK #23
	GO OUT TO BLOCK #30


	--- BLOCK #23 179-192, warpins: 1 ---
	id = _R.Entity.LookupBone(v, n[1])
	id2 = _R.Entity.LookupBone(v, n[2])
	--- END OF BLOCK #23 ---

	if id ~= nil then
	JUMP TO BLOCK #24
	else
	JUMP TO BLOCK #29
	end


	--- BLOCK #24 193-194, warpins: 1 ---
	--- END OF BLOCK #24 ---

	if id2 ~= nil then
	JUMP TO BLOCK #25
	else
	JUMP TO BLOCK #29
	end


	--- BLOCK #25 195-208, warpins: 1 ---
	b1p, b1a = _R.Entity.GetBonePosition(v, id)
	b2p, b2a = _R.Entity.GetBonePosition(v, id2)

	--- END OF BLOCK #25 ---

	slot14 = if b1p then
	JUMP TO BLOCK #26
	else
	JUMP TO BLOCK #29
	end


	--- BLOCK #26 209-210, warpins: 1 ---
	--- END OF BLOCK #26 ---

	slot16 = if not b2p then
	JUMP TO BLOCK #27
	else
	JUMP TO BLOCK #28
	end


	--- BLOCK #27 211-211, warpins: 1 ---
	--- END OF BLOCK #27 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #29


	--- BLOCK #28 212-219, warpins: 1 ---
	g.render.DrawLine(b1p, b2p, col, false)
	--- END OF BLOCK #28 ---

	FLOW; TARGET BLOCK #29


	--- BLOCK #29 220-221, warpins: 6 ---
	--- END OF BLOCK #29 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #22


	--- BLOCK #30 222-222, warpins: 1 ---
	--- END OF BLOCK #30 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #41


	--- BLOCK #31 223-228, warpins: 1 ---
	--- END OF BLOCK #31 ---

	if 2 <= AT.vars.CHAMS_ON then
	JUMP TO BLOCK #32
	else
	JUMP TO BLOCK #41
	end


	--- BLOCK #32 229-233, warpins: 1 ---
	--- END OF BLOCK #32 ---

	if AT.vars.CHAMS_ON == 2 then
	JUMP TO BLOCK #33
	else
	JUMP TO BLOCK #34
	end


	--- BLOCK #33 234-258, warpins: 1 ---
	_R.IMaterial.SetVector(AT.overlay, "$color2", g.Vector(col.r/255, col.g/255, col.b/255))
	g.render.MaterialOverride(AT.overlay)
	--- END OF BLOCK #33 ---

	FLOW; TARGET BLOCK #34


	--- BLOCK #34 259-263, warpins: 2 ---
	--- END OF BLOCK #34 ---

	if AT.vars.CHAMS_ON == 4 then
	JUMP TO BLOCK #35
	else
	JUMP TO BLOCK #36
	end


	--- BLOCK #35 264-288, warpins: 1 ---
	_R.IMaterial.SetVector(AT.colorchams, "$color2", g.Vector(col.r/255, col.g/255, col.b/255))
	g.render.MaterialOverride(AT.colorchams)
	--- END OF BLOCK #35 ---

	FLOW; TARGET BLOCK #36


	--- BLOCK #36 289-293, warpins: 2 ---
	--- END OF BLOCK #36 ---

	if AT.vars.ESP_FULLBRIGHT == 1 then
	JUMP TO BLOCK #37
	else
	JUMP TO BLOCK #38
	end


	--- BLOCK #37 294-298, warpins: 1 ---
	g.render.SuppressEngineLighting(true)

	--- END OF BLOCK #37 ---

	FLOW; TARGET BLOCK #38


	--- BLOCK #38 299-309, warpins: 2 ---
	fakemodel = AT.GetFakeModel(k)

	--- END OF BLOCK #38 ---

	slot8 = if not _R.Entity.IsValid(fakemodel)
	 then
	JUMP TO BLOCK #39
	else
	JUMP TO BLOCK #40
	end


	--- BLOCK #39 310-310, warpins: 1 ---
	--- END OF BLOCK #39 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #63


	--- BLOCK #40 311-398, warpins: 1 ---
	_R.Entity.SetModel(fakemodel, AT.getmodel(k))
	_R.Entity.SetParent(fakemodel, v)
	_R.Entity.AddEffects(fakemodel, 1)
	_R.Entity.SetupBones(fakemodel)
	_R.Entity.SetParent(fakemodel, nil)
	_R.Entity.SetPos(fakemodel, _R.Entity.GetPos(v))

	ang = _R.Entity.EyeAngles(v)
	ang.p = 0

	_R.Entity.SetAngles(fakemodel, ang)
	_R.Entity.SetSequence(fakemodel, _R.Entity.GetSequence(v))
	AT.sn(1)
	_R.Entity.DrawModel(fakemodel)
	AT.sn(0)
	g.render.SuppressEngineLighting(false)
	g.render.MaterialOverride(nil)

	--- END OF BLOCK #40 ---

	FLOW; TARGET BLOCK #41


	--- BLOCK #41 399-403, warpins: 3 ---
	--- END OF BLOCK #41 ---

	if AT.vars.ESP_WEAPON == 1 then
	JUMP TO BLOCK #42
	else
	JUMP TO BLOCK #63
	end


	--- BLOCK #42 404-415, warpins: 1 ---
	wep = _R.Player.GetActiveWeapon(v)

	--- END OF BLOCK #42 ---

	slot8 = if not _R.Entity.IsValid(wep)

	 then
	JUMP TO BLOCK #43
	else
	JUMP TO BLOCK #44
	end


	--- BLOCK #43 416-416, warpins: 1 ---
	--- END OF BLOCK #43 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #63


	--- BLOCK #44 417-424, warpins: 1 ---
	att = _R.Entity.LookupAttachment(v, "anim_attachment_RH")
	--- END OF BLOCK #44 ---

	slot8 = if not att then
	JUMP TO BLOCK #45
	else
	JUMP TO BLOCK #46
	end


	--- BLOCK #45 425-425, warpins: 1 ---
	--- END OF BLOCK #45 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #63


	--- BLOCK #46 426-452, warpins: 1 ---
	pos = _R.Entity.GetAttachment(v, att)
	nop, ang = _R.Entity.GetBonePosition(wep, 0)
	dahmod = AT.GetModelWeapon(_R.Entity.EntIndex(v))

	--- END OF BLOCK #46 ---

	slot13 = if _R.Entity.IsValid(dahmod)

	 then
	JUMP TO BLOCK #47
	else
	JUMP TO BLOCK #63
	end


	--- BLOCK #47 453-454, warpins: 1 ---
	--- END OF BLOCK #47 ---

	slot9 = if pos then
	JUMP TO BLOCK #48
	else
	JUMP TO BLOCK #63
	end


	--- BLOCK #48 455-456, warpins: 1 ---
	--- END OF BLOCK #48 ---

	slot11 = if ang then
	JUMP TO BLOCK #49
	else
	JUMP TO BLOCK #63
	end


	--- BLOCK #49 457-459, warpins: 1 ---
	--- END OF BLOCK #49 ---

	slot13 = if not pos.Pos then
	JUMP TO BLOCK #50
	else
	JUMP TO BLOCK #51
	end


	--- BLOCK #50 460-460, warpins: 1 ---
	--- END OF BLOCK #50 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #63


	--- BLOCK #51 461-467, warpins: 1 ---
	ang = pos.Ang
	pos = pos.Pos

	--- END OF BLOCK #51 ---

	slot13 = if AT.vars.color_weapon then
	JUMP TO BLOCK #52
	else
	JUMP TO BLOCK #53
	end


	--- BLOCK #52 468-475, warpins: 1 ---
	--- END OF BLOCK #52 ---

	slot13 = if not AT.h2c(AT.vars.color_weapon)

	 then
	JUMP TO BLOCK #53
	else
	JUMP TO BLOCK #54
	end


	--- BLOCK #53 476-477, warpins: 2 ---
	colwep = colors.wep

	--- END OF BLOCK #53 ---

	FLOW; TARGET BLOCK #54


	--- BLOCK #54 478-565, warpins: 2 ---
	_R.IMaterial.SetVector(AT.colorchams, "$color2", g.Vector(colwep.r/255, colwep.g/255, colwep.b/255))
	g.render.MaterialOverride(AT.colorchams)

	model = AT.getmodel(_R.Entity.EntIndex(wep))

	_R.Entity.SetNoDraw(dahmod, true)
	_R.Entity.SetModel(dahmod, model)
	_R.Entity.SetParent(dahmod, v)
	_R.Entity.AddEffects(dahmod, 1)
	_R.Entity.SetupBones(dahmod)
	_R.Entity.SetParent(dahmod, nil)
	_R.Entity.SetAngles(dahmod, ang)
	_R.Entity.RemoveEffects(dahmod, 1)
	_R.Entity.SetPos(dahmod, pos)
	--- END OF BLOCK #54 ---

	if AT.vars.ESP_FULLBRIGHT == 1 then
	JUMP TO BLOCK #55
	else
	JUMP TO BLOCK #56
	end


	--- BLOCK #55 566-570, warpins: 1 ---
	g.render.SuppressEngineLighting(true)
	--- END OF BLOCK #55 ---

	FLOW; TARGET BLOCK #56


	--- BLOCK #56 571-572, warpins: 2 ---
	--- END OF BLOCK #56 ---

	if model ~= "models/buggy.mdl" then
	JUMP TO BLOCK #57
	else
	JUMP TO BLOCK #58
	end


	--- BLOCK #57 573-585, warpins: 1 ---
	AT.sn(1)
	_R.Entity.DrawModel(dahmod)
	AT.sn(0)
	--- END OF BLOCK #57 ---

	FLOW; TARGET BLOCK #58


	--- BLOCK #58 586-596, warpins: 2 ---
	g.render.SuppressEngineLighting(false)
	g.render.MaterialOverride(nil)

	--- END OF BLOCK #58 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #63


	--- BLOCK #59 597-597, warpins: 0 ---
	--- END OF BLOCK #59 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #61


	--- BLOCK #60 598-601, warpins: 5 ---
	AT.NoRender[k] = 1
	--- END OF BLOCK #60 ---

	FLOW; TARGET BLOCK #61


	--- BLOCK #61 602-614, warpins: 2 ---
	cust = AT.vars.ESP_ENTS[_R.Entity.GetClass(v)]
	--- END OF BLOCK #61 ---

	slot6 = if cust then
	JUMP TO BLOCK #62
	else
	JUMP TO BLOCK #63
	end


	--- BLOCK #62 615-670, warpins: 1 ---
	min = _R.Entity.OBBMins(v)
	max = _R.Entity.OBBMaxs(v)
	pos = _R.Entity.GetPos(v)
	ang = _R.Entity.GetAngles(v)
	col2 = AT.h2c(cust)

	_R.IMaterial.SetVector(AT.overlay, "$color2", g.Vector(col2.r/255, col2.g/255, col2.b/255))
	g.render.SetMaterial(AT.overlay)
	g.render.DrawBox(pos, ang, min, max, col2, true)
	--- END OF BLOCK #62 ---

	FLOW; TARGET BLOCK #63


	--- BLOCK #63 671-672, warpins: 15 ---
	--- END OF BLOCK #63 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #0


	--- BLOCK #64 673-681, warpins: 1 ---
	g.cam.End3D()
	--- END OF BLOCK #64 ---

	if AT.vars.ESP_GLOW == 1 then
	JUMP TO BLOCK #65
	else
	JUMP TO BLOCK #66
	end


	--- BLOCK #65 682-691, warpins: 1 ---
	AT.Halo(nil, g.Color(255, 0, 0))

	--- END OF BLOCK #65 ---

	FLOW; TARGET BLOCK #66


	--- BLOCK #66 692-692, warpins: 2 ---
	return
	--- END OF BLOCK #66 ---



end
AT.pp_add = g.CreateMaterial(AT.rndstr(), "UnlitGeneric", {
	["$ignorez"] = 1,
	["$basetexture"] = "_rt_FullFrameFB",
	["$additive"] = 1
})
AT.pp_sub = g.CreateMaterial(AT.rndstr(), "Modulate", {
	["$ignorez"] = 1,
	["$basetexture"] = "_rt_FullFrameFB",
	["$writez"] = 0
})
AT.pp_copy = g.CreateMaterial(AT.rndstr(), "UnlitGeneric", {
	["$ignorez"] = 1,
	["$writez"] = 0,
	["$linearwrite"] = 0,
	["$fbtexture"] = "_rt_FullFrameFB"
})
AT.g_blurx = g.CreateMaterial(AT.rndstr(), "g_blurx", {
	["$ignorez"] = 1,
	["$basetexture"] = "_rt_FullFrameFB",
	["$additive"] = 1,
	["$size"] = 6
})
AT.g_blury = g.CreateMaterial(AT.rndstr(), "g_blury", {
	["$ignorez"] = 1,
	["$basetexture"] = "_rt_FullFrameFB",
	["$additive"] = 1,
	["$size"] = 6
})
mat_Copy = AT.pp_copy
mat_Add = AT.pp_add
mat_Sub = AT.pp_sub
rt_Store = g.render.GetScreenEffectTexture(0)
rt_Blur = g.render.GetScreenEffectTexture(1)
mat_BlurX = AT.g_blurx
mat_BlurY = AT.g_blury
tex_Bloom1 = g.render.GetBloomTex1()
g.render.BlurRenderTarget = function (rt, sizex, sizey, passes)
	--- BLOCK #0 1-32, warpins: 1 ---
	_R.IMaterial.SetTexture(mat_BlurX, "$basetexture", rt)
	_R.IMaterial.SetTexture(mat_BlurY, "$basetexture", tex_Bloom1)
	_R.IMaterial.SetFloat(mat_BlurX, "$size", sizex)
	_R.IMaterial.SetFloat(mat_BlurY, "$size", sizey)
	--- END OF BLOCK #0 ---

	for i=1, passes + 1, 1
	LOOP BLOCK #1
	GO OUT TO BLOCK #2

	--- BLOCK #1 33-61, warpins: 2 ---
	g.render.SetRenderTarget(tex_Bloom1)
	g.render.SetMaterial(mat_BlurX)
	g.render.DrawScreenQuad()
	g.render.SetRenderTarget(rt)
	g.render.SetMaterial(mat_BlurY)
	g.render.DrawScreenQuad()

	--- END OF BLOCK #1 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #0


	--- BLOCK #2 62-62, warpins: 1 ---
	return
	--- END OF BLOCK #2 ---



end
g.cam.Start2D = function ()
	--- BLOCK #0 1-5, warpins: 1 ---
	return g.cam.Start({
		type = "2D"
	})
	--- END OF BLOCK #0 ---



end
AT.HaloModel = nil
AT.PlayerModels = {}
AT.GetFakeModel = function (id)
	--- BLOCK #0 1-8, warpins: 1 ---
	--- END OF BLOCK #0 ---

	slot1 = if not _R.Entity.IsValid(AT.HaloModel)
	 then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 9-37, warpins: 1 ---
	AT.sn(1)

	AT.HaloModel = g.ClientsideModel("models/buggy.mdl", 7)

	AT.sn(0)
	_R.Entity.SetNoDraw(AT.HaloModel, true)
	_R.Entity.SetLOD(AT.HaloModel, 0)
	--- END OF BLOCK #1 ---

	FLOW; TARGET BLOCK #2


	--- BLOCK #2 38-39, warpins: 2 ---
	--- END OF BLOCK #2 ---

	slot0 = if id then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #6
	end


	--- BLOCK #3 40-48, warpins: 1 ---
	--- END OF BLOCK #3 ---

	slot1 = if not _R.Entity.IsValid(AT.PlayerModels[id])
	 then
	JUMP TO BLOCK #4
	else
	JUMP TO BLOCK #5
	end


	--- BLOCK #4 49-80, warpins: 1 ---
	AT.sn(1)

	AT.PlayerModels[id] = g.ClientsideModel("models/buggy.mdl", 7)

	AT.sn(0)
	_R.Entity.SetNoDraw(AT.PlayerModels[id], true)
	_R.Entity.SetLOD(AT.PlayerModels[id], 0)

	--- END OF BLOCK #4 ---

	FLOW; TARGET BLOCK #5


	--- BLOCK #5 81-84, warpins: 2 ---
	return AT.PlayerModels[id]
	--- END OF BLOCK #5 ---

	FLOW; TARGET BLOCK #6


	--- BLOCK #6 85-87, warpins: 2 ---
	return AT.HaloModel
	--- END OF BLOCK #6 ---



end
AT.Halo = function (entity, col)
	--- BLOCK #0 1-81, warpins: 1 ---
	rt_Scene = g.render.GetRenderTarget()

	g.render.CopyRenderTargetToTexture(rt_Store)
	g.render.Clear(0, 0, 0, 255, false, true)
	g.cam.Start3D(eyepos, eyeangles)
	g.render.SetStencilEnable(true)
	g.render.SuppressEngineLighting(true)
	g.cam.IgnoreZ(true)
	g.render.SetStencilWriteMask(1)
	g.render.SetStencilTestMask(1)
	g.render.SetStencilReferenceValue(1)
	g.render.SetStencilCompareFunction(8)
	g.render.SetStencilPassOperation(3)
	g.render.SetStencilFailOperation(1)
	g.render.SetStencilZFailOperation(1)
	--- END OF BLOCK #0 ---

	for k, v in pairs(AT.GetPlayers())

	LOOP BLOCK #1
	GO OUT TO BLOCK #5


	--- BLOCK #1 82-88, warpins: 1 ---
	--- END OF BLOCK #1 ---

	slot8 = if _R.Entity.IsValid(v)

	 then
	JUMP TO BLOCK #2
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #2 89-93, warpins: 1 ---
	--- END OF BLOCK #2 ---

	slot8 = if not AT.NoRender[k] then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #3 94-175, warpins: 1 ---
	fakemodel = AT.GetFakeModel(k)

	_R.Entity.SetModel(fakemodel, AT.getmodel(k))
	_R.Entity.SetParent(fakemodel, v)
	_R.Entity.AddEffects(fakemodel, 1)
	_R.Entity.SetupBones(fakemodel)
	_R.Entity.SetParent(fakemodel, nil)
	_R.Entity.SetPos(fakemodel, _R.Entity.GetPos(v))

	ang = _R.Entity.EyeAngles(v)
	ang.p = 0

	_R.Entity.SetAngles(fakemodel, ang)
	_R.Entity.SetSequence(fakemodel, _R.Entity.GetSequence(v))
	AT.sn(1)
	_R.Entity.DrawModel(fakemodel)
	AT.sn(0)
	--- END OF BLOCK #3 ---

	FLOW; TARGET BLOCK #4


	--- BLOCK #4 176-177, warpins: 4 ---
	--- END OF BLOCK #4 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #0


	--- BLOCK #5 178-198, warpins: 1 ---
	g.render.SetStencilCompareFunction(3)
	g.render.SetStencilPassOperation(1)
	g.cam.Start2D()

	slot3 = _surface.SetDrawColor

	--- END OF BLOCK #5 ---

	slot4 = if AT.vars.color_glow then
	JUMP TO BLOCK #6
	else
	JUMP TO BLOCK #7
	end


	--- BLOCK #6 199-206, warpins: 1 ---
	--- END OF BLOCK #6 ---

	slot4 = if not AT.h2c(AT.vars.color_glow)

	 then
	JUMP TO BLOCK #7
	else
	JUMP TO BLOCK #8
	end


	--- BLOCK #7 207-208, warpins: 2 ---
	slot4 = colors.ply

	--- END OF BLOCK #7 ---

	FLOW; TARGET BLOCK #8


	--- BLOCK #8 209-303, warpins: 2 ---
	slot3(slot4)
	_surface.DrawRect(0, 0, g.ScrW(), g.ScrH())
	g.cam.End2D()
	g.cam.IgnoreZ(false)
	g.render.SuppressEngineLighting(false)
	g.render.SetStencilEnable(false)
	g.cam.End3D()
	g.render.CopyRenderTargetToTexture(rt_Blur)
	g.render.BlurRenderTarget(rt_Blur, 2, 2, 1)
	g.render.SetRenderTarget(rt_Scene)
	_R.IMaterial.SetTexture(mat_Copy, "$basetexture", rt_Store)
	g.render.SetMaterial(mat_Copy)
	g.render.DrawScreenQuad()
	g.render.SetStencilEnable(true)
	g.render.SetStencilCompareFunction(6)
	_R.IMaterial.SetTexture(mat_Add, "$basetexture", rt_Blur)
	g.render.SetMaterial(mat_Add)
	--- END OF BLOCK #8 ---

	for i=0, 1, 1
	LOOP BLOCK #9
	GO OUT TO BLOCK #10

	--- BLOCK #9 304-308, warpins: 2 ---
	g.render.DrawScreenQuad()
	--- END OF BLOCK #9 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #8


	--- BLOCK #10 309-329, warpins: 1 ---
	g.render.SetStencilEnable(false)
	g.render.SetStencilTestMask(0)
	g.render.SetStencilWriteMask(0)
	g.render.SetStencilReferenceValue(0)

	return
	--- END OF BLOCK #10 ---



end
AT.SNAP = false
g.math.AngleDifference = function (a, b)
	--- BLOCK #0 1-8, warpins: 1 ---
	diff = g.math.NormalizeAngle(a - b)

	--- END OF BLOCK #0 ---

	if diff < 180 then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 9-9, warpins: 1 ---
	return diff
	--- END OF BLOCK #1 ---

	FLOW; TARGET BLOCK #2


	--- BLOCK #2 10-11, warpins: 2 ---
	return diff - 360
	--- END OF BLOCK #2 ---



end

function AngleAxisDelta(inEyeAngle, inResultAng)
	--- BLOCK #0 1-18, warpins: 1 ---
	axisP = g.math.AngleDifference(inEyeAngle.p, inResultAng.p)
	axisY = g.math.AngleDifference(inEyeAngle.y, inResultAng.y)

	return g.Angle(axisP, axisY, 0)
	--- END OF BLOCK #0 ---



end

constLerpValue = 0.4
autoSnap = 3
approachToSnapValue = 0.02
tempLV = constLerpValue
AT.vars.AIMBOT_SMOOTHINGNEW = 0.3
AT.smooth = function (eyeang, eyep, tpos)
	--- BLOCK #0 1-26, warpins: 1 ---
	lerpedAngle = AngleAxisDelta(eyeang, _R.Vector.Angle(tpos - eyep))

	--- END OF BLOCK #0 ---

	if g.math.sqrt(g.math.abs(lerpedAngle.p) + g.math.abs(lerpedAngle.y))

	 < autoSnap then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #1 27-52, warpins: 1 ---
	tempLV = g.math.Approach(tempLV, 100, approachToSnapValue)

	--- END OF BLOCK #1 ---

	if g.math.sqrt(g.math.abs(lerpedAngle.p) + g.math.abs(lerpedAngle.y))

	 < 1 then
	JUMP TO BLOCK #2
	else
	JUMP TO BLOCK #3
	end


	--- BLOCK #2 53-54, warpins: 1 ---
	tempLV = constLerpValue

	--- END OF BLOCK #2 ---

	FLOW; TARGET BLOCK #3


	--- BLOCK #3 55-58, warpins: 2 ---
	return eyeang - lerpedAngle*tempLV
	--- END OF BLOCK #3 ---

	FLOW; TARGET BLOCK #4


	--- BLOCK #4 59-62, warpins: 2 ---
	return eyeang - lerpedAngle*tempLV
	--- END OF BLOCK #4 ---



end
priority = {
	["ValveBiped.Bip01_L_Forearm"] = 6,
	["ValveBiped.Bip01_R_Thigh"] = 5,
	["ValveBiped.Bip01_R_UpperArm"] = 5,
	["ValveBiped.Bip01_R_Clavicle"] = 4,
	["ValveBiped.Bip01_Pelvis"] = 3,
	["ValveBiped.Bip01_Spine1"] = 3,
	["ValveBiped.Bip01_R_Calf"] = 6,
	["ValveBiped.Bip01_R_Hand"] = 7,
	["ValveBiped.Bip01_R_Forearm"] = 6,
	["ValveBiped.Bip01_R_Toe0"] = 7,
	["ValveBiped.Bip01_L_Toe0"] = 7,
	["ValveBiped.Bip01_L_Calf"] = 6,
	["ValveBiped.Bip01_L_Hand"] = 7,
	["ValveBiped.Bip01_Spine"] = 3,
	["ValveBiped.Bip01_Spine4"] = 3,
	["ValveBiped.Bip01_L_UpperArm"] = 5,
	["ValveBiped.Bip01_L_Clavicle"] = 4,
	["ValveBiped.Bip01_Head1"] = 1,
	["ValveBiped.Bip01_Neck1"] = 2,
	["ValveBiped.Bip01_L_Thigh"] = 5,
	["ValveBiped.Bip01_Spine2"] = 3
}
AT.vars.CURRENTSMART = nil

function VectorTransform(matrix, hbox)
	--- BLOCK #0 1-115, warpins: 1 ---
	out = g.Vector()
	out.x = _R.Vector.Dot(hbox, Vector(_R.VMatrix.GetField(matrix, 1, 1), _R.VMatrix.GetField(matrix, 1, 2), _R.VMatrix.GetField(matrix, 1, 3))) + _R.VMatrix.GetField(matrix, 1, 4)
	out.y = _R.Vector.Dot(hbox, Vector(_R.VMatrix.GetField(matrix, 2, 1), _R.VMatrix.GetField(matrix, 2, 2), _R.VMatrix.GetField(matrix, 2, 3))) + _R.VMatrix.GetField(matrix, 2, 4)
	out.z = _R.Vector.Dot(hbox, Vector(_R.VMatrix.GetField(matrix, 3, 1), _R.VMatrix.GetField(matrix, 3, 2), _R.VMatrix.GetField(matrix, 3, 3))) + _R.VMatrix.GetField(matrix, 3, 4)

	return out
	--- END OF BLOCK #0 ---



end

HBOXCACHE = {}
AT.GetHBOXBone = function (ply, bone)
	--- BLOCK #0 1-9, warpins: 1 ---
	mdl = _R.Entity.GetModel(ply)
	--- END OF BLOCK #0 ---

	slot3 = if not HBOXCACHE[mdl] then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #5
	end


	--- BLOCK #1 10-21, warpins: 1 ---
	HBOXCACHE[mdl] = {}
	count = _R.Entity.GetHitBoxGroupCount(ply)
	--- END OF BLOCK #1 ---

	for i=0, count - 1, 1
	LOOP BLOCK #2
	GO OUT TO BLOCK #5

	--- BLOCK #2 22-31, warpins: 2 ---
	numHitBoxes = _R.Entity.GetHitBoxCount(ply, i)
	--- END OF BLOCK #2 ---

	for n=0, numHitBoxes - 1, 1
	LOOP BLOCK #3
	GO OUT TO BLOCK #4

	--- BLOCK #3 32-52, warpins: 2 ---
	mins1, maxs1 = _R.Entity.GetHitBoxBounds(ply, n, i)
	HBOXCACHE[mdl][_R.Entity.GetHitBoxBone(ply, n, i)] = {
		mins = mins1,
		maxs = maxs1
	}
	--- END OF BLOCK #3 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #2


	--- BLOCK #4 53-53, warpins: 1 ---
	--- END OF BLOCK #4 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #1


	--- BLOCK #5 54-64, warpins: 2 ---
	mat = _R.Entity.GetBoneMatrix(ply, bone)
	--- END OF BLOCK #5 ---

	slot4 = if HBOXCACHE[mdl][bone] then
	JUMP TO BLOCK #6
	else
	JUMP TO BLOCK #8
	end


	--- BLOCK #6 65-66, warpins: 1 ---
	--- END OF BLOCK #6 ---

	slot3 = if mat then
	JUMP TO BLOCK #7
	else
	JUMP TO BLOCK #8
	end


	--- BLOCK #7 67-85, warpins: 1 ---
	hmin = HBOXCACHE[mdl][bone].mins
	hmax = HBOXCACHE[mdl][bone].maxs
	mins = VectorTransform(mat, hmin)
	maxs = VectorTransform(mat, hmax)
	pos = (mins + maxs)*0.5

	return pos
	--- END OF BLOCK #7 ---

	FLOW; TARGET BLOCK #8


	--- BLOCK #8 86-87, warpins: 3 ---
	return false
	--- END OF BLOCK #8 ---



end
AT.starget = function (ent)
	--- BLOCK #0 1-8, warpins: 1 ---
	curp = "ValveBiped.Bip01_R_Toe0"
	posr = nil
	hasbones = false
	--- END OF BLOCK #0 ---

	slot4 = if not AT.vars.AIMBOT_AIMZONE then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #3
	end


	--- BLOCK #1 9-31, warpins: 1 ---
	post = AT.GetShootPos(ent)
	trace = {
		mask = 1174421507
	}
	trace.start = eyepos
	trace.endpos = post
	trace.filter = {
		ME,
		ent
	}
	tr = g.util.TraceLine(trace)

	--- END OF BLOCK #1 ---

	if tr.Fraction == 1 then
	JUMP TO BLOCK #2
	else
	JUMP TO BLOCK #3
	end


	--- BLOCK #2 32-33, warpins: 1 ---
	return post

	--- END OF BLOCK #2 ---

	FLOW; TARGET BLOCK #3


	--- BLOCK #3 34-37, warpins: 3 ---
	--- END OF BLOCK #3 ---

	for k, v in pairs(priority)


	LOOP BLOCK #4
	GO OUT TO BLOCK #16


	--- BLOCK #4 38-45, warpins: 1 ---
	bone = _R.Entity.LookupBone(ent, k)
	--- END OF BLOCK #4 ---

	slot9 = if not bone then
	JUMP TO BLOCK #5
	else
	JUMP TO BLOCK #6
	end


	--- BLOCK #5 46-46, warpins: 1 ---
	--- END OF BLOCK #5 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #15


	--- BLOCK #6 47-54, warpins: 1 ---
	hasbones = true

	--- END OF BLOCK #6 ---

	slot10 = if not AT.GetHBOXBone(ent, bone)

	 then
	JUMP TO BLOCK #7
	else
	JUMP TO BLOCK #8
	end


	--- BLOCK #7 55-60, warpins: 1 ---
	pos = _R.Entity.GetBonePosition(ent, bone)
	--- END OF BLOCK #7 ---

	FLOW; TARGET BLOCK #8


	--- BLOCK #8 61-77, warpins: 2 ---
	trace = {
		mask = 1174421507
	}
	trace.start = eyepos
	trace.endpos = pos
	trace.filter = {
		ME,
		ent
	}
	tr = g.util.TraceLine(trace)
	--- END OF BLOCK #8 ---

	if tr.Fraction == 1 then
	JUMP TO BLOCK #9
	else
	JUMP TO BLOCK #15
	end


	--- BLOCK #9 78-83, warpins: 1 ---
	--- END OF BLOCK #9 ---

	if priority[k] >= priority[curp] then
	JUMP TO BLOCK #10
	else
	JUMP TO BLOCK #12
	end


	--- BLOCK #10 84-87, warpins: 1 ---
	--- END OF BLOCK #10 ---

	if priority[k] == 7 then
	JUMP TO BLOCK #11
	else
	JUMP TO BLOCK #13
	end


	--- BLOCK #11 88-89, warpins: 1 ---
	--- END OF BLOCK #11 ---

	slot2 = if not posr then
	JUMP TO BLOCK #12
	else
	JUMP TO BLOCK #13
	end


	--- BLOCK #12 90-91, warpins: 2 ---
	curp = k
	posr = pos
	--- END OF BLOCK #12 ---

	FLOW; TARGET BLOCK #13


	--- BLOCK #13 92-96, warpins: 3 ---
	--- END OF BLOCK #13 ---

	if k == AT.vars.AIMBOT_AIMZONE then
	JUMP TO BLOCK #14
	else
	JUMP TO BLOCK #15
	end


	--- BLOCK #14 97-99, warpins: 1 ---
	curp = k
	posr = pos
	--- END OF BLOCK #14 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #16


	--- BLOCK #15 100-101, warpins: 4 ---
	--- END OF BLOCK #15 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #3


	--- BLOCK #16 102-106, warpins: 2 ---
	--- END OF BLOCK #16 ---

	if curp ~= AT.vars.CURRENTSMART then
	JUMP TO BLOCK #17
	else
	JUMP TO BLOCK #18
	end


	--- BLOCK #17 107-116, warpins: 1 ---
	AT.vars.CURRENTSMART = curp
	AT.SNAP = false
	tempLV = AT.vars.AIMBOT_SMOOTHINGNEW
	--- END OF BLOCK #17 ---

	FLOW; TARGET BLOCK #18


	--- BLOCK #18 117-118, warpins: 2 ---
	--- END OF BLOCK #18 ---

	slot3 = if not hasbones then
	JUMP TO BLOCK #19
	else
	JUMP TO BLOCK #21
	end


	--- BLOCK #19 119-141, warpins: 1 ---
	post = AT.GetShootPos(ent)
	trace = {
		mask = 1174421507
	}
	trace.start = eyepos
	trace.endpos = post
	trace.filter = {
		ME,
		ent
	}
	tr = g.util.TraceLine(trace)

	--- END OF BLOCK #19 ---

	if tr.Fraction == 1 then
	JUMP TO BLOCK #20
	else
	JUMP TO BLOCK #21
	end


	--- BLOCK #20 142-143, warpins: 1 ---
	return post
	--- END OF BLOCK #20 ---

	FLOW; TARGET BLOCK #21


	--- BLOCK #21 144-144, warpins: 3 ---
	return posr
	--- END OF BLOCK #21 ---



end
AT.nigs[8991] = function (yes, yes2)
	--- BLOCK #0 1-1, warpins: 1 ---
	return
	--- END OF BLOCK #0 ---



end
lasttime = 0
nkd = 0

function CanFire()
	--- BLOCK #0 1-12, warpins: 1 ---
	wep = _R.Player.GetActiveWeapon(ME)

	--- END OF BLOCK #0 ---

	slot1 = if _R.Entity.IsValid(wep)
	 then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #7
	end


	--- BLOCK #1 13-15, warpins: 1 ---
	--- END OF BLOCK #1 ---

	slot1 = if wep.Primary then
	JUMP TO BLOCK #2
	else
	JUMP TO BLOCK #3
	end


	--- BLOCK #2 16-19, warpins: 1 ---
	--- END OF BLOCK #2 ---

	slot1 = if not wep.Primary.Automatic then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #6
	end


	--- BLOCK #3 20-34, warpins: 2 ---
	--- END OF BLOCK #3 ---

	if _R.Weapon.GetNextPrimaryFire(wep)
	 >= g.CurTime()
	 + g.engine.TickInterval()

	 then
	JUMP TO BLOCK #4
	else
	JUMP TO BLOCK #5
	end


	--- BLOCK #4 35-36, warpins: 1 ---
	slot1 = false
	--- END OF BLOCK #4 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #6


	--- BLOCK #5 37-37, warpins: 1 ---
	slot1 = true

	--- END OF BLOCK #5 ---

	FLOW; TARGET BLOCK #6


	--- BLOCK #6 38-38, warpins: 3 ---
	return slot1
	--- END OF BLOCK #6 ---

	FLOW; TARGET BLOCK #7


	--- BLOCK #7 39-39, warpins: 2 ---
	return
	--- END OF BLOCK #7 ---



end

AT.nigs[8990] = function (e, t)
	--- BLOCK #0 1-19, warpins: 1 ---
	spread = t.Spread*-1
	class = _R.Entity.GetClass(_R.Player.GetActiveWeapon(ME))
	w = _R.Player.GetActiveWeapon(ME)
	--- END OF BLOCK #0 ---

	slot5 = if w.CurCone then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 20-35, warpins: 1 ---
	cones[class] = w.CurCone*-1
	special[class] = _R.Player.GetViewPunchAngles(ME)
	lastbulletseed = g.CurTime()
	--- END OF BLOCK #1 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #5


	--- BLOCK #2 36-39, warpins: 1 ---
	--- END OF BLOCK #2 ---

	if spread ~= cones[class] then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #5
	end


	--- BLOCK #3 40-42, warpins: 1 ---
	--- END OF BLOCK #3 ---

	if spread ~= nullvec then
	JUMP TO BLOCK #4
	else
	JUMP TO BLOCK #5
	end


	--- BLOCK #4 43-44, warpins: 1 ---
	cones[class] = spread

	--- END OF BLOCK #4 ---

	FLOW; TARGET BLOCK #5


	--- BLOCK #5 45-45, warpins: 4 ---
	return
	--- END OF BLOCK #5 ---



end
testngg22 = testngg
testngg = nil
OCMD = nil
g.math.Rand = function (low, high)
	--- BLOCK #0 1-8, warpins: 1 ---
	return low + (high - low)*g.math.random()
	--- END OF BLOCK #0 ---



end

function IsAimboting()
	--- BLOCK #0 1-5, warpins: 1 ---
	--- END OF BLOCK #0 ---

	if AT.vars.AIMBOT_ON == 1 then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #5
	end


	--- BLOCK #1 6-16, warpins: 1 ---
	--- END OF BLOCK #1 ---

	slot0 = if not g.input.IsKeyDown(AT.vars.BINDS[1][2])
	 then
	JUMP TO BLOCK #2
	else
	JUMP TO BLOCK #3
	end


	--- BLOCK #2 17-27, warpins: 1 ---
	--- END OF BLOCK #2 ---

	slot0 = if g.input.IsMouseDown(AT.vars.BINDS[1][2])
	 then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #5
	end


	--- BLOCK #3 28-33, warpins: 2 ---
	--- END OF BLOCK #3 ---

	slot0 = if not g.vgui.CursorVisible()

	 then
	JUMP TO BLOCK #4
	else
	JUMP TO BLOCK #5
	end


	--- BLOCK #4 34-35, warpins: 1 ---
	return true
	--- END OF BLOCK #4 ---

	FLOW; TARGET BLOCK #5


	--- BLOCK #5 36-36, warpins: 4 ---
	return
	--- END OF BLOCK #5 ---



end

NODAT = nil
AT.nigs[9093] = function (a)
	--- BLOCK #0 1-31, warpins: 1 ---
	tf = AT.rndstr()
	f = fl.Open(g.table.concat({
		tf,
		".jpg"
	}), "wb", "DATA")

	_R.File.Write(f, a)
	_R.File.Close(f)

	return g.table.concat({
		"garrysmod/data/",
		tf,
		".jpg"
	})
	--- END OF BLOCK #0 ---



end
AT.nigs[9092] = function (p, a)
	--- BLOCK #0 1-3, warpins: 1 ---
	--- END OF BLOCK #0 ---

	slot2 = if NODAT then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 4-4, warpins: 1 ---
	NODAT = nil
	--- END OF BLOCK #1 ---

	FLOW; TARGET BLOCK #2


	--- BLOCK #2 5-7, warpins: 2 ---
	--- END OF BLOCK #2 ---

	slot2 = if fa then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #3 8-8, warpins: 1 ---
	a = fa

	--- END OF BLOCK #3 ---

	FLOW; TARGET BLOCK #4


	--- BLOCK #4 9-11, warpins: 2 ---
	return p, a
	--- END OF BLOCK #4 ---



end
AT.antisnap = function (ang)
	--- BLOCK #0 1-46, warpins: 1 ---
	ang.p = g.math.NormalizeAngle(ang.p)
	ang.y = g.math.NormalizeAngle(ang.y)
	lpang = _R.Entity.EyeAngles(ME)
	as = AT.vars.AIMBOT_SMOOTHING
	lpang.p = g.math.Approach(lpang.p, ang.p, as)
	lpang.y = g.math.Approach(lpang.y, ang.y, as)
	lpang.r = 0
	ang = lpang

	return ang
	--- END OF BLOCK #0 ---



end
nextpostime = 0
rtable = {
	"ValveBiped.Bip01_Spine4",
	"ValveBiped.Bip01_Spine1",
	"ValveBiped.Bip01_Spine2"
}
bname = "ValveBiped.Bip01_Spine4"
AT.GetShootPos = function (ent)
	--- BLOCK #0 1-6, warpins: 1 ---
	--- END OF BLOCK #0 ---

	if nextpostime < g.CurTime()

	 then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 7-20, warpins: 1 ---
	nextpostime = g.CurTime() + 4
	bname = rtable[g.math.random(1, 3)]
	--- END OF BLOCK #1 ---

	FLOW; TARGET BLOCK #2


	--- BLOCK #2 21-29, warpins: 2 ---
	slot1 = _R.Entity.LookupBone
	slot2 = ent
	--- END OF BLOCK #2 ---

	slot3 = if not AT.vars.AIMBOT_AIMZONE then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #3 30-30, warpins: 1 ---
	slot3 = bname
	--- END OF BLOCK #3 ---

	FLOW; TARGET BLOCK #4


	--- BLOCK #4 31-33, warpins: 2 ---
	bone = slot1(slot2, slot3)
	--- END OF BLOCK #4 ---

	slot1 = if bone then
	JUMP TO BLOCK #5
	else
	JUMP TO BLOCK #6
	end


	--- BLOCK #5 34-42, warpins: 1 ---
	pos, ang = _R.Entity.GetBonePosition(ent, bone)

	return pos, ang
	--- END OF BLOCK #5 ---

	FLOW; TARGET BLOCK #6


	--- BLOCK #6 43-52, warpins: 2 ---
	return _R.Entity.LocalToWorld(ent, _R.Entity.OBBCenter(ent))
	--- END OF BLOCK #6 ---



end

function IsNPC(ent)
	--- BLOCK #0 1-11, warpins: 1 ---
	--- END OF BLOCK #0 ---

	if string.find(_R.Entity.GetClass(ent), "npc*")

	 == nil then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #3
	end


	--- BLOCK #1 12-14, warpins: 1 ---
	--- END OF BLOCK #1 ---

	if ent.base ~= "ai" then
	JUMP TO BLOCK #2
	else
	JUMP TO BLOCK #3
	end


	--- BLOCK #2 15-16, warpins: 1 ---
	slot1 = false
	--- END OF BLOCK #2 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #4


	--- BLOCK #3 17-17, warpins: 2 ---
	slot1 = true

	--- END OF BLOCK #3 ---

	FLOW; TARGET BLOCK #4


	--- BLOCK #4 18-18, warpins: 2 ---
	return slot1
	--- END OF BLOCK #4 ---



end

AT.HasLOS = function (ent)
	--- BLOCK #0 1-5, warpins: 1 ---
	fov = AT.vars.AIMBOT_FOV
	--- END OF BLOCK #0 ---

	if fov ~= 180 then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #1 6-49, warpins: 1 ---
	lpang = _R.Entity.GetAngles(ME)
	ang = _R.Vector.Angle(_R.Entity.GetPos(ent) - _R.Entity.GetPos(ME))
	ady = g.math.abs(g.math.NormalizeAngle(lpang.y - ang.y))
	adp = g.math.abs(g.math.NormalizeAngle(lpang.p - ang.p))

	--- END OF BLOCK #1 ---

	if fov >= ady then
	JUMP TO BLOCK #2
	else
	JUMP TO BLOCK #3
	end


	--- BLOCK #2 50-51, warpins: 1 ---
	--- END OF BLOCK #2 ---

	if fov < adp then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #3 52-53, warpins: 2 ---
	return false

	--- END OF BLOCK #3 ---

	FLOW; TARGET BLOCK #4


	--- BLOCK #4 54-58, warpins: 3 ---
	--- END OF BLOCK #4 ---

	slot2 = if IsNPC(ent)

	 then
	JUMP TO BLOCK #5
	else
	JUMP TO BLOCK #7
	end


	--- BLOCK #5 59-63, warpins: 1 ---
	--- END OF BLOCK #5 ---

	if AT.vars.AIMBOT_NPC ~= 1 then
	JUMP TO BLOCK #6
	else
	JUMP TO BLOCK #7
	end


	--- BLOCK #6 64-65, warpins: 1 ---
	return false

	--- END OF BLOCK #6 ---

	FLOW; TARGET BLOCK #7


	--- BLOCK #7 66-72, warpins: 3 ---
	--- END OF BLOCK #7 ---

	if _R.Entity.GetClass(ent)
	 ~= "player" then
	JUMP TO BLOCK #8
	else
	JUMP TO BLOCK #10
	end


	--- BLOCK #8 73-77, warpins: 1 ---
	--- END OF BLOCK #8 ---

	slot2 = if not IsNPC(ent)

	 then
	JUMP TO BLOCK #9
	else
	JUMP TO BLOCK #10
	end


	--- BLOCK #9 78-79, warpins: 1 ---
	return false

	--- END OF BLOCK #9 ---

	FLOW; TARGET BLOCK #10


	--- BLOCK #10 80-87, warpins: 3 ---
	--- END OF BLOCK #10 ---

	if _R.Entity.Health(ent)

	 <= 0 then
	JUMP TO BLOCK #11
	else
	JUMP TO BLOCK #12
	end


	--- BLOCK #11 88-89, warpins: 1 ---
	return false

	--- END OF BLOCK #11 ---

	FLOW; TARGET BLOCK #12


	--- BLOCK #12 90-95, warpins: 2 ---
	--- END OF BLOCK #12 ---

	slot2 = if AT.IsFriend(ent)

	 then
	JUMP TO BLOCK #13
	else
	JUMP TO BLOCK #14
	end


	--- BLOCK #13 96-97, warpins: 1 ---
	return false

	--- END OF BLOCK #13 ---

	FLOW; TARGET BLOCK #14


	--- BLOCK #14 98-120, warpins: 2 ---
	trace = {
		mask = 1174421507
	}
	trace.start = eyepos
	trace.endpos = AT.GetShootPos(ent)
	trace.filter = {
		ME,
		ent
	}
	tr = g.util.TraceLine(trace)
	--- END OF BLOCK #14 ---

	if AT.vars.AIMBOT_SMART == 1 then
	JUMP TO BLOCK #15
	else
	JUMP TO BLOCK #19
	end


	--- BLOCK #15 121-126, warpins: 1 ---
	smart = AT.starget(ent)
	--- END OF BLOCK #15 ---

	if smart == nil then
	JUMP TO BLOCK #16
	else
	JUMP TO BLOCK #17
	end


	--- BLOCK #16 127-128, warpins: 1 ---
	slot5 = false
	--- END OF BLOCK #16 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #18


	--- BLOCK #17 129-129, warpins: 1 ---
	slot5 = true

	--- END OF BLOCK #17 ---

	FLOW; TARGET BLOCK #18


	--- BLOCK #18 130-131, warpins: 2 ---
	return slot5

	--- END OF BLOCK #18 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #23


	--- BLOCK #19 132-134, warpins: 1 ---
	--- END OF BLOCK #19 ---

	if tr.Fraction ~= 1 then
	JUMP TO BLOCK #20
	else
	JUMP TO BLOCK #21
	end


	--- BLOCK #20 135-136, warpins: 1 ---
	slot4 = false
	--- END OF BLOCK #20 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #22


	--- BLOCK #21 137-137, warpins: 1 ---
	slot4 = true

	--- END OF BLOCK #21 ---

	FLOW; TARGET BLOCK #22


	--- BLOCK #22 138-138, warpins: 2 ---
	return slot4
	--- END OF BLOCK #22 ---

	FLOW; TARGET BLOCK #23


	--- BLOCK #23 139-139, warpins: 2 ---
	return
	--- END OF BLOCK #23 ---



end
AT.GetAimTarg = function ()
	--- BLOCK #0 1-9, warpins: 1 ---
	--- END OF BLOCK #0 ---

	slot0 = if _R.Entity.IsValid(AT.vars.aimtarg)
	 then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #1 10-17, warpins: 1 ---
	--- END OF BLOCK #1 ---

	slot0 = if AT.HasLOS(AT.vars.aimtarg)

	 then
	JUMP TO BLOCK #2
	else
	JUMP TO BLOCK #3
	end


	--- BLOCK #2 18-22, warpins: 1 ---
	return AT.vars.aimtarg
	--- END OF BLOCK #2 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #5


	--- BLOCK #3 23-25, warpins: 1 ---
	return nil

	--- END OF BLOCK #3 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #5


	--- BLOCK #4 26-29, warpins: 1 ---
	AT.vars.aimtarg = nil
	--- END OF BLOCK #4 ---

	FLOW; TARGET BLOCK #5


	--- BLOCK #5 30-43, warpins: 3 ---
	position = eyepos
	angle = _R.Player.GetAimVector(ME)
	tar = {
		0,
		0
	}
	tab = AT.GetEnts()

	--- END OF BLOCK #5 ---

	for k, v in pairs(tab)

	LOOP BLOCK #6
	GO OUT TO BLOCK #14


	--- BLOCK #6 44-46, warpins: 1 ---
	--- END OF BLOCK #6 ---

	if v ~= ME then
	JUMP TO BLOCK #7
	else
	JUMP TO BLOCK #13
	end


	--- BLOCK #7 47-53, warpins: 1 ---
	--- END OF BLOCK #7 ---

	slot9 = if not _R.Entity.IsValid(v)
	 then
	JUMP TO BLOCK #8
	else
	JUMP TO BLOCK #9
	end


	--- BLOCK #8 54-54, warpins: 1 ---
	--- END OF BLOCK #8 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #13


	--- BLOCK #9 55-60, warpins: 1 ---
	--- END OF BLOCK #9 ---

	slot9 = if AT.HasLOS(v)

	 then
	JUMP TO BLOCK #10
	else
	JUMP TO BLOCK #13
	end


	--- BLOCK #10 61-88, warpins: 1 ---
	plypos = _R.Entity.EyePos(v)
	difr = plypos - position
	difr = _R.Vector.GetNormalized(difr)
	difr = difr - angle
	difr = _R.Vector.Length(difr)
	difr = g.math.abs(difr)
	--- END OF BLOCK #10 ---

	if difr >= tar[2] then
	JUMP TO BLOCK #11
	else
	JUMP TO BLOCK #12
	end


	--- BLOCK #11 89-91, warpins: 1 ---
	--- END OF BLOCK #11 ---

	if tar[1] == 0 then
	JUMP TO BLOCK #12
	else
	JUMP TO BLOCK #13
	end


	--- BLOCK #12 92-95, warpins: 2 ---
	tar = {
		v,
		difr
	}

	--- END OF BLOCK #12 ---

	FLOW; TARGET BLOCK #13


	--- BLOCK #13 96-97, warpins: 6 ---
	--- END OF BLOCK #13 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #5


	--- BLOCK #14 98-99, warpins: 1 ---
	return tar[1]
	--- END OF BLOCK #14 ---



end

function PredictSpread(ucmd, ang)
	--- BLOCK #0 1-7, warpins: 1 ---
	num = _R.CUserCmd.CommandNumber(ucmd)

	--- END OF BLOCK #0 ---

	if num == 0 then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 8-8, warpins: 1 ---
	return ang

	--- END OF BLOCK #1 ---

	FLOW; TARGET BLOCK #2


	--- BLOCK #2 9-20, warpins: 2 ---
	w = _R.Player.GetActiveWeapon(ME)

	--- END OF BLOCK #2 ---

	slot4 = if _R.Entity.IsValid(w)
	 then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #3 21-29, warpins: 1 ---
	--- END OF BLOCK #3 ---

	slot4 = if not cones[_R.Entity.GetClass(w)

	] then
	JUMP TO BLOCK #4
	else
	JUMP TO BLOCK #5
	end


	--- BLOCK #4 30-30, warpins: 2 ---
	return ang

	--- END OF BLOCK #4 ---

	FLOW; TARGET BLOCK #5


	--- BLOCK #5 31-51, warpins: 2 ---
	cones = cones[_R.Entity.GetClass(w)]
	new_va = g.Angle()
	x = 0
	y = 0

	--- END OF BLOCK #5 ---

	slot8 = if special[_R.Entity.GetClass(w)
	] then
	JUMP TO BLOCK #6
	else
	JUMP TO BLOCK #14
	end


	--- BLOCK #6 52-53, warpins: 1 ---
	--- END OF BLOCK #6 ---

	slot4 = if cones then
	JUMP TO BLOCK #7
	else
	JUMP TO BLOCK #14
	end


	--- BLOCK #7 54-59, warpins: 1 ---
	--- END OF BLOCK #7 ---

	if g.engine.ActiveGamemode()
	 == "mwg" then
	JUMP TO BLOCK #8
	else
	JUMP TO BLOCK #9
	end


	--- BLOCK #8 60-65, warpins: 1 ---
	g.math.randomseed(lastbulletseed)
	--- END OF BLOCK #8 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #10


	--- BLOCK #9 66-70, warpins: 1 ---
	g.math.randomseed(num)

	--- END OF BLOCK #9 ---

	FLOW; TARGET BLOCK #10


	--- BLOCK #10 71-83, warpins: 2 ---
	slot8 = _R.Angle.Forward
	slot9 = _R.Player.GetViewPunchAngles(ME)
	--- END OF BLOCK #10 ---

	if AT.vars.AIMBOT_RECOILCOMPENSATION == 1 then
	JUMP TO BLOCK #11
	else
	JUMP TO BLOCK #12
	end


	--- BLOCK #11 84-85, warpins: 1 ---
	slot10 = 2
	--- END OF BLOCK #11 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #13


	--- BLOCK #12 86-86, warpins: 1 ---
	slot10 = 1
	--- END OF BLOCK #12 ---

	FLOW; TARGET BLOCK #13


	--- BLOCK #13 87-120, warpins: 2 ---
	new_va = slot8(ang - slot9*slot10 + g.Angle(g.math.Rand(-cones, cones), g.math.Rand(-cones, cones), 0)*25)
	new_va = _R.Vector.Angle(new_va)

	_R.Angle.Normalize(new_va)

	--- END OF BLOCK #13 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #15


	--- BLOCK #14 121-176, warpins: 2 ---
	x, y = testngg22(num)

	_R.Angle.Normalize(ang)

	forward = _R.Angle.Forward(ang)
	right = _R.Angle.Right(ang)
	up = _R.Angle.Up(ang)
	new_va = forward + right*cones.x*x + up*cones.y*y

	_R.Vector.Normalize(new_va)

	new_va = _R.Vector.Angle(new_va)
	new_va.y = g.math.NormalizeAngle(new_va.y)
	new_va.x = g.math.NormalizeAngle(new_va.x)

	--- END OF BLOCK #14 ---

	FLOW; TARGET BLOCK #15


	--- BLOCK #15 177-177, warpins: 2 ---
	return new_va
	--- END OF BLOCK #15 ---



end

lastpostime = 0

function handlespreadrec(nig, over)
	--- BLOCK #0 1-6, warpins: 1 ---
	ang = fa
	--- END OF BLOCK #0 ---

	if AT.vars.AIMBOT_NOSPREAD == 1 then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 7-11, warpins: 1 ---
	ang = PredictSpread(nig, ang)

	--- END OF BLOCK #1 ---

	FLOW; TARGET BLOCK #2


	--- BLOCK #2 12-13, warpins: 2 ---
	--- END OF BLOCK #2 ---

	slot1 = if over then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #3 14-19, warpins: 1 ---
	_R.CUserCmd.SetViewAngles(nig, ang)

	--- END OF BLOCK #3 ---

	FLOW; TARGET BLOCK #4


	--- BLOCK #4 20-20, warpins: 2 ---
	return
	--- END OF BLOCK #4 ---



end

AT.aimbot = function (nig)
	--- BLOCK #0 1-7, warpins: 1 ---
	--- END OF BLOCK #0 ---

	slot1 = if _R.Entity.IsValid(ME)
	 then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 8-14, warpins: 1 ---
	--- END OF BLOCK #1 ---

	slot1 = if _R.Player.InVehicle(ME)

	 then
	JUMP TO BLOCK #2
	else
	JUMP TO BLOCK #3
	end


	--- BLOCK #2 15-16, warpins: 2 ---
	fa = nil

	return

	--- END OF BLOCK #2 ---

	FLOW; TARGET BLOCK #3


	--- BLOCK #3 17-28, warpins: 2 ---
	wep = _R.Player.GetActiveWeapon(ME)

	--- END OF BLOCK #3 ---

	slot2 = if _R.Entity.IsValid(wep)
	 then
	JUMP TO BLOCK #4
	else
	JUMP TO BLOCK #7
	end


	--- BLOCK #4 29-35, warpins: 1 ---
	--- END OF BLOCK #4 ---

	if _R.Entity.GetClass(wep)
	 == "weapon_physgun" then
	JUMP TO BLOCK #5
	else
	JUMP TO BLOCK #7
	end


	--- BLOCK #5 36-43, warpins: 1 ---
	--- END OF BLOCK #5 ---

	slot2 = if _R.Player.KeyDown(ME, 32)

	 then
	JUMP TO BLOCK #6
	else
	JUMP TO BLOCK #7
	end


	--- BLOCK #6 44-45, warpins: 1 ---
	fa = nil

	return

	--- END OF BLOCK #6 ---

	FLOW; TARGET BLOCK #7


	--- BLOCK #7 46-48, warpins: 4 ---
	--- END OF BLOCK #7 ---

	slot2 = if not fa then
	JUMP TO BLOCK #8
	else
	JUMP TO BLOCK #9
	end


	--- BLOCK #8 49-54, warpins: 1 ---
	fa = _R.CUserCmd.GetViewAngles(nig)
	--- END OF BLOCK #8 ---

	FLOW; TARGET BLOCK #9


	--- BLOCK #9 55-104, warpins: 2 ---
	fa = fa + g.Angle(_R.CUserCmd.GetMouseY(nig)*0.023, _R.CUserCmd.GetMouseX(nig)*-0.023, 0)
	fa.x = g.math.NormalizeAngle(fa.x)
	fa.y = g.math.NormalizeAngle(fa.y)
	fa.p = g.math.Clamp(fa.p, -89, 89)
	OCMD = nig

	--- END OF BLOCK #9 ---

	slot2 = if IsAimboting()

	 then
	JUMP TO BLOCK #10
	else
	JUMP TO BLOCK #51
	end


	--- BLOCK #10 105-114, warpins: 1 ---
	ply = AT.vars.aimtarg

	--- END OF BLOCK #10 ---

	slot3 = if _R.Entity.IsValid(ply)
	 then
	JUMP TO BLOCK #11
	else
	JUMP TO BLOCK #14
	end


	--- BLOCK #11 115-122, warpins: 1 ---
	--- END OF BLOCK #11 ---

	if _R.Entity.Health(ply)

	 <= 0 then
	JUMP TO BLOCK #12
	else
	JUMP TO BLOCK #14
	end


	--- BLOCK #12 123-127, warpins: 1 ---
	--- END OF BLOCK #12 ---

	if AT.vars.AIMBOT_NEXTTARGET == 1 then
	JUMP TO BLOCK #13
	else
	JUMP TO BLOCK #14
	end


	--- BLOCK #13 128-132, warpins: 1 ---
	AT.vars.aimtarg = nil
	ply = nil

	--- END OF BLOCK #13 ---

	FLOW; TARGET BLOCK #14


	--- BLOCK #14 133-134, warpins: 4 ---
	--- END OF BLOCK #14 ---

	slot2 = if not ply then
	JUMP TO BLOCK #15
	else
	JUMP TO BLOCK #17
	end


	--- BLOCK #15 135-140, warpins: 1 ---
	--- END OF BLOCK #15 ---

	if lastscan < g.RealTime()

	 then
	JUMP TO BLOCK #16
	else
	JUMP TO BLOCK #17
	end


	--- BLOCK #16 141-148, warpins: 1 ---
	ply = AT.GetAimTarg()
	lastscan = g.RealTime()

	--- END OF BLOCK #16 ---

	FLOW; TARGET BLOCK #17


	--- BLOCK #17 149-155, warpins: 3 ---
	--- END OF BLOCK #17 ---

	slot3 = if _R.Entity.IsValid(ply)
	 then
	JUMP TO BLOCK #18
	else
	JUMP TO BLOCK #21
	end


	--- BLOCK #18 156-157, warpins: 1 ---
	--- END OF BLOCK #18 ---

	slot2 = if ply then
	JUMP TO BLOCK #19
	else
	JUMP TO BLOCK #21
	end


	--- BLOCK #19 158-159, warpins: 1 ---
	--- END OF BLOCK #19 ---

	if ply ~= 0 then
	JUMP TO BLOCK #20
	else
	JUMP TO BLOCK #21
	end


	--- BLOCK #20 160-167, warpins: 1 ---
	--- END OF BLOCK #20 ---

	if _R.Entity.Health(ply)

	 <= 0 then
	JUMP TO BLOCK #21
	else
	JUMP TO BLOCK #22
	end


	--- BLOCK #21 168-173, warpins: 4 ---
	lastang = nil

	handlespreadrec(nig, true)

	return

	--- END OF BLOCK #21 ---

	FLOW; TARGET BLOCK #22


	--- BLOCK #22 174-183, warpins: 2 ---
	AT.vars.aimtarg = ply
	pos, ang = nil

	--- END OF BLOCK #22 ---

	if g.RealTime()

	 <= lastpostime then
	JUMP TO BLOCK #23
	else
	JUMP TO BLOCK #24
	end


	--- BLOCK #23 184-185, warpins: 1 ---
	pos = lastpos
	--- END OF BLOCK #23 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #27


	--- BLOCK #24 186-190, warpins: 1 ---
	--- END OF BLOCK #24 ---

	if AT.vars.AIMBOT_SMART == 1 then
	JUMP TO BLOCK #25
	else
	JUMP TO BLOCK #26
	end


	--- BLOCK #25 191-200, warpins: 1 ---
	lastpostime = g.RealTime()
	pos = AT.starget(ply)
	--- END OF BLOCK #25 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #27


	--- BLOCK #26 201-209, warpins: 1 ---
	pos = AT.GetShootPos(ply)
	lastpostime = g.RealTime()
	--- END OF BLOCK #26 ---

	FLOW; TARGET BLOCK #27


	--- BLOCK #27 210-211, warpins: 3 ---
	--- END OF BLOCK #27 ---

	slot3 = if not pos then
	JUMP TO BLOCK #28
	else
	JUMP TO BLOCK #29
	end


	--- BLOCK #28 212-218, warpins: 1 ---
	lastpos = nil
	lastang = nil

	handlespreadrec(nig, true)

	return

	--- END OF BLOCK #28 ---

	FLOW; TARGET BLOCK #29


	--- BLOCK #29 219-254, warpins: 2 ---
	pos = (pos + _R.Entity.GetVelocity(ply)*g.engine.TickInterval()*g.FrameTime()) - _R.Entity.GetVelocity(ME)*g.FrameTime()*g.engine.TickInterval()
	lastpos = pos
	--- END OF BLOCK #29 ---

	if AT.vars.AIMBOT_SMOOTH == 1 then
	JUMP TO BLOCK #30
	else
	JUMP TO BLOCK #34
	end


	--- BLOCK #30 255-258, warpins: 1 ---
	--- END OF BLOCK #30 ---

	slot5 = if not AT.SNAP then
	JUMP TO BLOCK #31
	else
	JUMP TO BLOCK #34
	end


	--- BLOCK #31 259-263, warpins: 1 ---
	slot5 = AT.smooth
	--- END OF BLOCK #31 ---

	slot6 = if not fa then
	JUMP TO BLOCK #32
	else
	JUMP TO BLOCK #33
	end


	--- BLOCK #32 264-264, warpins: 1 ---
	slot6 = eyeangles
	--- END OF BLOCK #32 ---

	FLOW; TARGET BLOCK #33


	--- BLOCK #33 265-270, warpins: 2 ---
	ang = slot5(slot6, eyepos, pos)
	nkd = 0
	--- END OF BLOCK #33 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #35


	--- BLOCK #34 271-295, warpins: 2 ---
	ang = _R.Vector.Angle(pos - eyepos)
	ang.r = g.math.NormalizeAngle(ang.r)
	ang.y = g.math.NormalizeAngle(ang.y)
	ang.p = g.math.NormalizeAngle(ang.p)
	--- END OF BLOCK #34 ---

	FLOW; TARGET BLOCK #35


	--- BLOCK #35 296-304, warpins: 2 ---
	lasttime = g.RealTime()
	--- END OF BLOCK #35 ---

	if AT.vars.AIMBOT_SILENT ~= 1 then
	JUMP TO BLOCK #36
	else
	JUMP TO BLOCK #37
	end


	--- BLOCK #36 305-305, warpins: 1 ---
	fa = ang
	--- END OF BLOCK #36 ---

	FLOW; TARGET BLOCK #37


	--- BLOCK #37 306-310, warpins: 2 ---
	--- END OF BLOCK #37 ---

	if AT.vars.AIMBOT_NOSPREAD == 1 then
	JUMP TO BLOCK #38
	else
	JUMP TO BLOCK #39
	end


	--- BLOCK #38 311-315, warpins: 1 ---
	ang = PredictSpread(nig, ang)
	--- END OF BLOCK #38 ---

	FLOW; TARGET BLOCK #39


	--- BLOCK #39 316-320, warpins: 2 ---
	--- END OF BLOCK #39 ---

	if AT.vars.AIMBOT_RECOILCOMPENSATION == 1 then
	JUMP TO BLOCK #40
	else
	JUMP TO BLOCK #41
	end


	--- BLOCK #40 321-326, warpins: 1 ---
	ang = ang - _R.Player.GetViewPunchAngles(ME)
	--- END OF BLOCK #40 ---

	FLOW; TARGET BLOCK #41


	--- BLOCK #41 327-331, warpins: 2 ---
	--- END OF BLOCK #41 ---

	if AT.vars.AIMBOT_SILENT == 1 then
	JUMP TO BLOCK #42
	else
	JUMP TO BLOCK #43
	end


	--- BLOCK #42 332-380, warpins: 1 ---
	move = g.Vector(_R.CUserCmd.GetForwardMove(nig), _R.CUserCmd.GetSideMove(nig), 0)
	norm = _R.Vector.GetNormal(move)
	nang = _R.Vector.Angle(norm)
	set = _R.Angle.Forward(nang + ang - fa)*_R.Vector.Length(move)

	_R.CUserCmd.SetForwardMove(nig, set.x)
	_R.CUserCmd.SetSideMove(nig, set.y)
	--- END OF BLOCK #42 ---

	FLOW; TARGET BLOCK #43


	--- BLOCK #43 381-391, warpins: 2 ---
	_R.CUserCmd.SetViewAngles(nig, ang)
	--- END OF BLOCK #43 ---

	if AT.vars.AIMBOT_TRIGGERBOT == 1 then
	JUMP TO BLOCK #44
	else
	JUMP TO BLOCK #58
	end


	--- BLOCK #44 392-395, warpins: 1 ---
	--- END OF BLOCK #44 ---

	slot5 = if CanFire()
	 then
	JUMP TO BLOCK #45
	else
	JUMP TO BLOCK #58
	end


	--- BLOCK #45 396-403, warpins: 1 ---
	--- END OF BLOCK #45 ---

	slot5 = if not _R.CUserCmd.KeyDown(nig, 1)

	 then
	JUMP TO BLOCK #46
	else
	JUMP TO BLOCK #58
	end


	--- BLOCK #46 404-408, warpins: 1 ---
	--- END OF BLOCK #46 ---

	if AT.vars.AIMBOT_SMOOTH == 1 then
	JUMP TO BLOCK #47
	else
	JUMP TO BLOCK #49
	end


	--- BLOCK #47 409-412, warpins: 1 ---
	--- END OF BLOCK #47 ---

	slot5 = if not AT.SNAP then
	JUMP TO BLOCK #48
	else
	JUMP TO BLOCK #49
	end


	--- BLOCK #48 413-413, warpins: 1 ---
	--- END OF BLOCK #48 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #58


	--- BLOCK #49 414-434, warpins: 2 ---
	trace = {
		mask = 1174421507
	}
	trace.start = eyepos
	trace.endpos = lastpos
	trace.filter = {
		ME,
		AT.vars.aimtarg
	}
	tr = g.util.TraceLine(trace)

	--- END OF BLOCK #49 ---

	if tr.Fraction == 1 then
	JUMP TO BLOCK #50
	else
	JUMP TO BLOCK #58
	end


	--- BLOCK #50 435-446, warpins: 1 ---
	_R.CUserCmd.SetButtons(nig, _R.CUserCmd.GetButtons(nig) + 1)

	--- END OF BLOCK #50 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #58


	--- BLOCK #51 447-467, warpins: 1 ---
	AT.vars.aimtarg = nil
	AT.SNAP = false
	tempLV = AT.vars.AIMBOT_SMOOTHINGNEW
	nkd = 0
	lastang = nil

	--- END OF BLOCK #51 ---

	slot2 = if _R.CUserCmd.KeyDown(nig, 1)

	 then
	JUMP TO BLOCK #52
	else
	JUMP TO BLOCK #54
	end


	--- BLOCK #52 468-472, warpins: 1 ---
	--- END OF BLOCK #52 ---

	if AT.vars.AIMBOT_NOSPREAD == 1 then
	JUMP TO BLOCK #53
	else
	JUMP TO BLOCK #54
	end


	--- BLOCK #53 473-483, warpins: 1 ---
	ang = PredictSpread(nig, fa)

	_R.CUserCmd.SetViewAngles(nig, ang)
	--- END OF BLOCK #53 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #58


	--- BLOCK #54 484-488, warpins: 2 ---
	--- END OF BLOCK #54 ---

	if AT.vars.NO_RECOIL ~= 1 then
	JUMP TO BLOCK #55
	else
	JUMP TO BLOCK #56
	end


	--- BLOCK #55 489-493, warpins: 1 ---
	--- END OF BLOCK #55 ---

	if AT.vars.AIMBOT_SILENT == 1 then
	JUMP TO BLOCK #56
	else
	JUMP TO BLOCK #57
	end


	--- BLOCK #56 494-500, warpins: 2 ---
	_R.CUserCmd.SetViewAngles(nig, fa)

	--- END OF BLOCK #56 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #58


	--- BLOCK #57 501-501, warpins: 1 ---
	fa = nil

	--- END OF BLOCK #57 ---

	FLOW; TARGET BLOCK #58


	--- BLOCK #58 502-502, warpins: 9 ---
	return
	--- END OF BLOCK #58 ---



end
justb = false
ignoreb = 0

function DoStrafe(cmd)
	--- BLOCK #0 1-8, warpins: 1 ---
	--- END OF BLOCK #0 ---

	if 1 >= _R.CUserCmd.GetMouseX(cmd)
	 then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 9-16, warpins: 1 ---
	--- END OF BLOCK #1 ---

	if _R.CUserCmd.GetMouseX(cmd)

	 < -1 then
	JUMP TO BLOCK #2
	else
	JUMP TO BLOCK #6
	end


	--- BLOCK #2 17-28, warpins: 2 ---
	slot1 = _R.CUserCmd.SetSideMove
	slot2 = cmd

	--- END OF BLOCK #2 ---

	if 1 < _R.CUserCmd.GetMouseX(cmd)

	 then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #3 29-30, warpins: 1 ---
	slot3 = 400
	--- END OF BLOCK #3 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #5


	--- BLOCK #4 31-31, warpins: 1 ---
	slot3 = -400

	--- END OF BLOCK #4 ---

	FLOW; TARGET BLOCK #5


	--- BLOCK #5 32-33, warpins: 2 ---
	slot1(slot2, slot3)
	--- END OF BLOCK #5 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #10


	--- BLOCK #6 34-60, warpins: 1 ---
	_R.CUserCmd.SetForwardMove(cmd, _R.Vector.Length2D(_R.Entity.GetVelocity(ME))/5850)

	slot1 = _R.CUserCmd.SetSideMove
	slot2 = cmd

	--- END OF BLOCK #6 ---

	if _R.CUserCmd.CommandNumber(cmd)

	%2 == 0 then
	JUMP TO BLOCK #7
	else
	JUMP TO BLOCK #8
	end


	--- BLOCK #7 61-62, warpins: 1 ---
	slot3 = -400
	--- END OF BLOCK #7 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #9


	--- BLOCK #8 63-63, warpins: 1 ---
	slot3 = 400

	--- END OF BLOCK #8 ---

	FLOW; TARGET BLOCK #9


	--- BLOCK #9 64-64, warpins: 2 ---
	slot1(slot2, slot3)

	--- END OF BLOCK #9 ---

	FLOW; TARGET BLOCK #10


	--- BLOCK #10 65-65, warpins: 2 ---
	return
	--- END OF BLOCK #10 ---



end

AT.bhop = function (cmd)
	--- BLOCK #0 1-3, warpins: 1 ---
	--- END OF BLOCK #0 ---

	slot1 = if ME then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #1 4-10, warpins: 1 ---
	--- END OF BLOCK #1 ---

	slot1 = if _R.Entity.IsValid(ME)
	 then
	JUMP TO BLOCK #2
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #2 11-15, warpins: 1 ---
	--- END OF BLOCK #2 ---

	if AT.vars.BHOP_ON == 1 then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #3 16-23, warpins: 1 ---
	--- END OF BLOCK #3 ---

	if _R.Entity.Health(ME)

	 <= 0 then
	JUMP TO BLOCK #4
	else
	JUMP TO BLOCK #5
	end


	--- BLOCK #4 24-24, warpins: 4 ---
	return

	--- END OF BLOCK #4 ---

	FLOW; TARGET BLOCK #5


	--- BLOCK #5 25-29, warpins: 2 ---
	--- END OF BLOCK #5 ---

	if AT.vars.bhopfail == 1 then
	JUMP TO BLOCK #6
	else
	JUMP TO BLOCK #17
	end


	--- BLOCK #6 30-32, warpins: 1 ---
	--- END OF BLOCK #6 ---

	slot1 = if justb then
	JUMP TO BLOCK #7
	else
	JUMP TO BLOCK #17
	end


	--- BLOCK #7 33-39, warpins: 1 ---
	--- END OF BLOCK #7 ---

	slot1 = if g.input.IsKeyDown(65)
	 then
	JUMP TO BLOCK #8
	else
	JUMP TO BLOCK #11
	end


	--- BLOCK #8 40-46, warpins: 1 ---
	--- END OF BLOCK #8 ---

	slot1 = if not _R.Entity.IsOnGround(ME)
	 then
	JUMP TO BLOCK #9
	else
	JUMP TO BLOCK #11
	end


	--- BLOCK #9 47-51, warpins: 1 ---
	--- END OF BLOCK #9 ---

	if AT.vars.BHOP_STRAFE == 1 then
	JUMP TO BLOCK #10
	else
	JUMP TO BLOCK #11
	end


	--- BLOCK #10 52-54, warpins: 1 ---
	DoStrafe(cmd)
	--- END OF BLOCK #10 ---

	FLOW; TARGET BLOCK #11


	--- BLOCK #11 55-58, warpins: 4 ---
	--- END OF BLOCK #11 ---

	if ignoreb < 2 then
	JUMP TO BLOCK #12
	else
	JUMP TO BLOCK #14
	end


	--- BLOCK #12 59-65, warpins: 1 ---
	--- END OF BLOCK #12 ---

	slot1 = if _R.Entity.IsOnGround(ME)

	 then
	JUMP TO BLOCK #13
	else
	JUMP TO BLOCK #14
	end


	--- BLOCK #13 66-76, warpins: 1 ---
	ignoreb = ignoreb + 1

	_R.CUserCmd.RemoveKey(cmd, 2)

	return

	--- END OF BLOCK #13 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #17


	--- BLOCK #14 77-80, warpins: 2 ---
	--- END OF BLOCK #14 ---

	if 2 <= ignoreb then
	JUMP TO BLOCK #15
	else
	JUMP TO BLOCK #16
	end


	--- BLOCK #15 81-89, warpins: 1 ---
	justb = false

	_R.CUserCmd.RemoveKey(cmd, 2)

	return
	--- END OF BLOCK #15 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #17


	--- BLOCK #16 90-90, warpins: 1 ---
	return

	--- END OF BLOCK #16 ---

	FLOW; TARGET BLOCK #17


	--- BLOCK #17 91-98, warpins: 5 ---
	ignoreb = 0

	--- END OF BLOCK #17 ---

	slot1 = if g.input.IsKeyDown(65)
	 then
	JUMP TO BLOCK #18
	else
	JUMP TO BLOCK #21
	end


	--- BLOCK #18 99-105, warpins: 1 ---
	--- END OF BLOCK #18 ---

	slot1 = if not _R.Entity.IsOnGround(ME)

	 then
	JUMP TO BLOCK #19
	else
	JUMP TO BLOCK #21
	end


	--- BLOCK #19 106-117, warpins: 1 ---
	justb = true

	_R.CUserCmd.RemoveKey(cmd, 2)
	--- END OF BLOCK #19 ---

	if AT.vars.BHOP_STRAFE == 1 then
	JUMP TO BLOCK #20
	else
	JUMP TO BLOCK #24
	end


	--- BLOCK #20 118-121, warpins: 1 ---
	DoStrafe(cmd)
	--- END OF BLOCK #20 ---

	UNCONDITIONAL JUMP; TARGET BLOCK #24


	--- BLOCK #21 122-129, warpins: 2 ---
	--- END OF BLOCK #21 ---

	slot1 = if _R.CUserCmd.KeyDown(cmd, 2)
	 then
	JUMP TO BLOCK #22
	else
	JUMP TO BLOCK #24
	end


	--- BLOCK #22 130-134, warpins: 1 ---
	--- END OF BLOCK #22 ---

	if AT.vars.BHOP_STRAFE == 1 then
	JUMP TO BLOCK #23
	else
	JUMP TO BLOCK #24
	end


	--- BLOCK #23 135-140, warpins: 1 ---
	_R.CUserCmd.SetForwardMove(cmd, 10000)

	--- END OF BLOCK #23 ---

	FLOW; TARGET BLOCK #24


	--- BLOCK #24 141-141, warpins: 5 ---
	return
	--- END OF BLOCK #24 ---



end
AT.nigs[9090] = function (yes, arg1, arg2, arg3)
	--- BLOCK #0 1-2, warpins: 1 ---
	--- END OF BLOCK #0 ---

	slot0 = if not yes then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 3-3, warpins: 1 ---
	return

	--- END OF BLOCK #1 ---

	FLOW; TARGET BLOCK #2


	--- BLOCK #2 4-12, warpins: 2 ---
	AT.bhop(yes)
	AT.aimbot(yes)

	return
	--- END OF BLOCK #2 ---



end
AT.nigs[10000] = function (d, ...)
	--- BLOCK #0 1-3, warpins: 1 ---
	--- END OF BLOCK #0 ---

	slot1 = if d.func then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 4-8, warpins: 1 ---
	--- END OF BLOCK #1 ---

	slot1 = if not IGNFS[d.func] then
	JUMP TO BLOCK #2
	else
	JUMP TO BLOCK #3
	end


	--- BLOCK #2 9-11, warpins: 2 ---
	--- END OF BLOCK #2 ---

	if d.source == "_" then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #3 12-31, warpins: 2 ---
	d.currentline = -1
	d.isvararg = true
	d.lastlinedefined = -1
	d.linedefined = -1
	d.namewhat = ""
	d.nparams = 0
	d.nups = 0
	d.short_src = "[C]"
	d.source = "=[C]"
	d.what = "C"

	--- END OF BLOCK #3 ---

	FLOW; TARGET BLOCK #4


	--- BLOCK #4 32-32, warpins: 2 ---
	return
	--- END OF BLOCK #4 ---



end
AT.nigs[10001] = function (d, ...)
	--- BLOCK #0 1-4, warpins: 1 ---
	--- END OF BLOCK #0 ---

	slot1 = if IGNFS[d] then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #1 5-10, warpins: 1 ---
	slot1 = 3
	slot2 = {
		upvalues = 0
	}
	--- END OF BLOCK #1 ---

	slot3 = if not ndsfdsf[d] then
	JUMP TO BLOCK #2
	else
	JUMP TO BLOCK #3
	end


	--- BLOCK #2 11-11, warpins: 1 ---
	slot3 = 1419386064
	--- END OF BLOCK #2 ---

	FLOW; TARGET BLOCK #3


	--- BLOCK #3 12-13, warpins: 2 ---
	slot2.addr = slot3

	return slot1, slot2
	--- END OF BLOCK #3 ---

	FLOW; TARGET BLOCK #4


	--- BLOCK #4 14-16, warpins: 2 ---
	return 1, {}
	--- END OF BLOCK #4 ---



end
AT.nigs[10004] = function (c, a, b)
	--- BLOCK #0 1-2, warpins: 1 ---
	--- END OF BLOCK #0 ---

	slot0 = if c then
	JUMP TO BLOCK #1
	else
	JUMP TO BLOCK #2
	end


	--- BLOCK #1 3-6, warpins: 1 ---
	--- END OF BLOCK #1 ---

	slot3 = if not IGNFS[c] then
	JUMP TO BLOCK #2
	else
	JUMP TO BLOCK #4
	end


	--- BLOCK #2 7-8, warpins: 2 ---
	--- END OF BLOCK #2 ---

	slot1 = if a then
	JUMP TO BLOCK #3
	else
	JUMP TO BLOCK #5
	end


	--- BLOCK #3 9-11, warpins: 1 ---
	--- END OF BLOCK #3 ---

	if a == AT then
	JUMP TO BLOCK #4
	else
	JUMP TO BLOCK #5
	end


	--- BLOCK #4 12-13, warpins: 2 ---
	return true
	--- END OF BLOCK #4 ---

	FLOW; TARGET BLOCK #5


	--- BLOCK #5 14-15, warpins: 3 ---
	return false
	--- END OF BLOCK #5 ---



end
AT.nigs[10009] = function (ret)
	--- BLOCK #0 1-1, warpins: 1 ---
	return
	--- END OF BLOCK #0 ---



end

return
--- END OF BLOCK #6 ---