Rust

pinned build 25824447 · 11:44 AM (EST) · 23 dumps tracked · updated 2026-10-09 15:45 UTC

Resources

#pragma once

#include <cstdint>
#include <cstring>
#include <string>

namespace resources
{
    namespace ClassNames
    {
        inline auto BaseNetworkableStatic = std::string ( e ( "%002b2dc837c01ef2e3e2b9cee4d9b8dd1bb95a8a" ) );
        inline auto BufferList = std::string ( e ( "%e74923865878d4ebab75ef5576305bbdbbbea628" ) );
        inline auto BuildingBlock = std::string ( e ( "%a153e6b67a465d8fd1ca1022e9d47e09237329b0" ) );
        inline auto CameraMan = std::string ( e ( "CameraMan" ) );
        inline auto CameraUpdateHookStatic = std::string ( e ( "%00a40c1a1ba19012cc65cd85832c92ed010fdcfa" ) );
        inline auto ConsoleSystem = std::string ( e ( "%66c3ca9bfe6b61434efea03910a55146a08852eb" ) );
        inline auto ConsoleSystemCommand = std::string ( e ( "%6e889557aaf9579d0f3008886712eccd4fe55aaa" ) );
        inline auto ConsoleSystemIndex = std::string ( e ( "%af253e358e18ea5141a90b0c66a00eb19a27be34" ) );
        inline auto ConsoleSystemIndexClient = std::string ( e ( "%04191392a7186b8d2a26fb2f5b13e374175dde97" ) );
        inline auto ConsoleSystemIndexStatic = std::string ( e ( "%ff6639a012e56b8f9f38134e081e14358a031124" ) );
        inline auto ConvarClientStatic = std::string ( e ( "%606f4524ff7b7c5ab036fc323a1c5b7bf1e1beb4" ) );
        inline auto ConvarGraphicsStatic = std::string ( e ( "%9c2887bf66e46d1810a962f1bb773367d2501b12" ) );
        inline auto ConvarPlayerStatic = std::string ( e ( "%c0dca99a96818e0c555455f153eebca30374c231" ) );
        inline auto ConvarServerStatic = std::string ( e ( "%a1e9bfa226bc279b46d4969b7541366ed377417f" ) );
        inline auto EncryptedValue = std::string ( e ( "%8a3328a2c5783b2865cb09a5c6b8818bc25dc682" ) );
        inline auto EntityRealm = std::string ( e ( "%58dd71aca572e0abe6e2e295ece717643d50f152" ) );
        inline auto EntityRef = std::string ( e ( "%0d6db161fb40c5ec43b204a2ed4badd4054c909e" ) );
        inline auto GameManager = std::string ( e ( "%69b83fdfd29771589fb407b125f1a60e7044f3b6" ) );
        inline auto GameManagerStatic = std::string ( e ( "%cb7d1425458877bd805a919135ee8fdc6645949f" ) );
        inline auto HiddenField = std::string ( e ( "%80511064a47c3b27894a93568c8d3725fc54c97e" ) );
        inline auto InputMessage = std::string ( e ( "%c2d5d48452af3a92a1625d694bba49ccdf912995" ) );
        inline auto InputState = std::string ( e ( "%c14cf7cba63787595f258b453ed3050a37c71bf3" ) );
        inline auto Interpolator = std::string ( e ( "%e9695193b36f3a932b41027401f239a590413db0" ) );
        inline auto Item = std::string ( e ( "%4cba7aa8a697b503c22fbfa353d2b648a969bb20" ) );
        inline auto ItemContainer = std::string ( e ( "%c347bea0b56aa62a10b94439dcf3cfba04ea1727" ) );
        inline auto ItemContainerId = std::string ( e ( "%de4cf0504a8b5acaeaa63c1747c2ca1a47c4bbe9" ) );
        inline auto ItemIconStatic = std::string ( e ( "%175292a1d43a743a7b5fac37f89fdb692de5ab1c" ) );
        inline auto ItemId = std::string ( e ( "%c6c524b552f147fb78f94239b9922916cbe6b32a" ) );
        inline auto ListComponentProjectile = std::string ( e ( "ListComponent`1" ) );
        inline auto ListDictionary = std::string ( e ( "%96510f31001b7d19cc0b87dea583413e9a672790" ) );
        inline auto ListHashSet = std::string ( e ( "%4f496c046cbcc3b8ee3ec634a85c5f7e33ba66fa" ) );
        inline auto LoadingScreen = std::string ( e ( "UI_LoadingScreen" ) );
        inline auto LocalPlayer = std::string ( e ( "%b8786d4743fc5315f55751fd2ee46619481c67f8" ) );
        inline auto LocalPlayerStatic = std::string ( e ( "%00b6121cca715b9f46f3a85cd12e3eb926c7ca80" ) );
        inline auto MixerSnapshotManager = std::string ( e ( "MixerSnapshotManager" ) );
        inline auto ModelState = std::string ( e ( "%621237f15b2b663d4bd11cc1130de98def518524" ) );
        inline auto NetworkableId = std::string ( e ( "%115d65806127dfc562d937bfbb3c794080e3413b" ) );
        inline auto PlayerTeam = std::string ( e ( "%ef64787bc3ba608b5bec29f7f2b5ba07a6eafd50" ) );
        inline auto PlayerTeamMember = std::string ( e ( "%36a5ec89b31490982a1419ccc5e35b8e831d161a" ) );
        inline auto PlayerTick = std::string ( e ( "%5e5c76f1b51c2bbb971854def4d5d29a25019c0e" ) );
        inline auto PositionLerp = std::string ( e ( "%04b83e475ceedc1fe5eb5731e1ab7c7b1e8b186e" ) );
        inline auto ServerAdminUGCEntry = std::string ( e ( "UI_ServerAdminUGCEntry" ) );
        inline auto SingletonComponentCameraMan = std::string ( e ( "SingletonComponent`1" ) );
        inline auto SingletonComponentLoadingScreen = std::string ( e ( "SingletonComponent`1" ) );
        inline auto SingletonComponentMixerSnapshotManager = std::string ( e ( "SingletonComponent`1" ) );
        inline auto StringPool = std::string ( e ( "%15a90965a9561ca4b38bcd315812ce50dea9664e" ) );
        inline auto TodSkyStatic = std::string ( e ( "%831a07856d053a21f3d24b42203206e59a379377" ) );
        inline auto TransformSnapshot = std::string ( e ( "%372fffd304328c31746bb30473198e07feaf44f7" ) );
    }

    namespace AttackEntity
    {
        inline constexpr auto animationDelay = std::uint64_t ( 0x2f8 );
        inline constexpr auto deployDelay = std::uint64_t ( 0x2f0 );
        inline constexpr auto effectiveRange = std::uint64_t ( 0x2fc );
        inline constexpr auto lastTickTime = std::uint64_t ( 0x350 );
        inline constexpr auto nextAttackTime = std::uint64_t ( 0x348 );
        inline constexpr auto nextTickTime = std::uint64_t ( 0x358 );
        inline constexpr auto noHeadshots = std::uint64_t ( 0x346 );
        inline constexpr auto repeatDelay = std::uint64_t ( 0x2f4 );
        inline constexpr auto timeSinceDeploy = std::uint64_t ( 0x360 );
    }

    namespace BaseCombatEntity
    {
        inline constexpr auto _health = std::uint64_t ( 0x2bc );
        inline constexpr auto _maxHealth = std::uint64_t ( 0x2c0 );
        inline constexpr auto baseProtection = std::uint64_t ( 0x240 );
        inline constexpr auto lifestate = std::uint64_t ( 0x2b0 );
        inline constexpr auto markAttackerHostile = std::uint64_t ( 0x2b6 );
        inline constexpr auto skeletonProperties = std::uint64_t ( 0x238 );
        inline constexpr auto startHealth = std::uint64_t ( 0x248 );
    }

    namespace BaseCorpse
    {
        inline constexpr auto blockDamageIfNotGather = std::uint64_t ( 0x2f8 );
        inline constexpr auto parentEnt = std::uint64_t ( 0x2e0 );
    }

