// Dumped by amexofficial on discord
// amexware.cc

#pragma once
#include <cstdint>
#include <bit>

namespace offsets
{

    namespace decryption
    {

        inline std::uintptr_t client_entities(std::uintptr_t hv_value)
        {
            std::uintptr_t rax = hv_value;
            std::uint32_t* rdx = reinterpret_cast<std::uint32_t*>(&rax);
            for (std::uint32_t _i = 0; _i < 2; ++_i) {
                std::uint32_t v = *rdx;
                v = (v << 31) | (v >> 1);
                v += 0x8F7F58E3u;
                v = (v << 31) | (v >> 1);
                v ^= 0x64DE867Fu;
                *rdx = v;
                ++rdx;
            }
            return rax;
        }

        inline std::uintptr_t entity_list(std::uintptr_t hv_value)
        {
            std::uintptr_t rax = hv_value;
            std::uint32_t* rdx = reinterpret_cast<std::uint32_t*>(&rax);
            for (std::uint32_t _i = 0; _i < 2; ++_i) {
                std::uint32_t v = *rdx;
                v += 0x0374D4FAu;
                v = (v << 27) | (v >> 5);
                v ^= 0x5DD1D7B5u;
                v -= 0x10D77418u;
                *rdx = v;
                ++rdx;
            }
            return rax;
        }

        inline std::uint32_t encrypt_fov(float input)
        {
            std::uint32_t v = std::bit_cast<std::uint32_t>(input);
            v ^= 0x7DCF10AFu;
            v = (v << 10) | (v >> 22);
            v += 0x06258F02u;
            return v;
        }

        inline std::uint32_t encrypt_PlayerWalkMovement_groundAngleNew_off_0x108(float value)
        {
            std::uint32_t v = std::bit_cast<std::uint32_t>(value);
            v = (v << 10) | (v >> 22);
            v -= 0x75B6E603u;
            v ^= 0x883CD959u;
            v += 0x5EF50FCAu;
            return v;
        }

        inline std::uint32_t encrypt_PlayerWalkMovement_groundTime_off_0x110(float value)
        {
            std::uint32_t v = std::bit_cast<std::uint32_t>(value);
            v += 0x340B5115u;
            v = (v << 25) | (v >> 7);
            v ^= 0x8D984D53u;
            return v;
        }

        inline std::uint32_t encrypt_PlayerWalkMovement_jumpTime_off_0x118(float value)
        {
            std::uint32_t v = std::bit_cast<std::uint32_t>(value);
            v += 0x5ED8266Au;
            v = (v << 24) | (v >> 8);
            v ^= 0x975CE3D8u;
            v = (v << 22) | (v >> 10);
            return v;
        }

        inline std::uint32_t encrypt_PlayerWalkMovement_landTime_off_0x120(float value)
        {
            std::uint32_t v = std::bit_cast<std::uint32_t>(value);
            v = (v << 7) | (v >> 25);
            v -= 0x075CBAD0u;
            v = (v << 7) | (v >> 25);
            return v;
        }

        inline std::uint32_t encrypt_PlayerWalkMovement_velocity_off_0x128(float value)
        {
            std::uint32_t v = std::bit_cast<std::uint32_t>(value);
            v ^= 0x5D22278Eu;
            v = (v << 14) | (v >> 18);
            v -= 0x10EB2F11u;
            v = (v << 23) | (v >> 9);
            return v;
        }

        inline std::uint32_t encrypt_PlayerWalkMovement_off_0x130(float value)
        {
            std::uint32_t v = std::bit_cast<std::uint32_t>(value);
            v -= 0x081A6F73u;
            v = (v << 9) | (v >> 23);
            v += 0x5904CE26u;
            return v;
        }

        inline std::uint32_t encrypt_PlayerWalkMovement_off_0x140(float value)
        {
            std::uint32_t v = std::bit_cast<std::uint32_t>(value);
            v = (v << 23) | (v >> 9);
            v -= 0x3A39AD4Bu;
            v ^= 0x9FB2FEABu;
            v = (v << 8) | (v >> 24);
            return v;
        }

        inline std::uint32_t encrypt_PlayerWalkMovement_off_0x150(float value)
        {
            std::uint32_t v = std::bit_cast<std::uint32_t>(value);
            v -= 0x799233B9u;
            v = (v << 19) | (v >> 13);
            v ^= 0x3149B54Eu;
            v = (v << 13) | (v >> 19);
            return v;
        }

