25903346

pinned 6:50am (EST) · updated 2026-10-13 11:50 UTC

Resources

#pragma once

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

namespace resources
{
    namespace ClassNames
    {
        inline auto BaseNetworkableStatic = std::string ( e ( "%32fc4efe885e0a8a8590dc8849d3d0cfdcf7f2ec" ) );
        inline auto BufferList = std::string ( e ( "%53bb56292d181903957f07145cc3160c6ceb1ca8" ) );
        inline auto BuildingBlock = std::string ( e ( "%bde4c62cc66b8f96ddfd7087a401a95f94646fcc" ) );
        inline auto CameraMan = std::string ( e ( "CameraMan" ) );
        inline auto CameraUpdateHookStatic = std::string ( e ( "%80f9037080f0c1863fd247172695a76f0d298776" ) );
        inline auto ConsoleSystem = std::string ( e ( "%f249402a474b87ef91baeeac98c6c3f59f5d3d4d" ) );
        inline auto ConsoleSystemCommand = std::string ( e ( "%482b988fcb3ccac9ae75f66da6f80a77cb753a69" ) );
        inline auto ConsoleSystemIndex = std::string ( e ( "%71c82f444a3fcd45adc55f810d5c03cd69ef48d0" ) );
        inline auto ConsoleSystemIndexClient = std::string ( e ( "%e153083c361b0d14eff1dad1eaaae2fa41607611" ) );
        inline auto ConsoleSystemIndexStatic = std::string ( e ( "%5b05bec8a2ef7cc57ea0aec5b39ad20d3bc1cdc1" ) );
        inline auto ConvarClientStatic = std::string ( e ( "%dc8b7b7b5fa9e682fa6c40a7cdeb23698e956b45" ) );
        inline auto ConvarGraphicsStatic = std::string ( e ( "%6459565bd947bf37fe6ac1ac1e0fd0b2db2521ac" ) );
        inline auto ConvarPlayerStatic = std::string ( e ( "%38be46ed67e086e7473aef69702dd7cfc307cb62" ) );
        inline auto ConvarServerStatic = std::string ( e ( "%ef15afe4abf94dd2f6700db0c0b1ae65a0890e2b" ) );
        inline auto EncryptedValue = std::string ( e ( "%a487a47fed81b4343a3b36b22936306b2fedeba8" ) );
        inline auto EntityRealm = std::string ( e ( "%ca23af51c2273f96d2cbc335a8a25cebc5a72857" ) );
        inline auto EntityRef = std::string ( e ( "%28a579c4563edbf7f30c999606708ef05c9e5e9d" ) );
        inline auto GameManager = std::string ( e ( "%94aa85c5e800cf18dac534782b8cf6d0a25f4d98" ) );
        inline auto GameManagerStatic = std::string ( e ( "%8c7c9259d4c5054de20bb06a5ab8e904107510ca" ) );
        inline auto HiddenField = std::string ( e ( "%5f03c55f026606e5fa66964fb040da97c91da0ee" ) );
        inline auto HitTest = std::string ( e ( "%e545e5aacf5be79aa6672e5ba49ec8aa00f66e24" ) );
        inline auto InputMessage = std::string ( e ( "%6c3fe6b82b323228c39787e4348e4dae154bd076" ) );
        inline auto InputState = std::string ( e ( "%19dbe199cfb50143aa30e1d5b7447593fb722604" ) );
        inline auto Interpolator = std::string ( e ( "%67acc45caf979a6e9e65574160e728188e1f3cc2" ) );
        inline auto Item = std::string ( e ( "%2b588a780bd1aa3b2e771e6a356ee85c567afb59" ) );
        inline auto ItemContainer = std::string ( e ( "%0d7216e679cbaf58cd179c6009d7ce03d5d6feb6" ) );
        inline auto ItemContainerId = std::string ( e ( "%b768c097c0273b29f39b00adc434ac503e0dcef7" ) );
        inline auto ItemIconStatic = std::string ( e ( "%49317043f2ec19969c4e4ed98875cd6193fff0c1" ) );
        inline auto ItemId = std::string ( e ( "%c6a72cf7c670d14169389585043b38fcdf728b9f" ) );
        inline auto ListComponentProjectile = std::string ( e ( "ListComponent`1" ) );
        inline auto ListDictionary = std::string ( e ( "%fea45df2cee9b39d209e12a4907092c687cc593e" ) );
        inline auto ListHashSet = std::string ( e ( "%52d687a9bf4ef563fce3533c937bca9ac1f3a2fa" ) );
        inline auto LoadingScreen = std::string ( e ( "UI_LoadingScreen" ) );
        inline auto LocalPlayer = std::string ( e ( "%bc775426e1a6d4182006bc2dbf5578bddef42475" ) );
        inline auto LocalPlayerStatic = std::string ( e ( "%2ec826d514d6be5ff4649794b79e14e05d9e326f" ) );
        inline auto MixerSnapshotManager = std::string ( e ( "MixerSnapshotManager" ) );
        inline auto ModelState = std::string ( e ( "%6b43371b999fd7dc2f3c80ce80c23118161e1a44" ) );
        inline auto NetworkableId = std::string ( e ( "%b3b7bbf3cc4c07f712446e5f837f45ae0cb06fe9" ) );
        inline auto PlayerTeam = std::string ( e ( "%4bcfb88948bcb8762176961ac081cd9ab41d7ce7" ) );
        inline auto PlayerTeamMember = std::string ( e ( "%3beeba8903105386db7305fb80b26ac0e2e54bbf" ) );
        inline auto PlayerTick = std::string ( e ( "%db787bd10cfdd5b1b398c2914e492b371cb95b4c" ) );
        inline auto PositionLerp = std::string ( e ( "%99790f9390e13e265c502cf290252fee5da57b0f" ) );
        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 ( "%25a8e8aa429689c0253eaaaf5fbb21a79ce944fa" ) );
        inline auto TodSkyStatic = std::string ( e ( "%14ac2ba730747467bc9e03f8ebc0de8acd0c12c4" ) );
        inline auto TransformSnapshot = std::string ( e ( "%5e918b2b3b58d6b2e3635865c94150eb3a71e200" ) );
    }

    namespace AttackEntity
    {
        inline constexpr auto StartAttackCooldown = std::uint64_t ( 0x2acb200 );
        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 ( 0x6033b60 );
        inline constexpr auto ServerRPC = std::uint64_t ( 0x601d8f0 );
        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 ( 0xa0 );
        inline constexpr auto triggers = std::uint64_t ( 0x118 );
    }

    namespace BaseMelee
    {
        inline constexpr auto ProcessAttack = std::uint64_t ( 0x26a12d0 );
        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 ( 0x1110f4b8 );
        inline constexpr auto clientEntities = std::uint64_t ( 0x30 );
    }

    namespace BasePlayer
    {
        inline constexpr auto OnViewModeChanged = std::uint64_t ( 0x571ef40 );
        inline constexpr auto _displayName = std::uint64_t ( 0x2e8 );
        inline constexpr auto _lookingAt = std::uint64_t ( 0x718 );
        inline constexpr auto clActiveItem = std::uint64_t ( 0x590 );
        inline constexpr auto clientTeam = std::uint64_t ( 0x358 );
        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 ( 0x2e0 );
        inline constexpr auto input = std::uint64_t ( 0x400 );
        inline constexpr auto inventory = std::uint64_t ( 0x5b0 );
        inline constexpr auto lastSentTick = std::uint64_t ( 0x4c8 );
        inline constexpr auto lastSentTickTime = std::uint64_t ( 0x6a0 );
        inline constexpr auto modelState = std::uint64_t ( 0x318 );
        inline constexpr auto modifiers = std::uint64_t ( 0x408 );
        inline constexpr auto mounted = std::uint64_t ( 0x5e8 );
        inline constexpr auto movement = std::uint64_t ( 0x2f0 );
        inline constexpr auto playerFlags = std::uint64_t ( 0x6e0 );
        inline constexpr auto playerModel = std::uint64_t ( 0x4b8 );
        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 ( 0x34d0380 );
        inline constexpr auto UpdateAmmoDisplay = std::uint64_t ( 0x34debe0 );
        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 ( 0x100 );
        inline constexpr auto aspectOffset = std::uint64_t ( 0xa0 );
        inline constexpr auto bob = std::uint64_t ( 0x130 );
        inline constexpr auto lower = std::uint64_t ( 0x98 );
        inline constexpr auto punch = std::uint64_t ( 0x90 );
        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 ( 0xe422dc0 );
    }

    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 ( 0x112a1590 );
    }

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

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

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

    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 ( 0x111b1298 );
    }

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

    namespace ConvarClientStatic
    {
        inline constexpr auto TypeInfo = std::uint64_t ( 0x11103760 );
        inline constexpr auto camlerp = std::uint64_t ( 0x3cc );
        inline constexpr auto camspeed = std::uint64_t ( 0x880 );
    }

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

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

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

    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 ( 0x20f9d50 );
        inline constexpr auto TypeInfo = std::uint64_t ( 0x1119adb0 );
    }

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

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

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

    namespace HitTest
    {
        inline constexpr auto AttackRay = std::uint64_t ( 0x38 );
        inline constexpr auto DidHit = std::uint64_t ( 0x30 );
        inline constexpr auto HitDistance = std::uint64_t ( 0x18 );
        inline constexpr auto HitEntity = std::uint64_t ( 0x68 );
        inline constexpr auto HitMaterial = std::uint64_t ( 0x10 );
        inline constexpr auto HitNormal = std::uint64_t ( 0xcc );
        inline constexpr auto HitPart = std::uint64_t ( 0xa4 );
        inline constexpr auto HitPoint = std::uint64_t ( 0x24 );
        inline constexpr auto HitTransform = std::uint64_t ( 0xa8 );
        inline constexpr auto MaxDistance = std::uint64_t ( 0xc8 );
        inline constexpr auto Radius = std::uint64_t ( 0x1c );
        inline constexpr auto TypeInfo = std::uint64_t ( 0x111593f0 );
        inline constexpr auto damageProperties = std::uint64_t ( 0xc0 );
    }

    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 ( 0x11161cb0 );
        inline constexpr auto aimAngles = std::uint64_t ( 0x20 );
        inline constexpr auto buttons = std::uint64_t ( 0x1c );
        inline constexpr auto mouseDelta = std::uint64_t ( 0x10 );
    }

    namespace InputState
    {
        inline constexpr auto TypeInfo = std::uint64_t ( 0x11157d50 );
        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 ( 0x11155020 );
        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 ( 0x11198740 );
        inline constexpr auto amount = std::uint64_t ( 0x8c );
        inline constexpr auto heldEntity = std::uint64_t ( 0x70 );
        inline constexpr auto info = std::uint64_t ( 0xe0 );
        inline constexpr auto position = std::uint64_t ( 0x90 );
        inline constexpr auto uid = std::uint64_t ( 0xa8 );
        inline constexpr auto worldEnt = std::uint64_t ( 0x50 );
    }

    namespace ItemContainer
    {
        inline constexpr auto flags = std::uint64_t ( 0x24 );
        inline constexpr auto itemList = std::uint64_t ( 0x18 );
        inline constexpr auto uid = std::uint64_t ( 0x50 );
    }

    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 ( 0x110b26f0 );
        inline constexpr auto containerLootStartTimes = std::uint64_t ( 0x10 );
    }

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

    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 ( 0x11106690 );
    }

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

    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 ( 0x258 );
        inline constexpr auto TypeInfo = std::uint64_t ( 0x11156110 );
    }

    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 ( 0xd0 );
    }

    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 ( 0x11106a40 );
        inline constexpr auto flags = std::uint64_t ( 0x58 );
        inline constexpr auto lookDir = std::uint64_t ( 0x30 );
        inline constexpr auto waterLevel = std::uint64_t ( 0x14 );
    }

    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 ( 0x111142b8 );
    }

    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 ( 0x60 );
        inline constexpr auto containerMain = std::uint64_t ( 0x38 );
        inline constexpr auto containerWear = std::uint64_t ( 0x78 );
        inline constexpr auto loot = std::uint64_t ( 0x48 );
    }

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

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

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

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

    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 ( 0x50 );
    }

    namespace ProgressBar
    {
        inline constexpr auto Instance = std::uint64_t ( 0x8 );
        inline constexpr auto leftField = std::uint64_t ( 0x48 );
        inline constexpr auto timeCounter = std::uint64_t ( 0x2c );
        inline constexpr auto timeFinished = std::uint64_t ( 0x28 );
    }

    namespace Projectile
    {
        inline constexpr auto DoHit = std::uint64_t ( 0x67fd550 );
        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 hitTest = std::uint64_t ( 0x118 );
        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 ( 0x24709d0 );
    }

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

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

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

    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 ( 0x40 );
    }

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

    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 ( 0x111c5920 );
        inline constexpr auto instances = std::uint64_t ( 0xa0 );
    }

    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 ^= 0x7e2722a2u;
            word = std::rotl ( word, 19 );
            word ^= 0x7220fa08u;
        }

        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 ^= 0x8d10a56u;
            word = std::rotl ( word, 11 );
            word += 0xb111dcf1u;
        }

        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 += 0x5230de53u;
            word ^= 0x21beb990u;
            word += 0x60b0dae3u;
            word = std::rotl ( word, 1 );
        }

        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 ^= 0x66b44004u;
            word = std::rotl ( word, 9 );
            word ^= 0x84ff76au;
            word += 0x9616a7f4u;
        }

        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 += 0x3f6d2780u;
            word ^= 0x99f9efbbu;
            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 += 0x5230de53u;
            word ^= 0x21beb990u;
            word += 0x60b0dae3u;
            word = std::rotl ( word, 1 );
        }

        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, 2 );
            word += 0x23cdad0u;
            word = std::rotl ( word, 18 );
            word ^= 0x5c7ed324u;
        }

        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 += 0x2c179544u;
            word ^= 0x7ea1d8b9u;
            word = std::rotl ( word, 12 );
        }

        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, 19 );
            word += 0xb24392c5u;
            word ^= 0x7fa45cabu;
        }

        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 ^= 0xaae8c423u;
            word = std::rotl ( word, 23 );
            word += 0xec93d20bu;
        }

        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 ^= 0x40ee9122u;
            word += 0xd95161d2u;
            word = std::rotl ( word, 23 );
        }

        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 ^= 0x3b7a99eau;
            word = std::rotl ( word, 25 );
            word += 0x10d8231fu;
        }

        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 += 0x446482c0u;
            word = std::rotl ( word, 27 );
            word += 0x31656392u;
        }

        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 ^= 0x712e8880u;
            word += 0x31f9136fu;
            word = std::rotl ( word, 24 );
            word ^= 0xef429512u;
        }

        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, 7 );
            word ^= 0xbeb129b9u;
            word += 0x3755e2b7u;
            word = std::rotl ( word, 29 );
        }

        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 += 0x86998bf8u;
            word = std::rotl ( word, 1 );
            word += 0x22e95b66u;
            word = std::rotl ( word, 17 );
        }

        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 = std::rotl ( word, 2 );
            word += 0xc9548203u;
            word = std::rotl ( word, 3 );
            word ^= 0xe14d71e4u;
        }

        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 ^= 0xa4323435u;
            word = std::rotl ( word, 24 );
            word ^= 0x6ae10bc9u;
            word = std::rotl ( word, 8 );
        }

        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 ^= 0x8d10a56u;
            word = std::rotl ( word, 11 );
            word += 0xb111dcf1u;
        }

        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 += 0x553b0e30u;
            word = std::rotl ( word, 18 );
            word += 0x173d62a1u;
            word ^= 0xfa23b42cu;
        }

        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 += 0xd3fdb248u;
            word = std::rotl ( word, 27 );
            word += 0x2c4f4852u;
        }

        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 += 0x7e53d965u;
            word ^= 0xb24c0be0u;
            word += 0x5b9334eau;
            word ^= 0x233d3a63u;
        }

        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 += 0x8958ee56u;
            word = std::rotl ( word, 28 );
            word ^= 0x24ce652eu;
        }

        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 += 0x387c578bu;
            word ^= 0x8effdcdu;
            word += 0x4b67a7bdu;
        }

        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 += 0x1dfe8b0au;
            word = std::rotl ( word, 7 );
            word += 0x9a367984u;
            word = std::rotl ( word, 1 );
        }

        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 = std::rotl ( word, 24 );
            word += 0xc2631636u;
            word = std::rotl ( word, 16 );
        }

        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 += 0xff904cf9u;
            word ^= 0xbef3bfdfu;
            word += 0x15507e6du;
        }

        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 += 0x8ad165ccu;
            word ^= 0x3aa0c0a4u;
            word = std::rotl ( word, 15 );
            word += 0x8d72916eu;
        }

        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 += 0x387c578fu;
            word ^= 0x8effdc9u;
            word += 0x4b67a7b9u;
        }

        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 ^= 0x2203e023u;
            word = std::rotl ( word, 25 );
            word ^= 0x6434bbc1u;
        }

        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 = std::rotl ( result, 31 );
        result += 0x9f4f251du;
        result ^= 0x21beb990u;
        result += 0xadcf21adu;

        return result;
    }

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

        result = std::rotl ( result, 31 );
        result += 0x9f4f251du;
        result ^= 0x21beb990u;
        result += 0xadcf21adu;

        return result;
    }

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

        result ^= 0x5c7ed324u;
        result = std::rotl ( result, 14 );
        result += 0xfdc32530u;
        result = std::rotl ( result, 30 );

        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, 20 );
        result ^= 0x7ea1d8b9u;
        result += 0xd3e86abcu;

        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 ^= 0x7fa45cabu;
            word += 0x4dbc6d3bu;
            word = std::rotl ( word, 13 );
        }

        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 += 0x136c2df5u;
            word = std::rotl ( word, 9 );
            word ^= 0xaae8c423u;
        }

        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 = std::rotl ( result, 9 );
        result += 0x26ae9e2eu;
        result ^= 0x40ee9122u;

        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 += 0xef27dce1u;
            word = std::rotl ( word, 7 );
            word ^= 0x3b7a99eau;
        }

        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 += 0xce9a9c6eu;
            word = std::rotl ( word, 5 );
            word += 0xbb9b7d40u;
        }

        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, 3 );
        result += 0xc8aa1d49u;
        result ^= 0xbeb129b9u;
        result = std::rotl ( result, 25 );

        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, 15 );
        result += 0xdd16a49au;
        result = std::rotl ( result, 31 );
        result += 0x79667408u;

        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 ^= 0xe14d71e4u;
        result = std::rotl ( result, 29 );
        result += 0x36ab7dfdu;
        result = std::rotl ( result, 30 );

        return result;
    }

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

        result ^= 0xfa23b42cu;
        result += 0xe8c29d5fu;
        result = std::rotl ( result, 14 );
        result += 0xaac4f1d0u;

        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 += 0xd3b0b7aeu;
        result = std::rotl ( result, 5 );
        result += 0x2c024db8u;

        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 ^= 0x233d3a63u;
        result += 0xa46ccb16u;
        result ^= 0xb24c0be0u;
        result += 0x81ac269bu;

        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 ^= 0x24ce652eu;
        result = std::rotl ( result, 4 );
        result += 0x76a711aau;

        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 += 0xb4985843u;
            word ^= 0x8effdcdu;
            word += 0xc783a875u;
        }

        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 = std::rotl ( word, 31 );
            word += 0x65c9867cu;
            word = std::rotl ( word, 25 );
            word += 0xe20174f6u;
        }

        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, 16 );
            word += 0x3d9ce9cau;
            word = std::rotl ( word, 8 );
        }

        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 += 0xeaaf8193u;
        result ^= 0xbef3bfdfu;
        result += 0x6fb307u;

        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 += 0x728d6e92u;
        result = std::rotl ( result, 17 );
        result ^= 0x3aa0c0a4u;
        result += 0x752e9a34u;

        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 ^= 0x6434bbc1u;
            word = std::rotl ( word, 7 );
            word ^= 0x2203e023u;
        }

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

}