    namespace BaseEntity
    {
        inline constexpr auto SendSignalBroadcast = std::uint64_t ( 0x5b50c90 );
        inline constexpr auto ServerRPC = std::uint64_t ( 0x5bc2970 );
        inline constexpr auto bounds = std::uint64_t ( 0x194 );
        inline constexpr auto flags = std::uint64_t ( 0x1c8 );
        inline constexpr auto model = std::uint64_t ( 0x1c0 );
        inline constexpr auto positionLerp = std::uint64_t ( 0x130 );
        inline constexpr auto triggers = std::uint64_t ( 0x100 );
    }

    namespace BaseMelee
    {
        inline constexpr auto attackRadius = std::uint64_t ( 0x3ac );
        inline constexpr auto blockSprintOnAttack = std::uint64_t ( 0x3b1 );
        inline constexpr auto canThrowAsProjectile = std::uint64_t ( 0x388 );
        inline constexpr auto damageProperties = std::uint64_t ( 0x390 );
        inline constexpr auto gathering = std::uint64_t ( 0x3e8 );
        inline constexpr auto maxDistance = std::uint64_t ( 0x3a8 );
    }

    namespace BaseMovement
    {
        inline constexpr auto Crawling = std::uint64_t ( 0x58 );
        inline constexpr auto Ducking = std::uint64_t ( 0x54 );
        inline constexpr auto Grounded = std::uint64_t ( 0x5c );
        inline constexpr auto InheritedVelocity = std::uint64_t ( 0x38 );
        inline constexpr auto Owner = std::uint64_t ( 0x30 );
        inline constexpr auto Running = std::uint64_t ( 0x50 );
        inline constexpr auto TargetMovement = std::uint64_t ( 0x44 );
        inline constexpr auto lastTeleportedTime = std::uint64_t ( 0x60 );
    }

    namespace BaseNetworkable
    {
        inline constexpr auto children = std::uint64_t ( 0x68 );
        inline constexpr auto parentEntity = std::uint64_t ( 0x38 );
        inline constexpr auto prefabID = std::uint64_t ( 0x54 );
    }

    namespace BaseNetworkableStatic
    {
        inline constexpr auto TypeInfo = std::uint64_t ( 0x112152c0 );
        inline constexpr auto clientEntities = std::uint64_t ( 0x28 );
    }

    namespace BasePlayer
    {
        inline constexpr auto OnViewModeChanged = std::uint64_t ( 0x260d460 );
        inline constexpr auto _displayName = std::uint64_t ( 0x568 );
        inline constexpr auto _lookingAt = std::uint64_t ( 0x500 );
        inline constexpr auto clActiveItem = std::uint64_t ( 0x590 );
        inline constexpr auto clientTeam = std::uint64_t ( 0x3f8 );
        inline constexpr auto clothingMoveSpeedReduction = std::uint64_t ( 0x7d0 );
        inline constexpr auto clothingWaterSpeedBonus = std::uint64_t ( 0x7d4 );
        inline constexpr auto currentTeam = std::uint64_t ( 0x560 );
        inline constexpr auto eyes = std::uint64_t ( 0x6f0 );
        inline constexpr auto input = std::uint64_t ( 0x2e8 );
        inline constexpr auto inventory = std::uint64_t ( 0x738 );
        inline constexpr auto lastSentTick = std::uint64_t ( 0x478 );
        inline constexpr auto lastSentTickTime = std::uint64_t ( 0x6a0 );
        inline constexpr auto modelState = std::uint64_t ( 0x550 );
        inline constexpr auto modifiers = std::uint64_t ( 0x3b0 );
        inline constexpr auto mounted = std::uint64_t ( 0x5e8 );
        inline constexpr auto movement = std::uint64_t ( 0x328 );
        inline constexpr auto playerFlags = std::uint64_t ( 0x6e0 );
        inline constexpr auto playerModel = std::uint64_t ( 0x6e8 );
        inline constexpr auto userID = std::uint64_t ( 0x728 );
        inline constexpr auto weaponMoveSpeedScale = std::uint64_t ( 0x7c8 );
    }

    namespace BaseProjectile
    {
        inline constexpr auto LaunchProjectile = std::uint64_t ( 0x4ecf9c0 );
        inline constexpr auto UpdateAmmoDisplay = std::uint64_t ( 0x4efd8a0 );
        inline constexpr auto aimCone = std::uint64_t ( 0x420 );
        inline constexpr auto aimConePenaltyMax = std::uint64_t ( 0x42c );
        inline constexpr auto aimSway = std::uint64_t ( 0x408 );
        inline constexpr auto aimSwaySpeed = std::uint64_t ( 0x40c );
        inline constexpr auto aimconePenalty = std::uint64_t ( 0x474 );
        inline constexpr auto aimconePenaltyPerShot = std::uint64_t ( 0x428 );
        inline constexpr auto automatic = std::uint64_t ( 0x3a0 );
        inline constexpr auto canChangeFireModes = std::uint64_t ( 0x448 );
        inline constexpr auto currentBurst = std::uint64_t ( 0x4c0 );
        inline constexpr auto fractionalReload = std::uint64_t ( 0x3f0 );
        inline constexpr auto hipAimCone = std::uint64_t ( 0x424 );
        inline constexpr auto isBurstWeapon = std::uint64_t ( 0x447 );
        inline constexpr auto isReloading = std::uint64_t ( 0x48c );
        inline constexpr auto nextReloadTime = std::uint64_t ( 0x460 );
        inline constexpr auto numShotsFired = std::uint64_t ( 0x45c );
        inline constexpr auto primaryMagazine = std::uint64_t ( 0x3e8 );
        inline constexpr auto projectileVelocityScale = std::uint64_t ( 0x39c );
        inline constexpr auto recoil = std::uint64_t ( 0x410 );
        inline constexpr auto reloadEndDuration = std::uint64_t ( 0x3fc );
        inline constexpr auto reloadFractionDuration = std::uint64_t ( 0x3f8 );
        inline constexpr auto reloadStartDuration = std::uint64_t ( 0x3f4 );
        inline constexpr auto reloadTime = std::uint64_t ( 0x3e0 );
        inline constexpr auto stancePenalty = std::uint64_t ( 0x470 );
        inline constexpr auto stancePenaltyScale = std::uint64_t ( 0x438 );
        inline constexpr auto startReloadTime = std::uint64_t ( 0x468 );
    }

    namespace BaseViewModel
    {
        inline constexpr auto animator = std::uint64_t ( 0xd0 );
        inline constexpr auto aspectOffset = std::uint64_t ( 0x108 );
        inline constexpr auto bob = std::uint64_t ( 0x88 );
        inline constexpr auto lower = std::uint64_t ( 0xd8 );
        inline constexpr auto punch = std::uint64_t ( 0xa8 );
        inline constexpr auto sway = std::uint64_t ( 0xe0 );
        inline constexpr auto useViewModelCamera = std::uint64_t ( 0x40 );
    }

    namespace Behaviour
    {
        inline constexpr auto set_enabled = std::uint64_t ( 0xe4f32d0 );
    }

    namespace BowWeapon
    {
        inline constexpr auto arrowBack = std::uint64_t ( 0x4e4 );
        inline constexpr auto attackReady = std::uint64_t ( 0x4e0 );
        inline constexpr auto wasAiming = std::uint64_t ( 0x4e8 );
    }

    namespace BufferList
    {
        inline constexpr auto TypeInfo = std::uint64_t ( 0x112fa5f0 );
    }

    namespace BuildingBlock
    {
        inline constexpr auto TypeInfo = std::uint64_t ( 0x112152b8 );
        inline constexpr auto apartmentList = std::uint64_t ( 0x20 );
    }

    namespace CameraUpdateHookStatic
    {
        inline constexpr auto TypeInfo = std::uint64_t ( 0x11293b00 );
        inline constexpr auto action = std::uint64_t ( 0x110 );
    }

    namespace Component
    {
        inline constexpr auto get_gameObject = std::uint64_t ( 0xe4f3fb0 );
    }