        inline std::uint32_t encrypt_PlayerWalkMovement_off_0x160(float value)
        {
            std::uint32_t v = std::bit_cast<std::uint32_t>(value);
            v = (v << 24) | (v >> 8);
            v += 0x7BFB3B67u;
            v ^= 0xF96FC5FFu;
            return v;
        }

        inline std::uint32_t encrypt_PlayerWalkMovement_off_0x170(float value)
        {
            std::uint32_t v = std::bit_cast<std::uint32_t>(value);
            v ^= 0x4C3CC5A2u;
            v = (v << 7) | (v >> 25);
            v ^= 0x776AC171u;
            return v;
        }

        inline std::uint32_t encrypt_PlayerWalkMovement_off_0x180(float value)
        {
            std::uint32_t v = std::bit_cast<std::uint32_t>(value);
            v = (v << 9) | (v >> 23);
            v += 0x4100991Du;
            v = (v << 30) | (v >> 2);
            v ^= 0x36B7B7C8u;
            return v;
        }

        inline std::uint32_t encrypt_PlayerWalkMovement_off_0x190(float value)
        {
            std::uint32_t v = std::bit_cast<std::uint32_t>(value);
            v = (v << 26) | (v >> 6);
            v ^= 0x970EA115u;
            v += 0x5CC489D8u;
            return v;
        }

        inline std::uint32_t encrypt_PlayerWalkMovement_lastSprintTime_off_0x1A0(float value)
        {
            std::uint32_t v = std::bit_cast<std::uint32_t>(value);
            v ^= 0x86B1EA65u;
            v += 0x15E2ED57u;
            v = (v << 6) | (v >> 26);
            v += 0x0D6BF47Du;
            return v;
        }

        inline std::uint32_t encrypt_PlayerWalkMovement_sprintForced_off_0x1A8(float value)
        {
            std::uint32_t v = std::bit_cast<std::uint32_t>(value);
            v -= 0x49823E40u;
            v ^= 0x66ECADA2u;
            v -= 0x379EE2C7u;
            return v;
        }

        inline std::uintptr_t encrypt_PlayerWalkMovement_modify_off_0x1B8(std::uintptr_t ptr)
        {
            std::uintptr_t rax = ptr;
            std::uint32_t* lane = reinterpret_cast<std::uint32_t*>(&rax);
            for (std::uint32_t _i = 0; _i < 2; ++_i) {
                std::uint32_t v = *lane;
                v ^= 0x3A757ECFu;
                v = (v << 22) | (v >> 10);
                v += 0x0B33D012u;
                *lane = v;
                ++lane;
            }
            return rax;
        }

        inline std::uint32_t encrypt_PlayerWalkMovement_wasGrounded_off_0x1C4(bool value)
        {
            std::uint32_t v = value ? 1u : 0u;
            v ^= 0x4E950628u;
            v += 0x5025DDFAu;
            v ^= 0xE0887AA0u;
            v -= 0x69094678u;
            return v;
        }

        inline std::uint32_t encrypt_PlayerWalkMovement_climbing_off_0x1CC(bool value)
        {
            std::uint32_t v = value ? 1u : 0u;
            v = (v << 27) | (v >> 5);
            v ^= 0x9F320C62u;
            v -= 0x5FE4A4CCu;
            return v;
        }

        inline std::uint32_t encrypt_PlayerWalkMovement_wasClimbing_off_0x1D4(bool value)
        {
            std::uint32_t v = value ? 1u : 0u;
            v ^= 0x2F349C2Au;
            v += 0x0D7F8388u;
            v = (v << 9) | (v >> 23);
            v -= 0x6A8FBC86u;
            return v;
        }

        inline std::uint32_t encrypt_PlayerWalkMovement_sliding_off_0x1DC(bool value)
        {
            std::uint32_t v = value ? 1u : 0u;
            v ^= 0xD0BC2C1Eu;
            v -= 0x29EA2CE6u;
            v = (v << 2) | (v >> 30);
            return v;
        }

        inline std::uint32_t encrypt_PlayerWalkMovement_wasSliding_off_0x1E4(bool value)
        {
            std::uint32_t v = value ? 1u : 0u;
            v = (v << 27) | (v >> 5);
            v -= 0x262402E2u;
            v = (v << 20) | (v >> 12);
            return v;
        }