    namespace CompoundBowWeapon
    {
        inline constexpr auto conditionLossHeldDelay = std::uint64_t ( 0x508 );
        inline constexpr auto conditionLossPerSecondHeld = std::uint64_t ( 0x504 );
        inline constexpr auto movementPenalty = std::uint64_t ( 0x538 );
        inline constexpr auto movementPenaltyRampUpTime = std::uint64_t ( 0x500 );
        inline constexpr auto stringBonusDamage = std::uint64_t ( 0x4f4 );
        inline constexpr auto stringBonusDistance = std::uint64_t ( 0x4f8 );
        inline constexpr auto stringBonusVelocity = std::uint64_t ( 0x4fc );
        inline constexpr auto stringHoldDurationMax = std::uint64_t ( 0x4f0 );
        inline constexpr auto stringHoldTimeStart = std::uint64_t ( 0x544 );
    }

    namespace ConsoleSystemCommand
    {
        inline constexpr auto TypeInfo = std::uint64_t ( 0x111d1958 );
    }

    namespace ConsoleSystemIndexStatic
    {
        inline constexpr auto TypeInfo = std::uint64_t ( 0x111a3ca8 );
    }

    namespace ConvarClientStatic
    {
        inline constexpr auto TypeInfo = std::uint64_t ( 0x11208970 );
        inline constexpr auto camlerp = std::uint64_t ( 0x254 );
        inline constexpr auto camspeed = std::uint64_t ( 0x4cc );
    }

    namespace ConvarGraphicsStatic
    {
        inline constexpr auto TypeInfo = std::uint64_t ( 0x112188a8 );
        inline constexpr auto _fov = std::uint64_t ( 0x5b0 );
    }

    namespace ConvarPlayerStatic
    {
        inline constexpr auto TypeInfo = std::uint64_t ( 0x11261d00 );
        inline constexpr auto clientTickInterval = std::uint64_t ( 0xa4 );
    }

    namespace ConvarServerStatic
    {
        inline constexpr auto TypeInfo = std::uint64_t ( 0x112085d8 );
    }

    namespace EntityRealm
    {
        inline constexpr auto entityList = std::uint64_t ( 0x18 );
    }

    namespace FlintStrikeWeapon
    {
        inline constexpr auto _didSparkThisFrame = std::uint64_t ( 0x4d8 );
        inline constexpr auto _isStriking = std::uint64_t ( 0x4d9 );
        inline constexpr auto strikes = std::uint64_t ( 0x4dc );
        inline constexpr auto successFraction = std::uint64_t ( 0x4c8 );
        inline constexpr auto successIncrease = std::uint64_t ( 0x4cc );
    }

    namespace GameManager
    {
        inline constexpr auto CreatePrefab = std::uint64_t ( 0x4d87370 );
        inline constexpr auto TypeInfo = std::uint64_t ( 0x111cc2c0 );
    }

    namespace GameManagerStatic
    {
        inline constexpr auto TypeInfo = std::uint64_t ( 0x11206a80 );
        inline constexpr auto client = std::uint64_t ( 0x20 );
    }

    namespace GameObject
    {
        inline constexpr auto SetActive = std::uint64_t ( 0xe4f92d0 );
    }

    namespace HeldEntity
    {
        inline constexpr auto viewModel = std::uint64_t ( 0x258 );
    }

    namespace HumanNPC
    {
        inline constexpr auto AdditionalLosBlockingLayer = std::uint64_t ( 0x858 );
        inline constexpr auto aimConeScale = std::uint64_t ( 0x868 );
        inline constexpr auto lastDismountTime = std::uint64_t ( 0x86c );
    }

    namespace InputMessage
    {
        inline constexpr auto TypeInfo = std::uint64_t ( 0x111ddb78 );
        inline constexpr auto aimAngles = std::uint64_t ( 0x10 );
        inline constexpr auto buttons = std::uint64_t ( 0x2c );
        inline constexpr auto mouseDelta = std::uint64_t ( 0x1c );
    }

    namespace InputState
    {
        inline constexpr auto TypeInfo = std::uint64_t ( 0x11229c08 );
        inline constexpr auto current = std::uint64_t ( 0x20 );
        inline constexpr auto previous = std::uint64_t ( 0x10 );
    }

    namespace Interpolator
    {
        inline constexpr auto TypeInfo = std::uint64_t ( 0x111d76c0 );
        inline constexpr auto last = std::uint64_t ( 0x10 );
        inline constexpr auto list = std::uint64_t ( 0x30 );
    }

    namespace Item
    {
        inline constexpr auto TypeInfo = std::uint64_t ( 0x111ee918 );
        inline constexpr auto amount = std::uint64_t ( 0x88 );
        inline constexpr auto heldEntity = std::uint64_t ( 0x20 );
        inline constexpr auto info = std::uint64_t ( 0x38 );
        inline constexpr auto position = std::uint64_t ( 0x60 );
        inline constexpr auto uid = std::uint64_t ( 0x90 );
        inline constexpr auto worldEnt = std::uint64_t ( 0x68 );
    }

    namespace ItemContainer
    {
        inline constexpr auto flags = std::uint64_t ( 0x2c );
        inline constexpr auto itemList = std::uint64_t ( 0x68 );
        inline constexpr auto uid = std::uint64_t ( 0x10 );
    }

    namespace ItemDefinition
    {
        inline constexpr auto category = std::uint64_t ( 0x58 );
        inline constexpr auto displayName = std::uint64_t ( 0x40 );
        inline constexpr auto itemid = std::uint64_t ( 0x20 );
        inline constexpr auto shortname = std::uint64_t ( 0x28 );
    }

    namespace ItemIconStatic
    {
        inline constexpr auto TypeInfo = std::uint64_t ( 0x11222448 );
        inline constexpr auto containerLootStartTimes = std::uint64_t ( 0x18 );
    }

    namespace ItemId
    {
        inline constexpr auto TypeInfo = std::uint64_t ( 0x112478c8 );
    }

    namespace ItemModProjectile
    {
        inline constexpr auto projectileObject = std::uint64_t ( 0x20 );
        inline constexpr auto projectileSpread = std::uint64_t ( 0x3c );
        inline constexpr auto projectileVelocity = std::uint64_t ( 0x40 );
        inline constexpr auto projectileVelocitySpread = std::uint64_t ( 0x44 );
    }

    namespace ListComponent
    {
        inline constexpr auto InstanceList = std::uint64_t ( 0x8 );
    }

    namespace ListComponentProjectile
    {
        inline constexpr auto TypeInfo = std::uint64_t ( 0x11225ae8 );
    }

    namespace ListDictionary
    {
        inline constexpr auto TypeInfo = std::uint64_t ( 0x11222018 );
        inline constexpr auto vals = std::uint64_t ( 0x18 );
    }

    namespace ListHashSet
    {
        inline constexpr auto vals = std::uint64_t ( 0x18 );
    }

    namespace LoadingScreen
    {
        inline constexpr auto panel = std::uint64_t ( 0x30 );
    }

    namespace LocalPlayerStatic
    {
        inline constexpr auto Entity = std::uint64_t ( 0x128 );
        inline constexpr auto TypeInfo = std::uint64_t ( 0x111ff1b0 );
    }

    namespace LootableCorpse
    {
        inline constexpr auto lootPanelName = std::uint64_t ( 0x320 );
    }

    namespace Magazine
    {
        inline constexpr auto allowAmmoSwitching = std::uint64_t ( 0x29 );
        inline constexpr auto allowPlayerReloading = std::uint64_t ( 0x28 );
        inline constexpr auto ammoType = std::uint64_t ( 0x20 );
        inline constexpr auto capacity = std::uint64_t ( 0x18 );
        inline constexpr auto contents = std::uint64_t ( 0x1c );
        inline constexpr auto definition = std::uint64_t ( 0x10 );
    }

    namespace MainCamera
    {
        inline constexpr auto mainCamera = std::uint64_t ( 0x10 );
    }

    namespace MixerSnapshotManager
    {
        inline constexpr auto defaultSnapshot = std::uint64_t ( 0x20 );
        inline constexpr auto loadingSnapshot = std::uint64_t ( 0x30 );
    }