        inline std::uint32_t encrypt_PlayerWalkMovement_wasSwimming_off_0x1F4(bool value)
        {
            std::uint32_t v = value ? 1u : 0u;
            v = (v << 11) | (v >> 21);
            v ^= 0x9CD3AFD8u;
            v = (v << 19) | (v >> 13);
            return v;
        }

        inline std::uint32_t encrypt_PlayerWalkMovement_jumping_off_0x1FC(bool value)
        {
            std::uint32_t v = value ? 1u : 0u;
            v = (v << 7) | (v >> 25);
            v += 0x3DAD2B0Au;
            v = (v << 17) | (v >> 15);
            return v;
        }

        inline std::uint32_t encrypt_PlayerWalkMovement_flying_off_0x204(bool value)
        {
            std::uint32_t v = value ? 1u : 0u;
            v += 0x5544E2B8u;
            v = (v << 12) | (v >> 20);
            v += 0x4557C79Au;
            return v;
        }

        inline std::uint32_t encrypt_PlayerWalkMovement_falling_off_0x20C(bool value)
        {
            std::uint32_t v = value ? 1u : 0u;
            v ^= 0x83D7F656u;
            v = (v << 2) | (v >> 30);
            v ^= 0x9A985892u;
            return v;
        }

        inline std::uint32_t encrypt_PlayerWalkMovement_forcedDuckDelta_off_0x214(bool value)
        {
            std::uint32_t v = value ? 1u : 0u;
            v -= 0x6256D92Cu;
            v ^= 0x9DFE7614u;
            v = (v << 16) | (v >> 16);
            return v;
        }

        inline std::uint32_t encrypt_PlayerInput_off_0x80(float value)
        {
            std::uint32_t v = std::bit_cast<std::uint32_t>(value);
            v ^= 0x469CA23Du;
            v -= 0x5DF22303u;
            v = (v << 3) | (v >> 29);
            v += 0x2DD1863Au;
            return v;
        }

        inline std::uintptr_t player_inventory__fb65c5e1ca75f4c0af3e48d3edc840a5314df547(std::uintptr_t hv_value)
        {
            std::uintptr_t rax = hv_value;
            std::uint32_t* rdx = reinterpret_cast<std::uint32_t*>(&rax);
            for (std::uint32_t _i = 0; _i < 2; ++_i) {
                std::uint32_t v = *rdx;
                v = (v << 14) | (v >> 18);
                v ^= 0xFBEB4E79u;
                v = (v << 17) | (v >> 15);
                v -= 0x167A6378u;
                *rdx = v;
                ++rdx;
            }
            return rax;
        }

        inline std::uintptr_t player_inventory__2d2726cb267ea1b790847f3dfcbb25b49a7e2732(std::uintptr_t hv_value)
        {
            std::uintptr_t rax = hv_value;
            std::uint32_t* rdx = reinterpret_cast<std::uint32_t*>(&rax);
            for (std::uint32_t _i = 0; _i < 2; ++_i) {
                std::uint32_t v = *rdx;
                v = (v << 12) | (v >> 20);
                v += 0xD06D4709u;
                v = (v << 21) | (v >> 11);
                *rdx = v;
                ++rdx;
            }
            return rax;
        }

        inline std::uintptr_t player_eyes__0617f8e0e10b3469945f5ed5746fe9efa6687fbe(std::uintptr_t hv_value)
        {
            std::uintptr_t rax = hv_value;
            std::uint32_t* rdx = reinterpret_cast<std::uint32_t*>(&rax);
            for (std::uint32_t _i = 0; _i < 2; ++_i) {
                std::uint32_t v = *rdx;
                v ^= 0xBA83296Eu;
                v = (v << 19) | (v >> 13);
                v += 0xCAD99CFBu;
                v = (v << 22) | (v >> 10);
                *rdx = v;
                ++rdx;
            }
            return rax;
        }

        inline std::uintptr_t player_eyes__ceb97a5693abd4b37b2b26b24c531e9d861e30d9(std::uintptr_t hv_value)
        {
            std::uintptr_t rax = hv_value;
            std::uint32_t* rdx = reinterpret_cast<std::uint32_t*>(&rax);
            for (std::uint32_t _i = 0; _i < 2; ++_i) {
                std::uint32_t v = *rdx;
                v += 0x45CC7567u;
                v = (v << 8) | (v >> 24);
                v += 0x3443CA46u;
                *rdx = v;
                ++rdx;
            }
            return rax;
        }