    namespace Model
    {
        inline constexpr auto boneNames = std::uint64_t ( 0x58 );
        inline constexpr auto boneTransforms = std::uint64_t ( 0x50 );
    }

    namespace ModelState
    {
        inline constexpr auto TypeInfo = std::uint64_t ( 0x112222c0 );
        inline constexpr auto flags = std::uint64_t ( 0x60 );
        inline constexpr auto lookDir = std::uint64_t ( 0x1c );
        inline constexpr auto waterLevel = std::uint64_t ( 0x30 );
    }

    namespace NPCPlayer
    {
        inline constexpr auto LegacyNavigation = std::uint64_t ( 0x834 );
        inline constexpr auto MovementTickStartDelay = std::uint64_t ( 0x7f8 );
        inline constexpr auto attackLengthMaxShortRangeScale = std::uint64_t ( 0x848 );
        inline constexpr auto damageScale = std::uint64_t ( 0x840 );
        inline constexpr auto finalDestination = std::uint64_t ( 0x808 );
        inline constexpr auto shortRange = std::uint64_t ( 0x844 );
    }

    namespace NetworkableId
    {
        inline constexpr auto TypeInfo = std::uint64_t ( 0x11215370 );
    }

    namespace Object
    {
        inline constexpr auto m_CachedPtr = std::uint64_t ( 0x10 );
    }

    namespace PlayerCorpse
    {
        inline constexpr auto underwearSkin = std::uint64_t ( 0x350 );
    }

    namespace PlayerEyes
    {
        inline constexpr auto bodyRotation = std::uint64_t ( 0x50 );
        inline constexpr auto viewOffset = std::uint64_t ( 0x40 );
    }

    namespace PlayerInput
    {
        inline constexpr auto bodyAngles = std::uint64_t ( 0x44 );
        inline constexpr auto state = std::uint64_t ( 0x28 );
    }

    namespace PlayerInventory
    {
        inline constexpr auto containerBelt = std::uint64_t ( 0x78 );
        inline constexpr auto containerMain = std::uint64_t ( 0x30 );
        inline constexpr auto containerWear = std::uint64_t ( 0x28 );
        inline constexpr auto loot = std::uint64_t ( 0x48 );
    }

    namespace PlayerModel
    {
        inline constexpr auto _multiMesh = std::uint64_t ( 0x540 );
    }

    namespace PlayerTeam
    {
        inline constexpr auto members = std::uint64_t ( 0x40 );
    }

    namespace PlayerTeamMember
    {
        inline constexpr auto userID = std::uint64_t ( 0x48 );
    }

    namespace PlayerTick
    {
        inline constexpr auto activeItem = std::uint64_t ( 0x10 );
        inline constexpr auto eyePos = std::uint64_t ( 0x20 );
        inline constexpr auto inputState = std::uint64_t ( 0x18 );
        inline constexpr auto modelState = std::uint64_t ( 0x50 );
        inline constexpr auto parentID = std::uint64_t ( 0x40 );
        inline constexpr auto position = std::uint64_t ( 0x34 );
    }

    namespace PlayerWalkMovement
    {
        inline constexpr auto groundAngle = std::uint64_t ( 0x108 );
        inline constexpr auto groundAngleNew = std::uint64_t ( 0x110 );
        inline constexpr auto groundNormal = std::uint64_t ( 0x160 );
        inline constexpr auto groundNormalNew = std::uint64_t ( 0x170 );
        inline constexpr auto groundTime = std::uint64_t ( 0x118 );
        inline constexpr auto groundVelocity = std::uint64_t ( 0x180 );
        inline constexpr auto groundVelocityNew = std::uint64_t ( 0x190 );
        inline constexpr auto jumpTime = std::uint64_t ( 0x120 );
        inline constexpr auto landTime = std::uint64_t ( 0x128 );
        inline constexpr auto maxVelocity = std::uint64_t ( 0x100 );
        inline constexpr auto previousInheritedVelocity = std::uint64_t ( 0x150 );
        inline constexpr auto previousPosition = std::uint64_t ( 0x130 );
        inline constexpr auto previousVelocity = std::uint64_t ( 0x140 );
    }

    namespace PositionLerp
    {
        inline constexpr auto interpolator = std::uint64_t ( 0x60 );
    }

    namespace ProgressBar
    {
        inline constexpr auto Instance = std::uint64_t ( 0x20 );
        inline constexpr auto leftField = std::uint64_t ( 0x40 );
        inline constexpr auto timeCounter = std::uint64_t ( 0x24 );
        inline constexpr auto timeFinished = std::uint64_t ( 0x20 );
    }

    namespace Projectile
    {
        inline constexpr auto currentPosition = std::uint64_t ( 0x170 );
        inline constexpr auto currentVelocity = std::uint64_t ( 0x164 );
        inline constexpr auto drag = std::uint64_t ( 0x34 );
        inline constexpr auto gravityModifier = std::uint64_t ( 0x38 );
        inline constexpr auto initialDistance = std::uint64_t ( 0x44 );
        inline constexpr auto integrity = std::uint64_t ( 0x13c );
        inline constexpr auto thickness = std::uint64_t ( 0x3c );
        inline constexpr auto traveledDistance = std::uint64_t ( 0x17c );
        inline constexpr auto traveledTime = std::uint64_t ( 0x180 );
    }

    namespace ProjectileWeaponMod
    {
        inline constexpr auto isSilencer = std::uint64_t ( 0x220 );
        inline constexpr auto projectileVelocity = std::uint64_t ( 0x234 );
        inline constexpr auto silencerType = std::uint64_t ( 0x224 );
    }

    namespace RecoilProperties
    {
        inline constexpr auto newRecoilOverride = std::uint64_t ( 0x80 );
        inline constexpr auto recoilPitchMax = std::uint64_t ( 0x24 );
        inline constexpr auto recoilPitchMin = std::uint64_t ( 0x20 );
        inline constexpr auto recoilYawMax = std::uint64_t ( 0x1c );
        inline constexpr auto recoilYawMin = std::uint64_t ( 0x18 );
    }

    namespace Rvas
    {
        inline constexpr auto TypeManagerInstance = std::uint64_t ( 0x221d020 );
        inline constexpr auto TypeToObjectSet = std::uint64_t ( 0x221cff8 );
        inline constexpr auto assetBundleManager = std::uint64_t ( 0x212fe00 );
        inline constexpr auto m_Instance = std::uint64_t ( 0x21818e8 );
        inline constexpr auto rigidActors = std::uint64_t ( 0x23d8 );
        inline constexpr auto sizeOfImage = std::uint64_t ( 0x2411000 );
        inline constexpr auto timeDateStamp = std::uint64_t ( 0x6aa9d1b0 );
    }

    namespace ScientistNPC
    {
        inline constexpr auto IdleChatterRepeatRange = std::uint64_t ( 0x890 );
        inline constexpr auto deathStatName = std::uint64_t ( 0x888 );
        inline constexpr auto radioChatterType = std::uint64_t ( 0x898 );
    }

    namespace ServerAdminUGCEntry
    {
        inline constexpr auto ReceivedDataFromServer = std::uint64_t ( 0x2f583f0 );
    }

    namespace SingletonComponentCameraMan
    {
        inline constexpr auto Instance = std::uint64_t ( 0x18 );
        inline constexpr auto TypeInfo = std::uint64_t ( 0x1123f1a0 );
    }

    namespace SingletonComponentLoadingScreen
    {
        inline constexpr auto Instance = std::uint64_t ( 0x18 );
        inline constexpr auto TypeInfo = std::uint64_t ( 0x11226f78 );
    }

    namespace SingletonComponentMixerSnapshotManager
    {
        inline constexpr auto Instance = std::uint64_t ( 0x18 );
        inline constexpr auto TypeInfo = std::uint64_t ( 0x11202330 );
    }

    namespace SkeletonProperties
    {
        inline constexpr auto bones = std::uint64_t ( 0x20 );
    }

    namespace SkeletonPropertiesBoneProperty
    {
        inline constexpr auto area = std::uint64_t ( 0x20 );
        inline constexpr auto bone = std::uint64_t ( 0x10 );
        inline constexpr auto boneName = std::uint64_t ( 0x18 );
    }

    namespace SkinnedMultiMesh
    {
        inline constexpr auto Renderers = std::uint64_t ( 0x38 );
    }

    namespace StringPool
    {
        inline constexpr auto TypeInfo = std::uint64_t ( 0x11247330 );
        inline constexpr auto toNumber = std::uint64_t ( 0x80 );
    }

    namespace TodAmbientParameters
    {
        inline constexpr auto Mode = std::uint64_t ( 0x10 );
        inline constexpr auto Saturation = std::uint64_t ( 0x14 );
        inline constexpr auto UpdateInterval = std::uint64_t ( 0x18 );
    }

    namespace TodAtmosphereParameters
    {
        inline constexpr auto Brightness = std::uint64_t ( 0x18 );
        inline constexpr auto Contrast = std::uint64_t ( 0x1c );
        inline constexpr auto Directionality = std::uint64_t ( 0x28 );
        inline constexpr auto Fogginess = std::uint64_t ( 0x2c );
        inline constexpr auto MieMultiplier = std::uint64_t ( 0x14 );
        inline constexpr auto NightBrightness = std::uint64_t ( 0x20 );
        inline constexpr auto NightContrast = std::uint64_t ( 0x24 );
        inline constexpr auto RayleighMultiplier = std::uint64_t ( 0x10 );
    }

    namespace TodCloudParameters
    {
        inline constexpr auto Attenuation = std::uint64_t ( 0x24 );
        inline constexpr auto Brightness = std::uint64_t ( 0x30 );
        inline constexpr auto Coloring = std::uint64_t ( 0x20 );
        inline constexpr auto Coverage = std::uint64_t ( 0x18 );
        inline constexpr auto Opacity = std::uint64_t ( 0x14 );
        inline constexpr auto Saturation = std::uint64_t ( 0x28 );
        inline constexpr auto Scattering = std::uint64_t ( 0x2c );
        inline constexpr auto Sharpness = std::uint64_t ( 0x1c );
        inline constexpr auto Size = std::uint64_t ( 0x10 );
    }

    namespace TodDayParameters
    {
        inline constexpr auto AmbientColor = std::uint64_t ( 0x40 );
        inline constexpr auto AmbientMultiplier = std::uint64_t ( 0x54 );
        inline constexpr auto CloudColor = std::uint64_t ( 0x30 );
        inline constexpr auto FogColor = std::uint64_t ( 0x38 );
        inline constexpr auto LightColor = std::uint64_t ( 0x18 );
        inline constexpr auto LightIntensity = std::uint64_t ( 0x48 );
        inline constexpr auto RayColor = std::uint64_t ( 0x20 );
        inline constexpr auto ReflectionMaxClamp = std::uint64_t ( 0x64 );
        inline constexpr auto ReflectionMultiplier = std::uint64_t ( 0x5c );
        inline constexpr auto ShadowStrength = std::uint64_t ( 0x50 );
        inline constexpr auto SkyColor = std::uint64_t ( 0x28 );
        inline constexpr auto SunColor = std::uint64_t ( 0x10 );
        inline constexpr auto runtimeAmbientMultiplier = std::uint64_t ( 0x58 );
        inline constexpr auto runtimeLightIntensity = std::uint64_t ( 0x4c );
        inline constexpr auto runtimeReflectionMultiplier = std::uint64_t ( 0x60 );
    }

    namespace TodFogParameters
    {
        inline constexpr auto HeightBias = std::uint64_t ( 0x14 );
        inline constexpr auto Mode = std::uint64_t ( 0x10 );
    }

    namespace TodLightParameters
    {
        inline constexpr auto MinimumHeight = std::uint64_t ( 0x14 );
        inline constexpr auto UpdateInterval = std::uint64_t ( 0x10 );
    }

    namespace TodMoonParameters
    {
        inline constexpr auto HaloBrightness = std::uint64_t ( 0x28 );
        inline constexpr auto HaloSize = std::uint64_t ( 0x24 );
        inline constexpr auto MeshBrightness = std::uint64_t ( 0x18 );
        inline constexpr auto MeshBrightnessDefault = std::uint64_t ( 0x1c );
        inline constexpr auto MeshContrast = std::uint64_t ( 0x20 );
        inline constexpr auto MeshSize = std::uint64_t ( 0x10 );
        inline constexpr auto MeshSizeRed = std::uint64_t ( 0x14 );
        inline constexpr auto Position = std::uint64_t ( 0x2c );
    }

    namespace TodNightParameters
    {
        inline constexpr auto AmbientColor = std::uint64_t ( 0x48 );
        inline constexpr auto AmbientMultiplier = std::uint64_t ( 0x5c );
        inline constexpr auto CloudColor = std::uint64_t ( 0x38 );
        inline constexpr auto FogColor = std::uint64_t ( 0x40 );
        inline constexpr auto LightColor = std::uint64_t ( 0x20 );
        inline constexpr auto LightIntensity = std::uint64_t ( 0x50 );
        inline constexpr auto MoonColor = std::uint64_t ( 0x10 );
        inline constexpr auto MoonColorRed = std::uint64_t ( 0x18 );
        inline constexpr auto RayColor = std::uint64_t ( 0x28 );
        inline constexpr auto ReflectionMaxClamp = std::uint64_t ( 0x6c );
        inline constexpr auto ReflectionMultiplier = std::uint64_t ( 0x64 );
        inline constexpr auto ShadowStrength = std::uint64_t ( 0x58 );
        inline constexpr auto SkyColor = std::uint64_t ( 0x30 );
        inline constexpr auto runtimeAmbientMultiplier = std::uint64_t ( 0x60 );
        inline constexpr auto runtimeLightIntensity = std::uint64_t ( 0x54 );
        inline constexpr auto runtimeReflectionMultiplier = std::uint64_t ( 0x68 );
    }

    namespace TodSky
    {
        inline constexpr auto Ambient = std::uint64_t ( 0x98 );
        inline constexpr auto Atmosphere = std::uint64_t ( 0x50 );
        inline constexpr auto Clouds = std::uint64_t ( 0x80 );
        inline constexpr auto Day = std::uint64_t ( 0x58 );
        inline constexpr auto Fog = std::uint64_t ( 0x90 );
        inline constexpr auto Light = std::uint64_t ( 0x88 );
        inline constexpr auto Moon = std::uint64_t ( 0x70 );
        inline constexpr auto Night = std::uint64_t ( 0x60 );
        inline constexpr auto Stars = std::uint64_t ( 0x78 );
        inline constexpr auto Sun = std::uint64_t ( 0x68 );
    }

    namespace TodSkyStatic
    {
        inline constexpr auto TypeInfo = std::uint64_t ( 0x11288480 );
        inline constexpr auto instances = std::uint64_t ( 0x98 );
    }

    namespace TodStarParameters
    {
        inline constexpr auto Brightness = std::uint64_t ( 0x14 );
        inline constexpr auto ColorScale = std::uint64_t ( 0x1c );
        inline constexpr auto Position = std::uint64_t ( 0x18 );
        inline constexpr auto Size = std::uint64_t ( 0x10 );
    }

    namespace TodSunParameters
    {
        inline constexpr auto MeshBrightness = std::uint64_t ( 0x14 );
        inline constexpr auto MeshBrightnessDefault = std::uint64_t ( 0x18 );
        inline constexpr auto MeshContrast = std::uint64_t ( 0x1c );
        inline constexpr auto MeshSize = std::uint64_t ( 0x10 );
    }

    namespace TranslatePhrase
    {
        inline constexpr auto legacyEnglish = std::uint64_t ( 0x20 );
        inline constexpr auto token = std::uint64_t ( 0x10 );
    }

    namespace TriggerLadder
    {
        inline constexpr auto ForceLookAt = std::uint64_t ( 0x54 );
        inline constexpr auto RequireJumpToMount = std::uint64_t ( 0x55 );
        inline constexpr auto Type = std::uint64_t ( 0x50 );
    }

    namespace TriggerMovement
    {
        inline constexpr auto losEyes = std::uint64_t ( 0x50 );
        inline constexpr auto movementModify = std::uint64_t ( 0x58 );
        inline constexpr auto scale = std::uint64_t ( 0x5c );
    }