        inline std::uintptr_t cl_active_item__f075f5c85087e5cb0407f8ff6b52745969388a44(std::uintptr_t hv_value)
        {
            std::uintptr_t rax = hv_value;
            std::uint32_t* rdx = reinterpret_cast<std::uint32_t*>(&rax);
            for (std::uint32_t _i = 0; _i < 2; ++_i) {
                std::uint32_t v = *rdx;
                v ^= 0xC7F486D7u;
                v += 0x021AB371u;
                v = (v << 11) | (v >> 21);
                v += 0x70077F50u;
                *rdx = v;
                ++rdx;
            }
            return rax;
        }

        inline std::uintptr_t cl_active_item__8572d52613e2b1042f439a76301bec77bede63f6(std::uintptr_t hv_value)
        {
            std::uintptr_t rax = hv_value;
            std::uint32_t* rdx = reinterpret_cast<std::uint32_t*>(&rax);
            for (std::uint32_t _i = 0; _i < 2; ++_i) {
                std::uint32_t v = *rdx;
                v = (v << 27) | (v >> 5);
                v ^= 0xBF1B783Du;
                v = (v << 30) | (v >> 2);
                *rdx = v;
                ++rdx;
            }
            return rax;
        }

        #ifndef PWM_WRITE_U32
        #define PWM_WRITE_U32(addr, v) driver->Write<uint32_t>((addr), (v))
        #endif
        #define PWM_WRITE(NAME, BODY) \
        	inline void write_PWM_##NAME(uint64_t addr, float value) { \
        		uint32_t v = std::bit_cast<uint32_t>(value); \
        		BODY \
        		PWM_WRITE_U32(addr, v); \
        	}
        #define PWM_WRITE_BOOL(NAME, BODY) \
        	inline void write_PWM_##NAME(uint64_t addr, float value) { \
        		uint32_t v = (value != 0.f) ? 1u : 0u; \
        		BODY \
        		PWM_WRITE_U32(addr, v); \
        	}
        PWM_WRITE(GroundAngleNew,          v = (v << 0xAu) | (v >> 0x16u); v -= 0x75B6E603u; v ^= 0x883CD959u; v += 0x5EF50FCAu; )
        PWM_WRITE(GroundTime,              v += 0x340B5115u; v = (v << 0x19u) | (v >> 0x7u); v ^= 0x8D984D53u; )
        PWM_WRITE(JumpTime,                v += 0x5ED8266Au; v = (v << 0x18u) | (v >> 0x8u); v ^= 0x975CE3D8u; v = (v << 0x16u) | (v >> 0xAu); )
        PWM_WRITE(LandTime,                v = (v << 0x7u) | (v >> 0x19u); v -= 0x75CBAD0u; v = (v << 0x7u) | (v >> 0x19u); )
        PWM_WRITE(Velocity,                v ^= 0x5D22278Eu; v = (v << 0xEu) | (v >> 0x12u); v -= 0x10EB2F11u; v = (v << 0x17u) | (v >> 0x9u); )
        PWM_WRITE(Off_0x130,               v -= 0x81A6F73u; v = (v << 0x9u) | (v >> 0x17u); v += 0x5904CE26u; )
        PWM_WRITE(Off_0x140,               v = (v << 0x17u) | (v >> 0x9u); v -= 0x3A39AD4Bu; v ^= 0x9FB2FEABu; v = (v << 0x8u) | (v >> 0x18u); )
        PWM_WRITE(Off_0x150,               v -= 0x799233B9u; v = (v << 0x13u) | (v >> 0xDu); v ^= 0x3149B54Eu; v = (v << 0xDu) | (v >> 0x13u); )
        PWM_WRITE(Off_0x160,               v = (v << 0x18u) | (v >> 0x8u); v += 0x7BFB3B67u; v ^= 0xF96FC5FFu; )
        PWM_WRITE(Off_0x170,               v ^= 0x4C3CC5A2u; v = (v << 0x7u) | (v >> 0x19u); v ^= 0x776AC171u; )
        PWM_WRITE(Off_0x180,               v = (v << 0x9u) | (v >> 0x17u); v += 0x4100991Du; v = (v << 0x1Eu) | (v >> 0x2u); v ^= 0x36B7B7C8u; )
        PWM_WRITE(Off_0x190,               v = (v << 0x1Au) | (v >> 0x6u); v ^= 0x970EA115u; v += 0x5CC489D8u; )
        PWM_WRITE(LastSprintTime,          v ^= 0x86B1EA65u; v += 0x15E2ED57u; v = (v << 0x6u) | (v >> 0x1Au); v += 0xD6BF47Du; )
        PWM_WRITE(SprintForced,            v -= 0x49823E40u; v ^= 0x66ECADA2u; v -= 0x379EE2C7u; )
        PWM_WRITE_BOOL(WasGrounded,             v ^= 0x4E950628u; v += 0x5025DDFAu; v ^= 0xE0887AA0u; v -= 0x69094678u; )
        PWM_WRITE_BOOL(Climbing,                v = (v << 0x1Bu) | (v >> 0x5u); v ^= 0x9F320C62u; v -= 0x5FE4A4CCu; )
        PWM_WRITE_BOOL(WasClimbing,             v ^= 0x2F349C2Au; v += 0xD7F8388u; v = (v << 0x9u) | (v >> 0x17u); v -= 0x6A8FBC86u; )
        PWM_WRITE_BOOL(Sliding,                 v ^= 0xD0BC2C1Eu; v -= 0x29EA2CE6u; v = (v << 0x2u) | (v >> 0x1Eu); )
        PWM_WRITE_BOOL(WasSliding,              v = (v << 0x1Bu) | (v >> 0x5u); v -= 0x262402E2u; v = (v << 0x14u) | (v >> 0xCu); )
        PWM_WRITE_BOOL(WasSwimming,             v = (v << 0xBu) | (v >> 0x15u); v ^= 0x9CD3AFD8u; v = (v << 0x13u) | (v >> 0xDu); )
        PWM_WRITE_BOOL(Jumping,                 v = (v << 0x7u) | (v >> 0x19u); v += 0x3DAD2B0Au; v = (v << 0x11u) | (v >> 0xFu); )
        PWM_WRITE_BOOL(Flying,                  v += 0x5544E2B8u; v = (v << 0xCu) | (v >> 0x14u); v += 0x4557C79Au; )
        PWM_WRITE_BOOL(Falling,                 v ^= 0x83D7F656u; v = (v << 0x2u) | (v >> 0x1Eu); v ^= 0x9A985892u; )
        PWM_WRITE_BOOL(ForcedDuckDelta,         v -= 0x6256D92Cu; v ^= 0x9DFE7614u; v = (v << 0x10u) | (v >> 0x10u); )
        PWM_WRITE_BOOL(Off_0x20,                v = (v << 0x9u) | (v >> 0x17u); v += 0x10EB2F11u; v = (v << 0x12u) | (v >> 0xEu); v ^= 0x5D22278Eu; )
        #undef PWM_WRITE
        #undef PWM_WRITE_BOOL

        inline void write_PWM_CapsuleCenter(uint64_t, float) {}
        inline void write_PWM_CapsuleHeightDucked(uint64_t, float) {}
        inline void write_PWM_CapsuleCenterDucked(uint64_t, float) {}
        inline void write_PWM_CapsuleRadius(uint64_t, float) {}
        inline void write_PWM_GravityTestRadius(uint64_t, float) {}
        inline void write_PWM_MaxStepHeight(uint64_t, float) {}
        inline void write_PWM_GravityMultiplier(uint64_t, float) {}
        inline void write_PWM_GravityMultiplierSwimming(uint64_t, float) {}
        inline void write_PWM_Off_0xB8(uint64_t, float) {}
        inline void write_PWM_Off_0xC0(uint64_t, float) {}
        inline void write_PWM_Off_0xC8(uint64_t, float) {}
        inline void write_PWM_Off_0xD0(uint64_t, float) {}
        inline void write_PWM_Ladder(uint64_t, float) {}
        inline void write_PWM_GroundAngle(uint64_t, float) {}
        inline void write_PWM_AttemptedMountTime(uint64_t, float) {}
        inline void write_PWM_Swimming(uint64_t, float) {}
        inline void write_PWM_Off_0x21C(uint64_t, float) {}
        inline void write_PWM_Off_0x28(uint64_t, float) {}

    }

}