    namespace UnityComponent
    {
        inline constexpr auto GetGameObject = std::uint64_t ( 0xbea00 );
    }

    namespace UnityEngineUiText
    {
        inline constexpr auto m_Text = std::uint64_t ( 0xe8 );
    }

    namespace UnityGameObject
    {
        inline constexpr auto m_IsActive = std::uint64_t ( 0x46 );
    }

    namespace ViewModel
    {
        inline constexpr auto instance = std::uint64_t ( 0x28 );
    }

    namespace ViewmodelBob
    {
        inline constexpr auto bobAmountRun = std::uint64_t ( 0x2c );
        inline constexpr auto bobAmountWalk = std::uint64_t ( 0x28 );
        inline constexpr auto bobSpeedRun = std::uint64_t ( 0x24 );
        inline constexpr auto bobSpeedWalk = std::uint64_t ( 0x20 );
        inline constexpr auto leftOffsetRun = std::uint64_t ( 0x30 );
    }

    namespace ViewmodelLower
    {
        inline constexpr auto forceLower = std::uint64_t ( 0x22 );
        inline constexpr auto lowerOnSprint = std::uint64_t ( 0x20 );
        inline constexpr auto lowerScale = std::uint64_t ( 0x24 );
        inline constexpr auto lowerWhenCantAttack = std::uint64_t ( 0x21 );
        inline constexpr auto shouldLower = std::uint64_t ( 0x28 );
    }

    namespace ViewmodelPunch
    {
        inline constexpr auto punchDuration = std::uint64_t ( 0x34 );
        inline constexpr auto punchMagnitude = std::uint64_t ( 0x38 );
        inline constexpr auto punchStartTime = std::uint64_t ( 0x3c );
    }

    namespace ViewmodelSway
    {
        inline constexpr auto positionalSwayAmount = std::uint64_t ( 0x24 );
        inline constexpr auto positionalSwaySpeed = std::uint64_t ( 0x20 );
        inline constexpr auto rotateAmountTest = std::uint64_t ( 0x30 );
        inline constexpr auto rotationSwayAmount = std::uint64_t ( 0x2c );
        inline constexpr auto rotationSwaySpeed = std::uint64_t ( 0x28 );
    }

    namespace WorldItem
    {
        inline constexpr auto Item = std::uint64_t ( 0x210 );
        inline constexpr auto allowPickup = std::uint64_t ( 0x208 );
    }
}

Decryption/Encryptions

#pragma once

#include <array>
#include <bit>
#include <cstdint>
#include <cstring>
#include <functional>

namespace decryptor
{
    inline auto read = std::function<std::uint64_t ( std::uint64_t )> ( );
    inline auto get_handle = std::function<std::uint64_t ( std::uint64_t )> ( );

    inline auto decrypt_clactiveitem ( std::uint64_t value ) -> std::uint64_t
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 2>> ( value );

        for ( auto& word : words )
        {
            word = std::rotl ( word, 24 );
            word += 0xc7b8e0dbu;
            word = std::rotl ( word, 22 );
        }

        return std::bit_cast<std::uint64_t> ( words );
    }

    inline auto decrypt_client_entities ( std::uint64_t value ) -> std::uint64_t
    {
        const auto handle = decryptor::read ( value + 0x18 );

        auto words = std::bit_cast<std::array<std::uint32_t, 2>> ( handle );

        for ( auto& word : words )
        {
            word += 0xe6a082cbu;
            word = std::rotl ( word, 31 );
            word += 0x70ed470bu;
            word ^= 0x8f910f67u;
        }

        return decryptor::get_handle ( std::bit_cast<std::uint64_t> ( words ) );
    }

    inline auto decrypt_client_tick_interval ( std::uint32_t value ) -> float
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 1>> ( value );

        for ( auto& word : words )
        {
            word += 0x9c6e171eu;
            word = std::rotl ( word, 29 );
            word ^= 0x9666edbeu;
        }

        auto result = 0.00f;
        std::memcpy ( &result, words.data ( ), sizeof ( result ) );

        return result;
    }

    inline auto decrypt_entity_list ( std::uint64_t value ) -> std::uint64_t
    {
        const auto handle = decryptor::read ( value + 0x18 );

        auto words = std::bit_cast<std::array<std::uint32_t, 2>> ( handle );

        for ( auto& word : words )
        {
            word += 0xfe565ecfu;
            word ^= 0x3e7b1f16u;
            word += 0xf72c787au;
            word = std::rotl ( word, 18 );
        }

        return decryptor::get_handle ( std::bit_cast<std::uint64_t> ( words ) );
    }

    inline auto decrypt_eyes ( std::uint64_t value ) -> std::uint64_t
    {
        const auto handle = decryptor::read ( value + 0x18 );

        auto words = std::bit_cast<std::array<std::uint32_t, 2>> ( handle );

        for ( auto& word : words )
        {
            word = std::rotl ( word, 22 );
            word ^= 0xa6b79536u;
            word += 0xf446cf4au;
            word = std::rotl ( word, 28 );
        }

        return decryptor::get_handle ( std::bit_cast<std::uint64_t> ( words ) );
    }

    inline auto decrypt_fov ( std::uint32_t value ) -> float
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 1>> ( value );

        for ( auto& word : words )
        {
            word += 0x9c6e171eu;
            word = std::rotl ( word, 29 );
            word ^= 0x9666edbeu;
        }

        auto result = 0.00f;
        std::memcpy ( &result, words.data ( ), sizeof ( result ) );

        return result;
    }

    inline auto decrypt_ground_angle ( std::uint32_t value ) -> float
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 1>> ( value );

        for ( auto& word : words )
        {
            word = std::rotl ( word, 3 );
            word += 0x2b741978u;
            word = std::rotl ( word, 15 );
            word += 0xb06d1eb5u;
        }

        auto result = 0.00f;
        std::memcpy ( &result, words.data ( ), sizeof ( result ) );

        return result;
    }

    inline auto decrypt_ground_angle_new ( std::uint32_t value ) -> float
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 1>> ( value );

        for ( auto& word : words )
        {
            word ^= 0x6d0d2c06u;
            word += 0x8290dc82u;
            word ^= 0xd2ac5f19u;
            word = std::rotl ( word, 21 );
        }

        auto result = 0.00f;
        std::memcpy ( &result, words.data ( ), sizeof ( result ) );

        return result;
    }

    inline auto decrypt_ground_normal ( std::array<std::uint32_t, 3> value ) -> std::array<std::uint32_t, 3>
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 3>> ( value );

        for ( auto& word : words )
        {
            word = std::rotl ( word, 23 );
            word += 0xb007168bu;
            word = std::rotl ( word, 15 );
            word += 0xd42c82u;
        }

        return std::bit_cast<std::array<std::uint32_t, 3>> ( words );
    }

    inline auto decrypt_ground_normal_new ( std::array<std::uint32_t, 3> value ) -> std::array<std::uint32_t, 3>
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 3>> ( value );

        for ( auto& word : words )
        {
            word += 0xd54ad0ffu;
            word = std::rotl ( word, 19 );
            word ^= 0x8c7cd1cdu;
            word += 0x58af0ad9u;
        }

        return std::bit_cast<std::array<std::uint32_t, 3>> ( words );
    }

    inline auto decrypt_ground_time ( std::uint32_t value ) -> float
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 1>> ( value );

        for ( auto& word : words )
        {
            word = std::rotl ( word, 26 );
            word += 0xdfca0a2bu;
            word ^= 0xdc2bfe8fu;
            word += 0x5f2e459cu;
        }

        auto result = 0.00f;
        std::memcpy ( &result, words.data ( ), sizeof ( result ) );

        return result;
    }

    inline auto decrypt_ground_velocity ( std::array<std::uint32_t, 3> value ) -> std::array<std::uint32_t, 3>
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 3>> ( value );

        for ( auto& word : words )
        {
            word = std::rotl ( word, 11 );
            word += 0x67db6cfdu;
            word = std::rotl ( word, 1 );
            word += 0x7bbee5a6u;
        }

        return std::bit_cast<std::array<std::uint32_t, 3>> ( words );
    }

    inline auto decrypt_ground_velocity_new ( std::array<std::uint32_t, 3> value ) -> std::array<std::uint32_t, 3>
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 3>> ( value );

        for ( auto& word : words )
        {
            word = std::rotl ( word, 20 );
            word ^= 0xe7b714dfu;
            word = std::rotl ( word, 29 );
        }

        return std::bit_cast<std::array<std::uint32_t, 3>> ( words );
    }

    inline auto decrypt_inventory ( std::uint64_t value ) -> std::uint64_t
    {
        const auto handle = decryptor::read ( value + 0x18 );

        auto words = std::bit_cast<std::array<std::uint32_t, 2>> ( handle );

        for ( auto& word : words )
        {
            word = std::rotl ( word, 24 );
            word += 0x1c5caf19u;
            word = std::rotl ( word, 14 );
        }

        return decryptor::get_handle ( std::bit_cast<std::uint64_t> ( words ) );
    }

    inline auto decrypt_jump_time ( std::uint32_t value ) -> float
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 1>> ( value );

        for ( auto& word : words )
        {
            word = std::rotl ( word, 5 );
            word += 0x2413eff3u;
            word = std::rotl ( word, 25 );
        }

        auto result = 0.00f;
        std::memcpy ( &result, words.data ( ), sizeof ( result ) );

        return result;
    }

    inline auto decrypt_land_time ( std::uint32_t value ) -> float
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 1>> ( value );

        for ( auto& word : words )
        {
            word = std::rotl ( word, 11 );
            word += 0xde1f41bcu;
            word = std::rotl ( word, 18 );
        }

        auto result = 0.00f;
        std::memcpy ( &result, words.data ( ), sizeof ( result ) );

        return result;
    }

    inline auto decrypt_last_tick_time ( std::uint32_t value ) -> float
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 1>> ( value );

        for ( auto& word : words )
        {
            word += 0xfebf38e4u;
            word ^= 0xad1611dbu;
            word = std::rotl ( word, 9 );
        }

        auto result = 0.00f;
        std::memcpy ( &result, words.data ( ), sizeof ( result ) );

        return result;
    }

    inline auto decrypt_lastsentticktime ( std::uint32_t value ) -> float
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 1>> ( value );

        for ( auto& word : words )
        {
            word ^= 0x2e3782a4u;
            word += 0x5c5df31u;
            word ^= 0x8fea3fdcu;
            word = std::rotl ( word, 15 );
        }

        auto result = 0.00f;
        std::memcpy ( &result, words.data ( ), sizeof ( result ) );

        return result;
    }

    inline auto decrypt_localplayer ( std::uint64_t value ) -> std::uint64_t
    {
        const auto handle = decryptor::read ( value + 0x18 );

        auto words = std::bit_cast<std::array<std::uint32_t, 2>> ( handle );

        for ( auto& word : words )
        {
            word += 0xe6a082cbu;
            word = std::rotl ( word, 31 );
            word += 0x70ed470bu;
            word ^= 0x8f910f67u;
        }

        return decryptor::get_handle ( std::bit_cast<std::uint64_t> ( words ) );
    }

    inline auto decrypt_max_velocity ( std::uint32_t value ) -> float
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 1>> ( value );

        for ( auto& word : words )
        {
            word += 0xd0bd229u;
            word = std::rotl ( word, 12 );
            word ^= 0x62ed404au;
        }

        auto result = 0.00f;
        std::memcpy ( &result, words.data ( ), sizeof ( result ) );

        return result;
    }

    inline auto decrypt_next_attack_time ( std::uint32_t value ) -> float
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 1>> ( value );

        for ( auto& word : words )
        {
            word = std::rotl ( word, 12 );
            word += 0x26d33d7fu;
            word = std::rotl ( word, 2 );
            word ^= 0x35d9b91u;
        }

        auto result = 0.00f;
        std::memcpy ( &result, words.data ( ), sizeof ( result ) );

        return result;
    }

    inline auto decrypt_next_reload_time ( std::uint32_t value ) -> float
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 1>> ( value );

        for ( auto& word : words )
        {
            word = std::rotl ( word, 31 );
            word += 0xfb57b957u;
            word = std::rotl ( word, 8 );
            word ^= 0xed107c9au;
        }

        auto result = 0.00f;
        std::memcpy ( &result, words.data ( ), sizeof ( result ) );

        return result;
    }

    inline auto decrypt_next_tick_time ( std::uint32_t value ) -> float
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 1>> ( value );

        for ( auto& word : words )
        {
            word ^= 0xd01a9874u;
            word += 0x13fd05a7u;
            word = std::rotl ( word, 30 );
        }

        auto result = 0.00f;
        std::memcpy ( &result, words.data ( ), sizeof ( result ) );

        return result;
    }

    inline auto decrypt_previous_inherited_velocity ( std::array<std::uint32_t, 3> value ) -> std::array<std::uint32_t, 3>
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 3>> ( value );

        for ( auto& word : words )
        {
            word += 0x55118a31u;
            word = std::rotl ( word, 29 );
            word += 0xe6af4fdeu;
            word = std::rotl ( word, 23 );
        }

        return std::bit_cast<std::array<std::uint32_t, 3>> ( words );
    }

    inline auto decrypt_previous_position ( std::array<std::uint32_t, 3> value ) -> std::array<std::uint32_t, 3>
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 3>> ( value );

        for ( auto& word : words )
        {
            word = std::rotl ( word, 30 );
            word += 0xa2d96df2u;
            word = std::rotl ( word, 8 );
            word += 0xf56d9ffau;
        }

        return std::bit_cast<std::array<std::uint32_t, 3>> ( words );
    }

    inline auto decrypt_previous_velocity ( std::array<std::uint32_t, 3> value ) -> std::array<std::uint32_t, 3>
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 3>> ( value );

        for ( auto& word : words )
        {
            word += 0x229c9d5eu;
            word = std::rotl ( word, 30 );
            word ^= 0x34f9851bu;
            word = std::rotl ( word, 30 );
        }

        return std::bit_cast<std::array<std::uint32_t, 3>> ( words );
    }

    inline auto decrypt_start_reload_time ( std::uint32_t value ) -> float
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 1>> ( value );

        for ( auto& word : words )
        {
            word ^= 0x5d8fc76au;
            word += 0x5649001cu;
            word = std::rotl ( word, 30 );
            word += 0xdc7646a0u;
        }

        auto result = 0.00f;
        std::memcpy ( &result, words.data ( ), sizeof ( result ) );

        return result;
    }

    inline auto decrypt_time_since_deploy ( std::uint32_t value ) -> float
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 1>> ( value );

        for ( auto& word : words )
        {
            word += 0x784a36a7u;
            word = std::rotl ( word, 12 );
            word += 0x8494e33cu;
        }

        auto result = 0.00f;
        std::memcpy ( &result, words.data ( ), sizeof ( result ) );

        return result;
    }

    inline auto decrypt_user_id ( std::uint64_t value ) -> std::uint64_t
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 2>> ( value );

        for ( auto& word : words )
        {
            word += 0x55118a35u;
            word = std::rotl ( word, 29 );
            word += 0xe6af4fdeu;
            word = std::rotl ( word, 23 );
        }

        return std::bit_cast<std::uint64_t> ( words );
    }

    inline auto decrypt_viewoffset ( std::array<std::uint32_t, 3> value ) -> std::array<std::uint32_t, 3>
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 3>> ( value );

        for ( auto& word : words )
        {
            word = std::rotl ( word, 30 );
            word ^= 0x11a3feb6u;
            word += 0xfa1e1e0du;
        }

        return std::bit_cast<std::array<std::uint32_t, 3>> ( words );
    }

    inline auto encrypt_client_tick_interval ( float value ) -> std::uint32_t
    {
        auto result = std::uint32_t ( );
        std::memcpy ( &result, &value, sizeof ( result ) );

        result ^= 0x9666edbeu;
        result = std::rotl ( result, 3 );
        result += 0x6391e8e2u;

        return result;
    }

    inline auto encrypt_fov ( float value ) -> std::uint32_t
    {
        auto result = std::uint32_t ( );
        std::memcpy ( &result, &value, sizeof ( result ) );

        result ^= 0x9666edbeu;
        result = std::rotl ( result, 3 );
        result += 0x6391e8e2u;

        return result;
    }

    inline auto encrypt_ground_angle ( float value ) -> std::uint32_t
    {
        auto result = std::uint32_t ( );
        std::memcpy ( &result, &value, sizeof ( result ) );

        result += 0x4f92e14bu;
        result = std::rotl ( result, 17 );
        result += 0xd48be688u;
        result = std::rotl ( result, 29 );

        return result;
    }

    inline auto encrypt_ground_angle_new ( float value ) -> std::uint32_t
    {
        auto result = std::uint32_t ( );
        std::memcpy ( &result, &value, sizeof ( result ) );

        result = std::rotl ( result, 11 );
        result ^= 0xd2ac5f19u;
        result += 0x7d6f237eu;
        result ^= 0x6d0d2c06u;

        return result;
    }

    inline auto encrypt_ground_normal ( std::array<std::uint32_t, 3> value ) -> std::array<std::uint32_t, 3>
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 3>> ( value );

        for ( auto& word : words )
        {
            word += 0xff2bd37eu;
            word = std::rotl ( word, 17 );
            word += 0x4ff8e975u;
            word = std::rotl ( word, 9 );
        }

        return std::bit_cast<std::array<std::uint32_t, 3>> ( words );
    }

    inline auto encrypt_ground_normal_new ( std::array<std::uint32_t, 3> value ) -> std::array<std::uint32_t, 3>
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 3>> ( value );

        for ( auto& word : words )
        {
            word += 0xa750f527u;
            word ^= 0x8c7cd1cdu;
            word = std::rotl ( word, 13 );
            word += 0x2ab52f01u;
        }

        return std::bit_cast<std::array<std::uint32_t, 3>> ( words );
    }

    inline auto encrypt_ground_time ( float value ) -> std::uint32_t
    {
        auto result = std::uint32_t ( );
        std::memcpy ( &result, &value, sizeof ( result ) );

        result += 0xa0d1ba64u;
        result ^= 0xdc2bfe8fu;
        result += 0x2035f5d5u;
        result = std::rotl ( result, 6 );

        return result;
    }

    inline auto encrypt_ground_velocity ( std::array<std::uint32_t, 3> value ) -> std::array<std::uint32_t, 3>
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 3>> ( value );

        for ( auto& word : words )
        {
            word += 0x84411a5au;
            word = std::rotl ( word, 31 );
            word += 0x98249303u;
            word = std::rotl ( word, 21 );
        }

        return std::bit_cast<std::array<std::uint32_t, 3>> ( words );
    }

    inline auto encrypt_ground_velocity_new ( std::array<std::uint32_t, 3> value ) -> std::array<std::uint32_t, 3>
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 3>> ( value );

        for ( auto& word : words )
        {
            word = std::rotl ( word, 3 );
            word ^= 0xe7b714dfu;
            word = std::rotl ( word, 12 );
        }

        return std::bit_cast<std::array<std::uint32_t, 3>> ( words );
    }

    inline auto encrypt_jump_time ( float value ) -> std::uint32_t
    {
        auto result = std::uint32_t ( );
        std::memcpy ( &result, &value, sizeof ( result ) );

        result = std::rotl ( result, 7 );
        result += 0xdbec100du;
        result = std::rotl ( result, 27 );

        return result;
    }

    inline auto encrypt_land_time ( float value ) -> std::uint32_t
    {
        auto result = std::uint32_t ( );
        std::memcpy ( &result, &value, sizeof ( result ) );

        result = std::rotl ( result, 14 );
        result += 0x21e0be44u;
        result = std::rotl ( result, 21 );

        return result;
    }

    inline auto encrypt_last_tick_time ( float value ) -> std::uint32_t
    {
        auto result = std::uint32_t ( );
        std::memcpy ( &result, &value, sizeof ( result ) );

        result = std::rotl ( result, 23 );
        result ^= 0xad1611dbu;
        result += 0x140c71cu;

        return result;
    }

    inline auto encrypt_max_velocity ( float value ) -> std::uint32_t
    {
        auto result = std::uint32_t ( );
        std::memcpy ( &result, &value, sizeof ( result ) );

        result ^= 0x62ed404au;
        result = std::rotl ( result, 20 );
        result += 0xf2f42dd7u;

        return result;
    }

    inline auto encrypt_next_attack_time ( float value ) -> std::uint32_t
    {
        auto result = std::uint32_t ( );
        std::memcpy ( &result, &value, sizeof ( result ) );

        result ^= 0x35d9b91u;
        result = std::rotl ( result, 30 );
        result += 0xd92cc281u;
        result = std::rotl ( result, 20 );

        return result;
    }

    inline auto encrypt_next_reload_time ( float value ) -> std::uint32_t
    {
        auto result = std::uint32_t ( );
        std::memcpy ( &result, &value, sizeof ( result ) );

        result ^= 0xed107c9au;
        result = std::rotl ( result, 24 );
        result += 0x4a846a9u;
        result = std::rotl ( result, 1 );

        return result;
    }

    inline auto encrypt_next_tick_time ( float value ) -> std::uint32_t
    {
        auto result = std::uint32_t ( );
        std::memcpy ( &result, &value, sizeof ( result ) );

        result = std::rotl ( result, 2 );
        result += 0xec02fa59u;
        result ^= 0xd01a9874u;

        return result;
    }

    inline auto encrypt_previous_inherited_velocity ( std::array<std::uint32_t, 3> value ) -> std::array<std::uint32_t, 3>
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 3>> ( value );

        for ( auto& word : words )
        {
            word = std::rotl ( word, 9 );
            word += 0x1950b022u;
            word = std::rotl ( word, 3 );
            word += 0xaaee75cfu;
        }

        return std::bit_cast<std::array<std::uint32_t, 3>> ( words );
    }

    inline auto encrypt_previous_position ( std::array<std::uint32_t, 3> value ) -> std::array<std::uint32_t, 3>
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 3>> ( value );

        for ( auto& word : words )
        {
            word += 0xa926006u;
            word = std::rotl ( word, 24 );
            word += 0x5d26920eu;
            word = std::rotl ( word, 2 );
        }

        return std::bit_cast<std::array<std::uint32_t, 3>> ( words );
    }

    inline auto encrypt_previous_velocity ( std::array<std::uint32_t, 3> value ) -> std::array<std::uint32_t, 3>
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 3>> ( value );

        for ( auto& word : words )
        {
            word = std::rotl ( word, 2 );
            word ^= 0x34f9851bu;
            word = std::rotl ( word, 2 );
            word += 0xdd6362a2u;
        }

        return std::bit_cast<std::array<std::uint32_t, 3>> ( words );
    }

    inline auto encrypt_start_reload_time ( float value ) -> std::uint32_t
    {
        auto result = std::uint32_t ( );
        std::memcpy ( &result, &value, sizeof ( result ) );

        result += 0x2389b960u;
        result = std::rotl ( result, 2 );
        result += 0xa9b6ffe4u;
        result ^= 0x5d8fc76au;

        return result;
    }

    inline auto encrypt_time_since_deploy ( float value ) -> std::uint32_t
    {
        auto result = std::uint32_t ( );
        std::memcpy ( &result, &value, sizeof ( result ) );

        result += 0x7b6b1cc4u;
        result = std::rotl ( result, 20 );
        result += 0x87b5c959u;

        return result;
    }

    inline auto encrypt_viewoffset ( std::array<std::uint32_t, 3> value ) -> std::array<std::uint32_t, 3>
    {
        auto words = std::bit_cast<std::array<std::uint32_t, 3>> ( value );

        for ( auto& word : words )
        {
            word += 0x5e1e1f3u;
            word ^= 0x11a3feb6u;
            word = std::rotl ( word, 2 );
        }

        return std::bit_cast<std::array<std::uint32_t, 3>> ( words );
    }

}