codm/ligma-cheat/ligma-cheat/SDK/assembly-csharp.dll/includes/gamebase/pawn.h

#pragma once
#include <il2cpp/il2cpp.h>
namespace gamebase {

    class pawn {
      public:
        template <typename T = std::int32_t> T &reloadcount() {
            return *(T *)((std::uintptr_t)this + 0x7C);
        }
        template <typename T = il2cpp_string *> T &mparameters() {
            return *(T *)((std::uintptr_t)this + 0x80);
        }
        template <typename T = float> T &m_lastleavevehicletime() {
            return *(T *)((std::uintptr_t)this + 0x84);
        }
        template <typename T = float> T &dotofprone() {
            return *(T *)((std::uintptr_t)this + 0x88);
        }
        template <typename T = bool> T &m_isstartfireinsprint() {
            return *(T *)((std::uintptr_t)this + 0x8C);
        }
        template <typename T = std::uintptr_t> T &mpendingswitchweapon() {
            return *(T *)((std::uintptr_t)this + 0x90);
        }
        template <typename T = il2cpp_string *> T &m_pawnconfigpath() {
            return *(T *)((std::uintptr_t)this + 0x94);
        }
        template <typename T = bool> T &usingcontrollablemissile() {
            return *(T *)((std::uintptr_t)this + 0x98);
        }
        template <typename T = bool> T &usingsubweapongrapplegun() {
            return *(T *)((std::uintptr_t)this + 0x99);
        }
        template <typename T = bool> T &prepareusingsubweapongrapplegun() {
            return *(T *)((std::uintptr_t)this + 0x9A);
        }
        template <typename T = bool> T &usingairborne() {
            return *(T *)((std::uintptr_t)this + 0x9B);
        }
        template <typename T = bool> T &usinghackchip() {
            return *(T *)((std::uintptr_t)this + 0x9C);
        }
        template <typename T = bool> T &m_bisgrapdestpoint() {
            return *(T *)((std::uintptr_t)this + 0x9D);
        }
        template <typename T = il2cpp_vec3> T &m_vgrapplegundestpoint() {
            return *(T *)((std::uintptr_t)this + 0xA0);
        }
        template <typename T = bool> T &enabledrawlatestserverpos() {
            return *(T *)((std::uintptr_t)this + 0xAC);
        }
        template <typename T = std::uintptr_t> T &m_pawntransitiontype() {
            return *(T *)((std::uintptr_t)this + 0xB0);
        }
        template <typename T = float> T &m_pronebodyangle() {
            return *(T *)((std::uintptr_t)this + 0xB4);
        }
        template <typename T = float> T &m_fallinghorizontalobstrutcosvalue() {
            return *(T *)((std::uintptr_t)this + 0xB8);
        }
        template <typename T = bool> T &m_pindowntoground() {
            return *(T *)((std::uintptr_t)this + 0xBC);
        }
        template <typename T = std::int32_t> T &inregionid() {
            return *(T *)((std::uintptr_t)this + 0xC0);
        }
        template <typename T = float> T &m_maxmovespeed() {
            return *(T *)((std::uintptr_t)this + 0xC4);
        }
        template <typename T = std::uintptr_t> T &msoundemitterinternal() {
            return *(T *)((std::uintptr_t)this + 0xC8);
        }
        template <typename T = float> T &m_fixedweaponaccuracy() {
            return *(T *)((std::uintptr_t)this + 0xCC);
        }
        template <typename T = il2cpp_vec3> T &m_tpscameraoffset() {
            return *(T *)((std::uintptr_t)this + 0xD0);
        }
        template <typename T = il2cpp_vec3> T &tpsindividuationcameraoffset() {
            return *(T *)((std::uintptr_t)this + 0xDC);
        }
        template <typename T = std::uintptr_t> T &mfcameraoffsetlerptick() {
            return *(T *)((std::uintptr_t)this + 0xE8);
        }
        template <typename T = il2cpp_vec3> T &m_totpscameraoffset() {
            return *(T *)((std::uintptr_t)this + 0xEC);
        }
        template <typename T = float> T &m_totpscameraoffsettimer() {
            return *(T *)((std::uintptr_t)this + 0xF8);
        }
        template <typename T = float> T &m_totpscameraoffsettime() {
            return *(T *)((std::uintptr_t)this + 0xFC);
        }
        template <typename T = il2cpp_vec3> T &m_lasttpscameraoffset() {
            return *(T *)((std::uintptr_t)this + 0x100);
        }
        template <typename T = il2cpp_string *> T &m_localplayerspritename() {
            return *(T *)((std::uintptr_t)this + 0x10C);
        }
        template <typename T = il2cpp_string *>
        T &m_localplayergoliathspritename() {
            return *(T *)((std::uintptr_t)this + 0x110);
        }
        template <typename T = float> T &m_pronetransitionrate() {
            return *(T *)((std::uintptr_t)this + 0x114);
        }
        template <typename T = bool> T &m_istransitiontopronestate() {
            return *(T *)((std::uintptr_t)this + 0x118);
        }
        template <typename T = bool> T &m_istransitionfrompronestate() {
            return *(T *)((std::uintptr_t)this + 0x119);
        }
        template <typename T = bool> T &m_canseesmokein() {
            return *(T *)((std::uintptr_t)this + 0x11A);
        }
        template <typename T = bool> T &canseesmokein() {
            return *(T *)((std::uintptr_t)this + 0x11B);
        }
        template <typename T = bool> T &m_canseestreakfront() {
            return *(T *)((std::uintptr_t)this + 0x11C);
        }
        template <typename T = float> T &pronecheckheight() {
            return *(T *)((std::uintptr_t)this + 0x120);
        }
        template <typename T = std::int32_t> T &m_fireanimindex() {
            return *(T *)((std::uintptr_t)this + 0x124);
        }
        template <typename T = il2cpp_string *> T &m_debugstring() {
            return *(T *)((std::uintptr_t)this + 0x128);
        }
        template <typename T = bool> T &m_forcesyncmove() {
            return *(T *)((std::uintptr_t)this + 0x12C);
        }
        template <typename T = std::uintptr_t> T &m_inventorymanager() {
            return *(T *)((std::uintptr_t)this + 0x130);
        }
        template <typename T = std::uintptr_t> T &m_currentweaponattachment() {
            return *(T *)((std::uintptr_t)this + 0x134);
        }
        template <typename T = bool> T &m_binit() {
            return *(T *)((std::uintptr_t)this + 0x138);
        }
        template <typename T = bool> T &showweapon() {
            return *(T *)((std::uintptr_t)this + 0x139);
        }
        template <typename T = bool> T &m_inwater() {
            return *(T *)((std::uintptr_t)this + 0x13A);
        }
        template <typename T = il2cpp_vec3> T &m_initialupperbodyrelativepos() {
            return *(T *)((std::uintptr_t)this + 0x13C);
        }
        template <typename T = std::uintptr_t> T &m_cachedupperbodytransform() {
            return *(T *)((std::uintptr_t)this + 0x148);
        }
        template <typename T = std::uintptr_t>
        T &m_firstpersoncamerasockettransform() {
            return *(T *)((std::uintptr_t)this + 0x14C);
        }
        template <typename T = std::uintptr_t>
        T &m_thirdheadcamerasockettransform() {
            return *(T *)((std::uintptr_t)this + 0x150);
        }
        template <typename T = std::uintptr_t>
        T &m_worldcamerasockettransform() {
            return *(T *)((std::uintptr_t)this + 0x154);
        }
        template <typename T = std::uintptr_t>
        T &m_worldcamerasockettransform_tps() {
            return *(T *)((std::uintptr_t)this + 0x158);
        }
        template <typename T = float> T &m_standanimationtransitiontime() {
            return *(T *)((std::uintptr_t)this + 0x15C);
        }
        template <typename T = float> T &m_standanimationtransitionticktime() {
            return *(T *)((std::uintptr_t)this + 0x160);
        }
        template <typename T = bool> T &m_isinstandanimationtransition() {
            return *(T *)((std::uintptr_t)this + 0x164);
        }
        template <typename T = bool> T &m_isindeceleratestandanimtransition() {
            return *(T *)((std::uintptr_t)this + 0x165);
        }
        template <typename T = std::uintptr_t> T &m_headbone() {
            return *(T *)((std::uintptr_t)this + 0x168);
        }
        template <typename T = float> T &m_accelerationinputstrafe() {
            return *(T *)((std::uintptr_t)this + 0x16C);
        }
        template <typename T = il2cpp_vec3> T &m_accelerationreal() {
            return *(T *)((std::uintptr_t)this + 0x170);
        }
        template <typename T = il2cpp_vec3> T &m_acceleration() {
            return *(T *)((std::uintptr_t)this + 0x17C);
        }
        template <typename T = il2cpp_vec3> T &m_velocity() {
            return *(T *)((std::uintptr_t)this + 0x188);
        }
        template <typename T = std::uintptr_t> T &m_remotecontrolledvehicle() {
            return *(T *)((std::uintptr_t)this + 0x194);
        }
        template <typename T = std::uintptr_t> T &m_currentvehicle() {
            return *(T *)((std::uintptr_t)this + 0x198);
        }
        template <typename T = float> T &lastgetoffvehicletime() {
            return *(T *)((std::uintptr_t)this + 0x19C);
        }
        template <typename T = std::uint32_t> T &lastvehicleactorid() {
            return *(T *)((std::uintptr_t)this + 0x1A0);
        }
        template <typename T = il2cpp_list<std::uintptr_t> *>
        T &m_availablevehicles() {
            return *(T *)((std::uintptr_t)this + 0x1A4);
        }
        template <typename T = float> T &m_encpenetrationvalue() {
            return *(T *)((std::uintptr_t)this + 0x1A8);
        }
        template <typename T = il2cpp_vec3> T &m_fireblockworldpos() {
            return *(T *)((std::uintptr_t)this + 0x1AC);
        }
        template <typename T = il2cpp_quaternion> T &m_aimrotation() {
            return *(T *)((std::uintptr_t)this + 0x1B8);
        }
        template <typename T = il2cpp_quaternion>
        T &m_delayshootaimrotationlocal() {
            return *(T *)((std::uintptr_t)this + 0x1C8);
        }
        template <typename T = il2cpp_quaternion> T &m_delayshootaimrotation() {
            return *(T *)((std::uintptr_t)this + 0x1D8);
        }
        template <typename T = il2cpp_quaternion> T &m_aimrotationlocal() {
            return *(T *)((std::uintptr_t)this + 0x1E8);
        }
        template <typename T = std::uintptr_t> T &m_takedamagecomponent() {
            return *(T *)((std::uintptr_t)this + 0x1F8);
        }
        template <typename T = std::uintptr_t> T &m_crouchcomponent() {
            return *(T *)((std::uintptr_t)this + 0x1FC);
        }
        template <typename T = std::uintptr_t> T &m_pronecomponent() {
            return *(T *)((std::uintptr_t)this + 0x200);
        }
        template <typename T = std::uintptr_t> T &m_iksolvercomponent() {
            return *(T *)((std::uintptr_t)this + 0x204);
        }
        template <typename T = std::uintptr_t> T &m_avatarrotationcomponent() {
            return *(T *)((std::uintptr_t)this + 0x208);
        }
        template <typename T = std::uintptr_t> T &m_pawnladdercomponent() {
            return *(T *)((std::uintptr_t)this + 0x20C);
        }
        template <typename T = std::uintptr_t> T &m_slidetacklecomponent() {
            return *(T *)((std::uintptr_t)this + 0x210);
        }
        template <typename T = std::uintptr_t> T &m_rollcomponent() {
            return *(T *)((std::uintptr_t)this + 0x214);
        }
        template <typename T = std::uintptr_t> T &m_individuationcomponent() {
            return *(T *)((std::uintptr_t)this + 0x218);
        }
        template <typename T = std::uintptr_t>
        T &m_pawnsockettransformadjustcomponent() {
            return *(T *)((std::uintptr_t)this + 0x21C);
        }
        template <typename T = std::uintptr_t> T &m_dynamicskincomponent() {
            return *(T *)((std::uintptr_t)this + 0x220);
        }
        template <typename T = std::uintptr_t> T &m_spectatorcomponent() {
            return *(T *)((std::uintptr_t)this + 0x224);
        }
        template <typename T = std::uintptr_t> T &m_actioncomponent() {
            return *(T *)((std::uintptr_t)this + 0x228);
        }
        template <typename T = std::uintptr_t> T &m_switchrolecomponent() {
            return *(T *)((std::uintptr_t)this + 0x22C);
        }
        template <typename T = std::uintptr_t> T &m_paintcomponent() {
            return *(T *)((std::uintptr_t)this + 0x230);
        }
        template <typename T = std::uintptr_t> T &m_ragdollcomponent() {
            return *(T *)((std::uintptr_t)this + 0x234);
        }
        template <typename T = std::uintptr_t> T &m_gravityspikescomponent() {
            return *(T *)((std::uintptr_t)this + 0x238);
        }
        template <typename T = std::uintptr_t> T &m_shadowbladecomponent() {
            return *(T *)((std::uintptr_t)this + 0x23C);
        }
        template <typename T = std::uintptr_t> T &m_jumpcomponent() {
            return *(T *)((std::uintptr_t)this + 0x240);
        }
        template <typename T = std::uintptr_t> T &m_deadcomponent() {
            return *(T *)((std::uintptr_t)this + 0x244);
        }
        template <typename T = std::uintptr_t> T &m_trickycomponent() {
            return *(T *)((std::uintptr_t)this + 0x248);
        }
        template <typename T = std::uintptr_t> T &m_pawnsoundcomponent() {
            return *(T *)((std::uintptr_t)this + 0x24C);
        }
        template <typename T = std::uintptr_t> T &m_pawneffectmanager() {
            return *(T *)((std::uintptr_t)this + 0x250);
        }
        template <typename T = std::uintptr_t> T &m_logicanimationcomponent() {
            return *(T *)((std::uintptr_t)this + 0x254);
        }
        template <typename T = std::uintptr_t> T &m_rootmotionmovecomponent() {
            return *(T *)((std::uintptr_t)this + 0x258);
        }
        template <typename T = std::uintptr_t> T &m_graprushcomponent() {
            return *(T *)((std::uintptr_t)this + 0x25C);
        }
        template <typename T = std::uintptr_t> T &m_upwardlaunchcomponent() {
            return *(T *)((std::uintptr_t)this + 0x260);
        }
        template <typename T = std::uintptr_t> T &m_invisibleskillcomponent() {
            return *(T *)((std::uintptr_t)this + 0x264);
        }
        template <typename T = il2cpp_quaternion> T &m_simulatedaimrotation() {
            return *(T *)((std::uintptr_t)this + 0x268);
        }
        template <typename T = il2cpp_vec3> T &m_lastsimulatevelocity() {
            return *(T *)((std::uintptr_t)this + 0x278);
        }
        template <typename T = float> T &m_ladderforceyangle() {
            return *(T *)((std::uintptr_t)this + 0x284);
        }
        template <typename T = std::uintptr_t> T &m_pawnreliablesounddata() {
            return *(T *)((std::uintptr_t)this + 0x288);
        }
        template <typename T = bool> T &m_inelectric() {
            return *(T *)((std::uintptr_t)this + 0x28C);
        }
        template <typename T = bool> T &m_isinsmoke() {
            return *(T *)((std::uintptr_t)this + 0x28D);
        }
        template <typename T = void *> T &simulatedendgraprushevent() {
            return *(T *)((std::uintptr_t)this + 0x290);
        }
        template <typename T = float> T &m_camheightoffset_3p() {
            return *(T *)((std::uintptr_t)this + 0x294);
        }
        template <typename T = il2cpp_vec3> T &m_lastdamagesourcepos() {
            return *(T *)((std::uintptr_t)this + 0x298);
        }
        template <typename T = float> T &m_lastchecksprinttime() {
            return *(T *)((std::uintptr_t)this + 0x2A4);
        }
        template <typename T = float> T &m_lastsendmovetime() {
            return *(T *)((std::uintptr_t)this + 0x2A8);
        }
        template <typename T = float> T &m_simulatespeed() {
            return *(T *)((std::uintptr_t)this + 0x2AC);
        }
        template <typename T = bool> T &m_lastinputsprint() {
            return *(T *)((std::uintptr_t)this + 0x2B0);
        }
        template <typename T = float> T &m_fwastetime() {
            return *(T *)((std::uintptr_t)this + 0x2B4);
        }
        template <typename T = float> T &m_maxclientforcemovedistance() {
            return *(T *)((std::uintptr_t)this + 0x2B8);
        }
        template <typename T = il2cpp_array<std::uintptr_t> *>
        T &m_ppawnsoundeventhandler() {
            return *(T *)((std::uintptr_t)this + 0x2BC);
        }
        template <typename T = bool> T &m_canswitchweapon() {
            return *(T *)((std::uintptr_t)this + 0x2C0);
        }
        template <typename T = il2cpp_vec2> T &m_horizontalroationlimit() {
            return *(T *)((std::uintptr_t)this + 0x2C4);
        }
        template <typename T = il2cpp_vec2> T &m_cacheverticalroationlimit() {
            return *(T *)((std::uintptr_t)this + 0x2CC);
        }
        template <typename T = il2cpp_vec2> T &m_maxhorizontalturndeltaprone() {
            return *(T *)((std::uintptr_t)this + 0x2D4);
        }
        template <typename T = il2cpp_vec2> T &m_verticalroationlimitprone() {
            return *(T *)((std::uintptr_t)this + 0x2DC);
        }
        template <typename T = bool> T &m_easyskyfly() {
            return *(T *)((std::uintptr_t)this + 0x2E4);
        }
        template <typename T = bool> T &m_isskyfly() {
            return *(T *)((std::uintptr_t)this + 0x2E5);
        }
        template <typename T = il2cpp_vec3> T &m_headoffset() {
            return *(T *)((std::uintptr_t)this + 0x2E8);
        }
        template <typename T = float> T &m_hudheadoffset() {
            return *(T *)((std::uintptr_t)this + 0x2F4);
        }
        template <typename T = float> T &m_goliathhudheadoffset() {
            return *(T *)((std::uintptr_t)this + 0x2F8);
        }
        template <typename T = bool> T &m_iscrouching() {
            return *(T *)((std::uintptr_t)this + 0x2FC);
        }
        template <typename T = bool> T &m_isproneing() {
            return *(T *)((std::uintptr_t)this + 0x2FD);
        }
        template <typename T = bool> T &proneconfirming() {
            return *(T *)((std::uintptr_t)this + 0x2FE);
        }
        template <typename T = bool> T &m_isrotation() {
            return *(T *)((std::uintptr_t)this + 0x2FF);
        }
        template <typename T = bool> T &m_isinaircraft() {
            return *(T *)((std::uintptr_t)this + 0x300);
        }
        template <typename T = bool> T &m_bisinnonbattlearea() {
            return *(T *)((std::uintptr_t)this + 0x301);
        }
        template <typename T = float> T &m_currenteyeheight() {
            return *(T *)((std::uintptr_t)this + 0x304);
        }
        template <typename T = bool> T &hasreleaseskillbutton() {
            return *(T *)((std::uintptr_t)this + 0x308);
        }
        template <typename T = bool> T &m_blockyrotation() {
            return *(T *)((std::uintptr_t)this + 0x309);
        }
        template <typename T = float> T &m_hitscoretime() {
            return *(T *)((std::uintptr_t)this + 0x30C);
        }
        template <typename T = float> T &m_lastplaybloodeffecttime() {
            return *(T *)((std::uintptr_t)this + 0x310);
        }
        template <typename T = il2cpp_vec3> T &m_jumpbob() {
            return *(T *)((std::uintptr_t)this + 0x314);
        }
        template <typename T = float> T &m_jumbbobdropheight() {
            return *(T *)((std::uintptr_t)this + 0x320);
        }
        template <typename T = float> T &m_jumbbobupheight() {
            return *(T *)((std::uintptr_t)this + 0x324);
        }
        template <typename T = float> T &m_jumbbobincreacement() {
            return *(T *)((std::uintptr_t)this + 0x328);
        }
        template <typename T = float> T &m_jumbbobdecreasement() {
            return *(T *)((std::uintptr_t)this + 0x32C);
        }
        template <typename T = bool> T &m_shouldupdatejumpbob() {
            return *(T *)((std::uintptr_t)this + 0x330);
        }
        template <typename T = bool> T &m_isjumbbobincreasing() {
            return *(T *)((std::uintptr_t)this + 0x331);
        }
        template <typename T = float> T &m_landafterjumpingtime() {
            return *(T *)((std::uintptr_t)this + 0x334);
        }
        template <typename T = float> T &m_cachefallingforwardspeed() {
            return *(T *)((std::uintptr_t)this + 0x338);
        }
        template <typename T = float> T &m_cachefallinglateralspeed() {
            return *(T *)((std::uintptr_t)this + 0x33C);
        }
        template <typename T = bool> T &m_bendsubweaponaciton() {
            return *(T *)((std::uintptr_t)this + 0x340);
        }
        template <typename T = std::uintptr_t> T &m_initloginphysicsstate() {
            return *(T *)((std::uintptr_t)this + 0x344);
        }
        template <typename T = std::uintptr_t> T &m_physicsstate() {
            return *(T *)((std::uintptr_t)this + 0x348);
        }
        template <typename T = std::uintptr_t> T &m_followtarget() {
            return *(T *)((std::uintptr_t)this + 0x34C);
        }
        template <typename T = il2cpp_list<std::uintptr_t> *>
        T &m_touchingvolumes() {
            return *(T *)((std::uintptr_t)this + 0x350);
        }
        template <typename T = std::uintptr_t> T &m_physicsvolumeinternal() {
            return *(T *)((std::uintptr_t)this + 0x354);
        }
        template <typename T = std::uintptr_t> T &currentladder() {
            return *(T *)((std::uintptr_t)this + 0x358);
        }
        template <typename T = std::uintptr_t> T &m_animationcomponent() {
            return *(T *)((std::uintptr_t)this + 0x35C);
        }
        template <typename T = std::uintptr_t> T &m_adaptiverootmotion() {
            return *(T *)((std::uintptr_t)this + 0x360);
        }
        template <typename T = bool> T &m_isalive() {
            return *(T *)((std::uintptr_t)this + 0x364);
        }
        template <typename T = bool> T &m_isplaydying() {
            return *(T *)((std::uintptr_t)this + 0x365);
        }
        template <typename T = bool> T &m_indeadeye() {
            return *(T *)((std::uintptr_t)this + 0x366);
        }
        template <typename T = float> T &m_lastbebulletdamged() {
            return *(T *)((std::uintptr_t)this + 0x368);
        }
        template <typename T = float> T &m_lastbeexplodedamged() {
            return *(T *)((std::uintptr_t)this + 0x36C);
        }
        template <typename T = bool> T &m_triggerquickknife() {
            return *(T *)((std::uintptr_t)this + 0x370);
        }
        template <typename T = float> T &m_lastfiretime() {
            return *(T *)((std::uintptr_t)this + 0x374);
        }
        template <typename T = std::uintptr_t> T &m_lastfireweaponname() {
            return *(T *)((std::uintptr_t)this + 0x378);
        }
        template <typename T = float> T &m_lastrespawntime() {
            return *(T *)((std::uintptr_t)this + 0x37C);
        }
        template <typename T = float> T &m_lastuavposupdatetime() {
            return *(T *)((std::uintptr_t)this + 0x380);
        }
        template <typename T = il2cpp_vec3> T &m_uavpos() {
            return *(T *)((std::uintptr_t)this + 0x384);
        }
        template <typename T = il2cpp_vec3> T &m_lastfireloc() {
            return *(T *)((std::uintptr_t)this + 0x390);
        }
        template <typename T = float> T &m_lastupdateloctime() {
            return *(T *)((std::uintptr_t)this + 0x39C);
        }
        template <typename T = float> T &m_locupdateinterval() {
            return *(T *)((std::uintptr_t)this + 0x3A0);
        }
        template <typename T = il2cpp_vec3> T &m_location() {
            return *(T *)((std::uintptr_t)this + 0x3A4);
        }
        template <typename T = bool> T &isshowingfireloc() {
            return *(T *)((std::uintptr_t)this + 0x3B0);
        }
        template <typename T = std::uintptr_t> T &m_playerinfo() {
            return *(T *)((std::uintptr_t)this + 0x3B4);
        }
        template <typename T = il2cpp_vec3> T &m_lastpawnpos() {
            return *(T *)((std::uintptr_t)this + 0x3B8);
        }
        template <typename T = float> T &movethreshold() {
            return *(T *)((std::uintptr_t)this + 0x3C4);
        }
        template <typename T = il2cpp_vec3> T &m_lastpawneulerangle() {
            return *(T *)((std::uintptr_t)this + 0x3C8);
        }
        template <typename T = bool> T &isswitchviewend() {
            return *(T *)((std::uintptr_t)this + 0x3D4);
        }
        template <typename T = bool> T &isswitchroleend() {
            return *(T *)((std::uintptr_t)this + 0x3D5);
        }
        template <typename T = std::uintptr_t> T &m_headtransform() {
            return *(T *)((std::uintptr_t)this + 0x3D8);
        }
        template <typename T = bool> T &m_fetchedheadtransform() {
            return *(T *)((std::uintptr_t)this + 0x3DC);
        }
        template <typename T = std::uintptr_t> T &m_controller() {
            return *(T *)((std::uintptr_t)this + 0x3E0);
        }
        template <typename T = il2cpp_dict<std::uintptr_t, bool> *>
        T &typetestdic() {
            return *(T *)((std::uintptr_t)this + 0x3E4);
        }
        template <typename T = std::uintptr_t> T &m_viewtype() {
            return *(T *)((std::uintptr_t)this + 0x3E8);
        }
        template <typename T = std::uintptr_t> T &m_role() {
            return *(T *)((std::uintptr_t)this + 0x3EC);
        }
        template <typename T = std::uintptr_t> T &m_mesh() {
            return *(T *)((std::uintptr_t)this + 0x3F0);
        }
        template <typename T = std::uintptr_t> T &m_modelroot() {
            return *(T *)((std::uintptr_t)this + 0x3F4);
        }
        template <typename T = il2cpp_quaternion> T &meshforwordrot() {
            return *(T *)((std::uintptr_t)this + 0x3F8);
        }
        template <typename T = bool> T &m_firsttimerespawn() {
            return *(T *)((std::uintptr_t)this + 0x408);
        }
        template <typename T = std::uintptr_t> T &notifystopdriving() {
            return *(T *)((std::uintptr_t)this + 0x40C);
        }
        template <typename T = std::uintptr_t> T &m_releventcomp() {
            return *(T *)((std::uintptr_t)this + 0x410);
        }
        template <typename T = il2cpp_vec3> T &m_actualwalkingvelocity() {
            return *(T *)((std::uintptr_t)this + 0x414);
        }
        template <typename T = std::uintptr_t> T &m_weaponshakecontroller() {
            return *(T *)((std::uintptr_t)this + 0x420);
        }
        template <typename T = il2cpp_vec3> T &m_deltaeulerangles() {
            return *(T *)((std::uintptr_t)this + 0x424);
        }
        template <typename T = void *> T &takedamagehandler() {
            return *(T *)((std::uintptr_t)this + 0x430);
        }
        template <typename T = bool> T &checkpassthroughwall() {
            return *(T *)((std::uintptr_t)this + 0x434);
        }
        template <typename T = il2cpp_list<std::uintptr_t> *>
        T &m_logicalcomponents() {
            return *(T *)((std::uintptr_t)this + 0x438);
        }
        template <typename T = il2cpp_vec3>
        T &m_firstpersonweaponsocketlocalposition_originalvalue() {
            return *(T *)((std::uintptr_t)this + 0x43C);
        }
        template <typename T = il2cpp_vec3>
        T &m_firstpersonweaponsocketlocaleulerangles_originalvalue() {
            return *(T *)((std::uintptr_t)this + 0x448);
        }
        template <typename T = il2cpp_vec3>
        T &m_firstpersonarmsocketlocalposition_originalvalue() {
            return *(T *)((std::uintptr_t)this + 0x454);
        }
        template <typename T = il2cpp_vec3>
        T &m_firstpersonarmsocketlocaleulerangles_originalvalue() {
            return *(T *)((std::uintptr_t)this + 0x460);
        }
        template <typename T = bool> T &m_needtoresetpose() {
            return *(T *)((std::uintptr_t)this + 0x46C);
        }
        template <typename T = bool> T &m_iscrouchingwhenswitchrole() {
            return *(T *)((std::uintptr_t)this + 0x46D);
        }
        template <typename T = bool> T &m_isproningwhenswitchrole() {
            return *(T *)((std::uintptr_t)this + 0x46E);
        }
        template <typename T = std::uintptr_t>
        T &cachevehicleswitchtpsmodereasontype() {
            return *(T *)((std::uintptr_t)this + 0x470);
        }
        template <typename T = float> T &m_firstpersoncameraoffsetticktimer() {
            return *(T *)((std::uintptr_t)this + 0x474);
        }
        template <typename T = float> T &m_firstpersoncameracurrentoffsetx() {
            return *(T *)((std::uintptr_t)this + 0x478);
        }
        template <typename T = float> T &m_firstpersoncameradestoffsetx() {
            return *(T *)((std::uintptr_t)this + 0x47C);
        }
        template <typename T = float> T &m_firstpersoncameramovespeed() {
            return *(T *)((std::uintptr_t)this + 0x480);
        }
        template <typename T = std::uintptr_t> T &m_cachedmaincamera() {
            return *(T *)((std::uintptr_t)this + 0x484);
        }
        template <typename T = float> T &m_currentpassengeraniangle() {
            return *(T *)((std::uintptr_t)this + 0x488);
        }
        template <typename T = float> T &targetaniangle() {
            return *(T *)((std::uintptr_t)this + 0x48C);
        }
        template <typename T = float> T &inputaccelerationforwrad() {
            return *(T *)((std::uintptr_t)this + 0x490);
        }
        template <typename T = float> T &inputaccelerationlaterial() {
            return *(T *)((std::uintptr_t)this + 0x494);
        }
        template <typename T = bool> T &disablesprint() {
            return *(T *)((std::uintptr_t)this + 0x498);
        }
        template <typename T = bool> T &isgravityspikesjumpup() {
            return *(T *)((std::uintptr_t)this + 0x499);
        }
        template <typename T = bool> T &m_isshadowblade() {
            return *(T *)((std::uintptr_t)this + 0x49A);
        }
        template <typename T = bool> T &m_canshadowbladefire() {
            return *(T *)((std::uintptr_t)this + 0x49B);
        }
        template <typename T = il2cpp_vec3>
        T &m_firstpersoncameralocalposition_originalvalue() {
            return *(T *)((std::uintptr_t)this + 0x49C);
        }
        template <typename T = bool> T &istpsclimb() {
            return *(T *)((std::uintptr_t)this + 0x4A8);
        }
        template <typename T = std::uintptr_t> T &m_firstpersonweaponsocket() {
            return *(T *)((std::uintptr_t)this + 0x4AC);
        }
        template <typename T = std::uintptr_t> T &m_firstpersonarmsocket() {
            return *(T *)((std::uintptr_t)this + 0x4B0);
        }
        template <typename T = std::uintptr_t> T &m_thirdpersonmodelsocket() {
            return *(T *)((std::uintptr_t)this + 0x4B4);
        }
        template <typename T = bool> T &m_showorhidearmfx() {
            return *(T *)((std::uintptr_t)this + 0x4B8);
        }
        template <typename T = std::uintptr_t> T &m_ruparmobj() {
            return *(T *)((std::uintptr_t)this + 0x4BC);
        }
        template <typename T = std::uintptr_t> T &m_luparmobj() {
            return *(T *)((std::uintptr_t)this + 0x4C0);
        }
        template <typename T = std::uint32_t> T &beforeinstigatorplayerid() {
            return *(T *)((std::uintptr_t)this + 0x4C4);
        }
        template <typename T = il2cpp_dict<il2cpp_string *, std::uintptr_t> *>
        T &m_socketdic() {
            return *(T *)((std::uintptr_t)this + 0x4C8);
        }
        template <typename T = std::uintptr_t>
        T &m_currenttriggercarepackage() {
            return *(T *)((std::uintptr_t)this + 0x4CC);
        }
        template <typename T = std::uintptr_t>
        T &m_cachedaimassistancecollider() {
            return *(T *)((std::uintptr_t)this + 0x4D0);
        }
        template <typename T = float> T &m_leftconcussiontime() {
            return *(T *)((std::uintptr_t)this + 0x4D4);
        }
        template <typename T = bool> T &m_needtoshowwhitescreeneffect() {
            return *(T *)((std::uintptr_t)this + 0x4D8);
        }
        template <typename T = float> T &m_leftflasheffecttime() {
            return *(T *)((std::uintptr_t)this + 0x4DC);
        }
        template <typename T = float> T &m_leftempeffecttime() {
            return *(T *)((std::uintptr_t)this + 0x4E0);
        }
        template <typename T = bool> T &m_isinterferedbydrone() {
            return *(T *)((std::uintptr_t)this + 0x4E4);
        }
        template <typename T = bool> T &m_isstartbehacked() {
            return *(T *)((std::uintptr_t)this + 0x4E5);
        }
        template <typename T = bool> T &m_isfinishbehacked() {
            return *(T *)((std::uintptr_t)this + 0x4E6);
        }
        template <typename T = bool> T &m_hasocclusioneffect() {
            return *(T *)((std::uintptr_t)this + 0x4E7);
        }
        template <typename T = bool> T &m_needshowonmap() {
            return *(T *)((std::uintptr_t)this + 0x4E8);
        }
        template <typename T = std::uintptr_t> T &mfeyeheighttlerptick() {
            return *(T *)((std::uintptr_t)this + 0x4EC);
        }
        template <typename T = float> T &m_toeyeheightoffset() {
            return *(T *)((std::uintptr_t)this + 0x4F0);
        }
        template <typename T = float> T &m_toeyeheighttimer() {
            return *(T *)((std::uintptr_t)this + 0x4F4);
        }
        template <typename T = float> T &m_toeyeheightttime() {
            return *(T *)((std::uintptr_t)this + 0x4F8);
        }
        template <typename T = float> T &m_lasteyeheightoffset() {
            return *(T *)((std::uintptr_t)this + 0x4FC);
        }
        template <typename T = bool> T &m_ishighthrowfire() {
            return *(T *)((std::uintptr_t)this + 0x500);
        }
        template <typename T = bool> T &m_busingbrult() {
            return *(T *)((std::uintptr_t)this + 0x501);
        }
        template <typename T = il2cpp_vec3> T &m_turnaroundtargetposition() {
            return *(T *)((std::uintptr_t)this + 0x504);
        }
        template <typename T = float> T &m_turnaroundradius() {
            return *(T *)((std::uintptr_t)this + 0x510);
        }
        template <typename T = float> T &m_lastrotatearoundaxiseulery() {
            return *(T *)((std::uintptr_t)this + 0x514);
        }
        template <typename T = bool> T &m_inslidetackle() {
            return *(T *)((std::uintptr_t)this + 0x518);
        }
        template <typename T = bool> T &m_useslidetacklespeed() {
            return *(T *)((std::uintptr_t)this + 0x519);
        }
        template <typename T = bool> T &m_inroll() {
            return *(T *)((std::uintptr_t)this + 0x51A);
        }
        template <typename T = bool> T &m_userollspeed() {
            return *(T *)((std::uintptr_t)this + 0x51B);
        }
        template <typename T = std::uintptr_t> T &m_subweaponattachment() {
            return *(T *)((std::uintptr_t)this + 0x51C);
        }
        template <typename T = bool> T &_istakinglightingdamage() {
            return *(T *)((std::uintptr_t)this + 0x520);
        }
        template <typename T = float> T &fightofftime() {
            return *(T *)((std::uintptr_t)this + 0x524);
        }
        template <typename T = float> T &fightoffcdtime() {
            return *(T *)((std::uintptr_t)this + 0x528);
        }
        template <typename T = std::uintptr_t>
        T &m_vehiclethrowweaponpositionsocket() {
            return *(T *)((std::uintptr_t)this + 0x52C);
        }
        template <typename T = il2cpp_quaternion>
        T &m_lastprojectilestartpositionoffsetrot() {
            return *(T *)((std::uintptr_t)this + 0x530);
        }
        template <typename T = il2cpp_list<std::uintptr_t> *>
        T &m_ignoreweaponwhenequiplist() {
            return *(T *)((std::uintptr_t)this + 0x540);
        }
        template <typename T = bool> T &m_isusingweaponskill() {
            return *(T *)((std::uintptr_t)this + 0x544);
        }
        template <typename T = float> T &m_rotatetime() {
            return *(T *)((std::uintptr_t)this + 0x548);
        }
        template <typename T = float> T &m_rotatecheckpoint() {
            return *(T *)((std::uintptr_t)this + 0x54C);
        }
        template <typename T = bool> T &m_ischangingfiremode() {
            return *(T *)((std::uintptr_t)this + 0x550);
        }
        template <typename T = std::uintptr_t>
        T &m_medicalstationcuringeffect() {
            return *(T *)((std::uintptr_t)this + 0x554);
        }
        template <typename T = bool> T &m_iscuringbymedicalstation() {
            return *(T *)((std::uintptr_t)this + 0x558);
        }
        template <typename T = std::uintptr_t> T &m_ulteffect1p() {
            return *(T *)((std::uintptr_t)this + 0x55C);
        }
        template <typename T = std::uintptr_t> T &m_ulteffect3p() {
            return *(T *)((std::uintptr_t)this + 0x560);
        }
        template <typename T = std::int32_t> T &m_ultscreeneffectid() {
            return *(T *)((std::uintptr_t)this + 0x564);
        }
        template <typename T = bool> T &m_isplayingulteffect() {
            return *(T *)((std::uintptr_t)this + 0x568);
        }
        template <typename T = bool> T &havevest() {
            return *(T *)((std::uintptr_t)this + 0x569);
        }
        template <typename T = bool> T &_hasmultythrowweapon() {
            return *(T *)((std::uintptr_t)this + 0x56A);
        }
        template <typename T = il2cpp_vec3> T &m_initpositionforradar() {
            return *(T *)((std::uintptr_t)this + 0x56C);
        }
        template <typename T = il2cpp_quaternion> T &m_initrotationforradar() {
            return *(T *)((std::uintptr_t)this + 0x578);
        }
        template <typename T = std::uintptr_t> T &standcolliderdata() {
            return *(T *)((std::uintptr_t)this + 0x588);
        }
        template <typename T = std::uintptr_t> T &pronecolliderdata() {
            return *(T *)((std::uintptr_t)this + 0x58C);
        }
        template <typename T = std::uintptr_t> T &crouchcolliderdata() {
            return *(T *)((std::uintptr_t)this + 0x590);
        }
        template <typename T = std::uintptr_t> T &swimcolliderdata() {
            return *(T *)((std::uintptr_t)this + 0x594);
        }
        template <typename T = std::uintptr_t> T &climbcolliderdata() {
            return *(T *)((std::uintptr_t)this + 0x598);
        }
        template <typename T = std::uintptr_t> T &slidetacklecolliderdata() {
            return *(T *)((std::uintptr_t)this + 0x59C);
        }
        template <typename T = std::uintptr_t> T &rollcolliderdata() {
            return *(T *)((std::uintptr_t)this + 0x5A0);
        }
        template <typename T = std::uintptr_t> T &goliathcolliderdata() {
            return *(T *)((std::uintptr_t)this + 0x5A4);
        }
        template <typename T = std::uintptr_t> T &m_modelcollider() {
            return *(T *)((std::uintptr_t)this + 0x5A8);
        }
        template <typename T = bool> T &m_hascharactercontroller() {
            return *(T *)((std::uintptr_t)this + 0x5AC);
        }
        template <typename T = std::uintptr_t> T &m_charactercontroller() {
            return *(T *)((std::uintptr_t)this + 0x5B0);
        }
        template <typename T = bool> T &m_hasbodycharactercontroller() {
            return *(T *)((std::uintptr_t)this + 0x5B4);
        }
        template <typename T = std::uintptr_t> T &m_bodycharactercontroller() {
            return *(T *)((std::uintptr_t)this + 0x5B8);
        }
        template <typename T = std::uintptr_t>
        T &m_bodycharactercontrollerobj() {
            return *(T *)((std::uintptr_t)this + 0x5BC);
        }
        template <typename T = bool> T &m_haslegcharactercontroller() {
            return *(T *)((std::uintptr_t)this + 0x5C0);
        }
        template <typename T = std::uintptr_t> T &m_legcharactercontroller() {
            return *(T *)((std::uintptr_t)this + 0x5C4);
        }
        template <typename T = std::uintptr_t>
        T &m_legcharactercontrollerobj() {
            return *(T *)((std::uintptr_t)this + 0x5C8);
        }
        template <typename T = float> T &m_standcharcontrollerheight() {
            return *(T *)((std::uintptr_t)this + 0x5CC);
        }
        template <typename T = float> T &m_crouchcharcontrollerhight() {
            return *(T *)((std::uintptr_t)this + 0x5D0);
        }
        template <typename T = float> T &m_slidecharcontrollerhight() {
            return *(T *)((std::uintptr_t)this + 0x5D4);
        }
        template <typename T = float> T &m_pronecharcontrollerhight() {
            return *(T *)((std::uintptr_t)this + 0x5D8);
        }
        template <typename T = float> T &m_swimcharcontrollerhight() {
            return *(T *)((std::uintptr_t)this + 0x5DC);
        }
        template <typename T = float> T &m_graprushcharcontrollerhight() {
            return *(T *)((std::uintptr_t)this + 0x5E0);
        }
        template <typename T = float> T &m_goliathstandcharcontrollerheight() {
            return *(T *)((std::uintptr_t)this + 0x5E4);
        }
        template <typename T = float> T &m_peripheralvision() {
            return *(T *)((std::uintptr_t)this + 0x5E8);
        }
        template <typename T = float> T &m_sightradius() {
            return *(T *)((std::uintptr_t)this + 0x5EC);
        }
        template <typename T = float> T &m_gravity() {
            return *(T *)((std::uintptr_t)this + 0x5F0);
        }
        template <typename T = float> T &m_airsteering() {
            return *(T *)((std::uintptr_t)this + 0x5F4);
        }
        template <typename T = float> T &m_initialverticalspeed() {
            return *(T *)((std::uintptr_t)this + 0x5F8);
        }
        template <typename T = float> T &m_initialmaxjumpheight() {
            return *(T *)((std::uintptr_t)this + 0x5FC);
        }
        template <typename T = float> T &m_jumplimittime() {
            return *(T *)((std::uintptr_t)this + 0x600);
        }
        template <typename T = float> T &m_jumplimitminjumpheight() {
            return *(T *)((std::uintptr_t)this + 0x604);
        }
        template <typename T = float> T &m_jumplimitdecreaserate() {
            return *(T *)((std::uintptr_t)this + 0x608);
        }
        template <typename T = float> T &m_jumpmagicnumber() {
            return *(T *)((std::uintptr_t)this + 0x60C);
        }
        template <typename T = bool> T &m_usejumplimit() {
            return *(T *)((std::uintptr_t)this + 0x610);
        }
        template <typename T = float> T &m_maxacceleration() {
            return *(T *)((std::uintptr_t)this + 0x614);
        }
        template <typename T = float> T &m_walkanimbasespeed() {
            return *(T *)((std::uintptr_t)this + 0x618);
        }
        template <typename T = float> T &m_maxspeed() {
            return *(T *)((std::uintptr_t)this + 0x61C);
        }
        template <typename T = float> T &m_backwardmaxspeed() {
            return *(T *)((std::uintptr_t)this + 0x620);
        }
        template <typename T = float> T &m_horizontalmaxspeed() {
            return *(T *)((std::uintptr_t)this + 0x624);
        }
        template <typename T = float> T &m_horizontalmaxcosvalue() {
            return *(T *)((std::uintptr_t)this + 0x628);
        }
        template <typename T = float> T &m_ladderspeed() {
            return *(T *)((std::uintptr_t)this + 0x62C);
        }
        template <typename T = float> T &m_friction() {
            return *(T *)((std::uintptr_t)this + 0x630);
        }
        template <typename T = float> T &m_walkingspeedaddpercent() {
            return *(T *)((std::uintptr_t)this + 0x634);
        }
        template <typename T = float> T &m_verticalroationlimitmin() {
            return *(T *)((std::uintptr_t)this + 0x638);
        }
        template <typename T = float> T &m_verticalroationlimitmax() {
            return *(T *)((std::uintptr_t)this + 0x63C);
        }
        template <typename T = float> T &m_anglelimitxdownprone() {
            return *(T *)((std::uintptr_t)this + 0x640);
        }
        template <typename T = float> T &m_anglelimitxupprone() {
            return *(T *)((std::uintptr_t)this + 0x644);
        }
        template <typename T = float> T &m_horizontalroationlimitmin() {
            return *(T *)((std::uintptr_t)this + 0x648);
        }
        template <typename T = float> T &m_horizontalroationlimitmax() {
            return *(T *)((std::uintptr_t)this + 0x64C);
        }
        template <typename T = float> T &m_maxangleturnrightdeltaprone() {
            return *(T *)((std::uintptr_t)this + 0x650);
        }
        template <typename T = float> T &m_maxangleturnleftdeltaprone() {
            return *(T *)((std::uintptr_t)this + 0x654);
        }
        template <typename T = float> T &m_hitscoreintervaltime() {
            return *(T *)((std::uintptr_t)this + 0x658);
        }
        template <typename T = float> T &m_climbupheight() {
            return *(T *)((std::uintptr_t)this + 0x65C);
        }
        template <typename T = float> T &m_emptyhandsprintmaxangle() {
            return *(T *)((std::uintptr_t)this + 0x660);
        }
        template <typename T = float> T &m_proneanimspeedmul() {
            return *(T *)((std::uintptr_t)this + 0x664);
        }
        template <typename T = float> T &m_backwardconsinethresholdvalue() {
            return *(T *)((std::uintptr_t)this + 0x668);
        }
        template <typename T = float> T &m_standmovetocrouchtransitiontime() {
            return *(T *)((std::uintptr_t)this + 0x66C);
        }
        template <typename T = float> T &m_crouchmovetostandtransitiontime() {
            return *(T *)((std::uintptr_t)this + 0x670);
        }
        template <typename T = float> T &m_animationsprintforwardlerpspeed() {
            return *(T *)((std::uintptr_t)this + 0x674);
        }
        template <typename T = float> T &m_animationsprintlaterallerpspeed() {
            return *(T *)((std::uintptr_t)this + 0x678);
        }
        template <typename T = float> T &m_animationcrouchforwardlerpspeed() {
            return *(T *)((std::uintptr_t)this + 0x67C);
        }
        template <typename T = float> T &m_animationcrouchlaterallerpspeed() {
            return *(T *)((std::uintptr_t)this + 0x680);
        }
        template <typename T = float> T &m_animationrunforwardlerpspeed() {
            return *(T *)((std::uintptr_t)this + 0x684);
        }
        template <typename T = float> T &m_animationrunsimulatespeed() {
            return *(T *)((std::uintptr_t)this + 0x688);
        }
        template <typename T = float> T &m_animationrunlaterallerpspeed() {
            return *(T *)((std::uintptr_t)this + 0x68C);
        }
        template <typename T = float> T &m_animationswimforwardlerpspeed() {
            return *(T *)((std::uintptr_t)this + 0x690);
        }
        template <typename T = float> T &m_animationswimlaterallerpspeed() {
            return *(T *)((std::uintptr_t)this + 0x694);
        }
        template <typename T = float> T &m_animationtpswimforwardlerpspeed() {
            return *(T *)((std::uintptr_t)this + 0x698);
        }
        template <typename T = float> T &m_animationtpswimlaterallerpspeed() {
            return *(T *)((std::uintptr_t)this + 0x69C);
        }
        template <typename T = float> T &m_animationproneforwardlerpspeed() {
            return *(T *)((std::uintptr_t)this + 0x6A0);
        }
        template <typename T = float> T &m_animationpronelaterallerpspeed() {
            return *(T *)((std::uintptr_t)this + 0x6A4);
        }
        template <typename T = float> T &m_animationdyingforwardlerpspeed() {
            return *(T *)((std::uintptr_t)this + 0x6A8);
        }
        template <typename T = float> T &m_animationdyinglaterallerpspeed() {
            return *(T *)((std::uintptr_t)this + 0x6AC);
        }
        template <typename T = float> T &m_walkingtofallingheight() {
            return *(T *)((std::uintptr_t)this + 0x6B0);
        }
        template <typename T = float> T &m_slidetackletofallingheight() {
            return *(T *)((std::uintptr_t)this + 0x6B4);
        }
        template <typename T = float> T &m_walkingtoskydivingheight() {
            return *(T *)((std::uintptr_t)this + 0x6B8);
        }
        template <typename T = float>
        T &m_walkingtoskydivingheightfromvehicle() {
            return *(T *)((std::uintptr_t)this + 0x6BC);
        }
        template <typename T = float> T &m_easywalkingtoskydivingheight() {
            return *(T *)((std::uintptr_t)this + 0x6C0);
        }
        template <typename T = float> T &m_maxangleturnleftdelta() {
            return *(T *)((std::uintptr_t)this + 0x6C4);
        }
        template <typename T = float> T &m_maxangleturnrightdelta() {
            return *(T *)((std::uintptr_t)this + 0x6C8);
        }
        template <typename T = float> T &m_maxanglepessnagerturndelta() {
            return *(T *)((std::uintptr_t)this + 0x6CC);
        }
        template <typename T = float> T &m_maxanglemoveturndelta() {
            return *(T *)((std::uintptr_t)this + 0x6D0);
        }
        template <typename T = float> T &m_swimmingmaxspeed() {
            return *(T *)((std::uintptr_t)this + 0x6D4);
        }
        template <typename T = float> T &m_underwaterswimmingmaxspeed() {
            return *(T *)((std::uintptr_t)this + 0x6D8);
        }
        template <typename T = float> T &m_floatingmaxspeed() {
            return *(T *)((std::uintptr_t)this + 0x6DC);
        }
        template <typename T = float> T &m_swimmingsprintmaxspeed() {
            return *(T *)((std::uintptr_t)this + 0x6E0);
        }
        template <typename T = float> T &m_underwaterswimmingsprintmaxspeed() {
            return *(T *)((std::uintptr_t)this + 0x6E4);
        }
        template <typename T = float> T &m_divingmaxspeed() {
            return *(T *)((std::uintptr_t)this + 0x6E8);
        }
        template <typename T = float> T &m_totaloxygen() {
            return *(T *)((std::uintptr_t)this + 0x6EC);
        }
        template <typename T = float> T &m_oxygenrecoverspeed() {
            return *(T *)((std::uintptr_t)this + 0x6F0);
        }
        template <typename T = float> T &m_oxygenattenuatespeed() {
            return *(T *)((std::uintptr_t)this + 0x6F4);
        }
        template <typename T = float> T &m_startswimmingheight() {
            return *(T *)((std::uintptr_t)this + 0x6F8);
        }
        template <typename T = float> T &m_deepwaterheight() {
            return *(T *)((std::uintptr_t)this + 0x6FC);
        }
        template <typename T = float> T &m_sprintingwaterheight() {
            return *(T *)((std::uintptr_t)this + 0x700);
        }
        template <typename T = float> T &m_sprintmaxcliffangle() {
            return *(T *)((std::uintptr_t)this + 0x704);
        }
        template <typename T = float> T &m_recoverrotationspeed() {
            return *(T *)((std::uintptr_t)this + 0x708);
        }
        template <typename T = float> T &m_recovermoverotationspeed() {
            return *(T *)((std::uintptr_t)this + 0x70C);
        }
        template <typename T = float> T &m_recoversprintrotationspeed() {
            return *(T *)((std::uintptr_t)this + 0x710);
        }
        template <typename T = float> T &m_cliffangle() {
            return *(T *)((std::uintptr_t)this + 0x714);
        }
        template <typename T = float> T &m_slopelimit() {
            return *(T *)((std::uintptr_t)this + 0x718);
        }
        template <typename T = float> T &m_fallinglandtime() {
            return *(T *)((std::uintptr_t)this + 0x71C);
        }
        template <typename T = float> T &m_dropdowntime() {
            return *(T *)((std::uintptr_t)this + 0x720);
        }
        template <typename T = float> T &m_landhardstandtime() {
            return *(T *)((std::uintptr_t)this + 0x724);
        }
        template <typename T = float> T &m_crouchingeyeheight() {
            return *(T *)((std::uintptr_t)this + 0x728);
        }
        template <typename T = float> T &m_prone1ptransitiontime() {
            return *(T *)((std::uintptr_t)this + 0x72C);
        }
        template <typename T = float> T &m_prone1pmidstoptime() {
            return *(T *)((std::uintptr_t)this + 0x730);
        }
        template <typename T = float> T &m_swimmingaimingfirespeedscale() {
            return *(T *)((std::uintptr_t)this + 0x734);
        }
        template <typename T = float> T &m_swimmingfirespeedscale() {
            return *(T *)((std::uintptr_t)this + 0x738);
        }
        template <typename T = float> T &m_guidemovecheckangle() {
            return *(T *)((std::uintptr_t)this + 0x73C);
        }
        template <typename T = float> T &m_guidemovecheckspeed() {
            return *(T *)((std::uintptr_t)this + 0x740);
        }
        template <typename T = float> T &m_guidemovechecktime() {
            return *(T *)((std::uintptr_t)this + 0x744);
        }
        template <typename T = float> T &m_pronetostandacceleration() {
            return *(T *)((std::uintptr_t)this + 0x748);
        }
        template <typename T = float> T &m_individuationtpscameradistance() {
            return *(T *)((std::uintptr_t)this + 0x74C);
        }
        template <typename T = float> T &m_individuationtpscamerayoffset() {
            return *(T *)((std::uintptr_t)this + 0x750);
        }
        template <typename T = float> T &m_playhitcdtime() {
            return *(T *)((std::uintptr_t)this + 0x754);
        }
        template <typename T = float> T &m_standingeyeheight() {
            return *(T *)((std::uintptr_t)this + 0x758);
        }
        template <typename T = float> T &m_proneingeyeheight() {
            return *(T *)((std::uintptr_t)this + 0x75C);
        }
        template <typename T = float> T &m_concussionmovementscale() {
            return *(T *)((std::uintptr_t)this + 0x760);
        }
        template <typename T = float> T &m_fallinghorizontalobstrutangle() {
            return *(T *)((std::uintptr_t)this + 0x764);
        }
        template <typename T = float> T &m_validfallingraydistance() {
            return *(T *)((std::uintptr_t)this + 0x768);
        }
        template <typename T = float> T &m_swimputweapontime() {
            return *(T *)((std::uintptr_t)this + 0x76C);
        }
        template <typename T = float> T &m_swimgetweapontime() {
            return *(T *)((std::uintptr_t)this + 0x770);
        }
        template <typename T = float> T &m_swimlefthandlimitupwardangle() {
            return *(T *)((std::uintptr_t)this + 0x774);
        }
        template <typename T = float> T &m_stepoffset() {
            return *(T *)((std::uintptr_t)this + 0x778);
        }
        template <typename T = float> T &m_maxclimbclientforcemovedistance() {
            return *(T *)((std::uintptr_t)this + 0x77C);
        }
        template <typename T = float> T &m_setrotationdirectlyanglethreshold() {
            return *(T *)((std::uintptr_t)this + 0x780);
        }
        template <typename T = float> T &m_jumplandheight() {
            return *(T *)((std::uintptr_t)this + 0x784);
        }
        template <typename T = float>
        T &m_walkingtofallingverticalspeedlimit() {
            return *(T *)((std::uintptr_t)this + 0x788);
        }
        template <typename T = float> T &m_dojumpverticalspeedlimit() {
            return *(T *)((std::uintptr_t)this + 0x78C);
        }
        template <typename T = float> T &m_autoslidespeed() {
            return *(T *)((std::uintptr_t)this + 0x790);
        }
        template <typename T = float> T &m_maxverticalmovedeltaspeed() {
            return *(T *)((std::uintptr_t)this + 0x794);
        }
        template <typename T = float> T &m_maxclimbfallingspeed() {
            return *(T *)((std::uintptr_t)this + 0x798);
        }
        template <typename T = float> T &m_jumpuplimittime() {
            return *(T *)((std::uintptr_t)this + 0x79C);
        }
        template <typename T = float> T &m_reachtargettime() {
            return *(T *)((std::uintptr_t)this + 0x7A0);
        }
        template <typename T = float> T &m_maxforcesimulatedistance() {
            return *(T *)((std::uintptr_t)this + 0x7A4);
        }
        template <typename T = float> T &m_facewalljumpmincosvalue() {
            return *(T *)((std::uintptr_t)this + 0x7A8);
        }
        template <typename T = float> T &m_jumpmeleeminheight() {
            return *(T *)((std::uintptr_t)this + 0x7AC);
        }
        template <typename T = float> T &m_maxwalkingslopeverticalvelocity() {
            return *(T *)((std::uintptr_t)this + 0x7B0);
        }
        template <typename T = float> T &m_simulateanimmovescale() {
            return *(T *)((std::uintptr_t)this + 0x7B4);
        }
        template <typename T = float> T &m_pronevalidxangle() {
            return *(T *)((std::uintptr_t)this + 0x7B8);
        }
        template <typename T = float> T &m_pronevalidbodylength() {
            return *(T *)((std::uintptr_t)this + 0x7BC);
        }
        template <typename T = float> T &m_pronevalidphysicscastradius() {
            return *(T *)((std::uintptr_t)this + 0x7C0);
        }
        template <typename T = float> T &m_maxforcesimulatefallingdistance() {
            return *(T *)((std::uintptr_t)this + 0x7C4);
        }
        template <typename T = float> T &m_ladderclimbtoptime() {
            return *(T *)((std::uintptr_t)this + 0x7C8);
        }
        template <typename T = float> T &m_fppickupfadetime() {
            return *(T *)((std::uintptr_t)this + 0x7CC);
        }
        template <typename T = bool> T &m_allowdowntoladder() {
            return *(T *)((std::uintptr_t)this + 0x7D0);
        }
        template <typename T = float> T &m_moveanimationspeed() {
            return *(T *)((std::uintptr_t)this + 0x7D4);
        }
        template <typename T = float> T &m_movewalkspeedforanimation() {
            return *(T *)((std::uintptr_t)this + 0x7D8);
        }
        template <typename T = float> T &m_crouchmoveanimationspeed() {
            return *(T *)((std::uintptr_t)this + 0x7DC);
        }
        template <typename T = float> T &m_ladderenterfromtoptime() {
            return *(T *)((std::uintptr_t)this + 0x7E0);
        }
        template <typename T = float> T &m_ladderclimbfromtoptime() {
            return *(T *)((std::uintptr_t)this + 0x7E4);
        }
        template <typename T = float> T &m_pronevalidcheckdistance() {
            return *(T *)((std::uintptr_t)this + 0x7E8);
        }
        template <typename T = float> T &m_velocitysyncdotvalue() {
            return *(T *)((std::uintptr_t)this + 0x7EC);
        }
        template <typename T = bool> T &m_useslowwalk() {
            return *(T *)((std::uintptr_t)this + 0x7F0);
        }
        template <typename T = bool> T &m_iscurrentanimationactive() {
            return *(T *)((std::uintptr_t)this + 0x7F1);
        }
        template <typename T = float> T &m_lastplayhittime() {
            return *(T *)((std::uintptr_t)this + 0x7F4);
        }
        template <typename T = il2cpp_list<std::uintptr_t> *>
        T &m_clothcachelist() {
            return *(T *)((std::uintptr_t)this + 0x7F8);
        }
        template <typename T = bool> T &m_hascloth() {
            return *(T *)((std::uintptr_t)this + 0x7FC);
        }
        template <typename T = bool> T &m_isusecloth() {
            return *(T *)((std::uintptr_t)this + 0x7FD);
        }
        template <typename T = std::uintptr_t> T &m_shadowbladeeffectassetid() {
            return *(T *)((std::uintptr_t)this + 0x800);
        }
        template <typename T = bool> T &isweaponinzerosocket() {
            return *(T *)((std::uintptr_t)this + 0x804);
        }
        template <typename T = std::uintptr_t>
        T &m_zerosocket_firstpersoncameratransform() {
            return *(T *)((std::uintptr_t)this + 0x808);
        }
        template <typename T = std::uintptr_t>
        T &m_zerosocket_rightweaponfirstpersontransform() {
            return *(T *)((std::uintptr_t)this + 0x80C);
        }
        template <typename T = std::uintptr_t> T &m_zerosockethandler() {
            return *(T *)((std::uintptr_t)this + 0x810);
        }
        template <typename T = std::uintptr_t> T &m_zerosocketroot() {
            return *(T *)((std::uintptr_t)this + 0x814);
        }
        template <typename T = bool> T &isusezerosocketweaponpendent() {
            return *(T *)((std::uintptr_t)this + 0x818);
        }
        template <typename T = std::uintptr_t>
        T &m_currentzeroweaponpendenthandler() {
            return *(T *)((std::uintptr_t)this + 0x81C);
        }
        template <typename T = std::uintptr_t>
        T &m_currentzeroweaponpendenthandlersocket() {
            return *(T *)((std::uintptr_t)this + 0x820);
        }
        template <typename T = std::uintptr_t> T &m_curclimbtype() {
            return *(T *)((std::uintptr_t)this + 0x824);
        }
        template <typename T = il2cpp_vec3> T &currentclimbcenter() {
            return *(T *)((std::uintptr_t)this + 0x828);
        }
        template <typename T = bool> T &m_isclimbwall() {
            return *(T *)((std::uintptr_t)this + 0x834);
        }
        template <typename T = float> T &m_climbmantlewidth() {
            return *(T *)((std::uintptr_t)this + 0x838);
        }
        template <typename T = bool> T &m_isclimbmantleover() {
            return *(T *)((std::uintptr_t)this + 0x83C);
        }
        template <typename T = il2cpp_vec3> T &m_climbstartpos() {
            return *(T *)((std::uintptr_t)this + 0x840);
        }
        template <typename T = il2cpp_vec3> T &m_climboverinitv() {
            return *(T *)((std::uintptr_t)this + 0x84C);
        }
        template <typename T = float>
        T &m_climbovercachecharcontrollerheight() {
            return *(T *)((std::uintptr_t)this + 0x858);
        }
        template <typename T = float> T &m_climboversetcharcontrollerheight() {
            return *(T *)((std::uintptr_t)this + 0x85C);
        }
        template <typename T = float> T &m_startclimbovertime() {
            return *(T *)((std::uintptr_t)this + 0x860);
        }
        template <typename T = float> T &m_maxclimbovertime() {
            return *(T *)((std::uintptr_t)this + 0x864);
        }
        template <typename T = float> T &m_climbovergravity() {
            return *(T *)((std::uintptr_t)this + 0x868);
        }
        template <typename T = float> T &m_climbovervelocityup() {
            return *(T *)((std::uintptr_t)this + 0x86C);
        }
        template <typename T = float> T &m_climbovervelocityforward() {
            return *(T *)((std::uintptr_t)this + 0x870);
        }
        template <typename T = il2cpp_vec3> T &m_climbupdestpos() {
            return *(T *)((std::uintptr_t)this + 0x874);
        }
        template <typename T = il2cpp_vec3> T &m_climboverhightpos() {
            return *(T *)((std::uintptr_t)this + 0x880);
        }
        template <typename T = float> T &m_endclimbovermaxheightmultyply() {
            return *(T *)((std::uintptr_t)this + 0x88C);
        }
        template <typename T = float> T &m_horizontalspeed() {
            return *(T *)((std::uintptr_t)this + 0x890);
        }
        template <typename T = float> T &m_maxjumpheight() {
            return *(T *)((std::uintptr_t)this + 0x894);
        }
        template <typename T = float> T &m_jumpbeginheight() {
            return *(T *)((std::uintptr_t)this + 0x898);
        }
        template <typename T = float> T &m_jumptopheight() {
            return *(T *)((std::uintptr_t)this + 0x89C);
        }
        template <typename T = float> T &m_lastdojumptime() {
            return *(T *)((std::uintptr_t)this + 0x8A0);
        }
        template <typename T = float> T &m_currentdojumpmaxheight() {
            return *(T *)((std::uintptr_t)this + 0x8A4);
        }
        template <typename T = float> T &m_startfallingtime() {
            return *(T *)((std::uintptr_t)this + 0x8A8);
        }
        template <typename T = float> T &m_verticalspeed() {
            return *(T *)((std::uintptr_t)this + 0x8AC);
        }
        template <typename T = float> T &m_reachjumpingtoptime() {
            return *(T *)((std::uintptr_t)this + 0x8B0);
        }
        template <typename T = bool> T &m_isjumpingup() {
            return *(T *)((std::uintptr_t)this + 0x8B4);
        }
        template <typename T = bool> T &m_reachjumpingtop() {
            return *(T *)((std::uintptr_t)this + 0x8B5);
        }
        template <typename T = float> T &fixlimitjumphornzontalspeed() {
            return *(T *)((std::uintptr_t)this + 0x8B8);
        }
        template <typename T = float> T &m_aircontrol() {
            return *(T *)((std::uintptr_t)this + 0x8BC);
        }
        template <typename T = bool> T &m_blastframeslopagainstwallmove() {
            return *(T *)((std::uintptr_t)this + 0x8C0);
        }
        template <typename T = bool> T &islastmove() {
            return *(T *)((std::uintptr_t)this + 0x8C1);
        }
        template <typename T = bool> T &m_isphyswalkingslidemove() {
            return *(T *)((std::uintptr_t)this + 0x8C2);
        }
        template <typename T = bool> T &openfacewallfix() {
            return *(T *)((std::uintptr_t)this + 0x8C3);
        }
        template <typename T = bool> T &docheckwalkinginfloatnan() {
            return *(T *)((std::uintptr_t)this + 0x8C4);
        }
        template <typename T = float> T &m_lastmovescale() {
            return *(T *)((std::uintptr_t)this + 0x8C8);
        }
        template <typename T = il2cpp_array<std::uintptr_t> *>
        T &m_checkstuckcollider() {
            return *(T *)((std::uintptr_t)this + 0x8CC);
        }
        template <typename T = std::int32_t> T &m_checkstruckframe() {
            return *(T *)((std::uintptr_t)this + 0x8D0);
        }
        template <typename T = bool> T &m_islastinstruck() {
            return *(T *)((std::uintptr_t)this + 0x8D4);
        }
        template <typename T = std::int32_t> T &m_checkstructcount() {
            return *(T *)((std::uintptr_t)this + 0x8D8);
        }
        template <typename T = il2cpp_vec3> T &m_lastinstruckposition() {
            return *(T *)((std::uintptr_t)this + 0x8DC);
        }
        template <typename T = float> T &checkstruckscale() {
            return *(T *)((std::uintptr_t)this + 0x8E8);
        }
        template <typename T = std::int32_t> T &tickprintnanlog() {
            return *(T *)((std::uintptr_t)this + 0x8EC);
        }
        template <typename T = float>
        T &m_processwalkingfacewallmoveraydownheight() {
            return *(T *)((std::uintptr_t)this + 0x8F0);
        }
        template <typename T = float>
        T &m_processwalkingfacewallmoveraydownradius() {
            return *(T *)((std::uintptr_t)this + 0x8F4);
        }
        template <typename T = std::int32_t>
        T &m_lastframeprocessstandonpawn() {
            return *(T *)((std::uintptr_t)this + 0x8F8);
        }
        template <typename T = std::int32_t>
        T &m_continueprocessstandonpawncount() {
            return *(T *)((std::uintptr_t)this + 0x8FC);
        }
        template <typename T = il2cpp_vec3> T &m_lastcchitnormal() {
            return *(T *)((std::uintptr_t)this + 0x900);
        }
        template <typename T = il2cpp_vec3> T &m_lastcchitpoint() {
            return *(T *)((std::uintptr_t)this + 0x90C);
        }
        template <typename T = bool> T &m_lastcchitbelow() {
            return *(T *)((std::uintptr_t)this + 0x918);
        }
        template <typename T = std::int32_t> T &m_lastcchitlayer() {
            return *(T *)((std::uintptr_t)this + 0x91C);
        }
        template <typename T = float> T &m_lastcchitframe() {
            return *(T *)((std::uintptr_t)this + 0x920);
        }
        template <typename T = bool> T &m_lastcchitwall() {
            return *(T *)((std::uintptr_t)this + 0x924);
        }
        template <typename T = std::int32_t> T &m_islasthitwallframe() {
            return *(T *)((std::uintptr_t)this + 0x928);
        }
        template <typename T = il2cpp_vec3> T &m_lastcchitwallnormal() {
            return *(T *)((std::uintptr_t)this + 0x92C);
        }
        template <typename T = il2cpp_vec3> T &m_lastcchitwallpoint() {
            return *(T *)((std::uintptr_t)this + 0x938);
        }
        template <typename T = il2cpp_vec3> T &m_lastcchitpawnnormal() {
            return *(T *)((std::uintptr_t)this + 0x944);
        }
        template <typename T = il2cpp_vec3> T &m_lastcchitpawnpoint() {
            return *(T *)((std::uintptr_t)this + 0x950);
        }
        template <typename T = std::int32_t> T &m_islastgroudhitpawnframe() {
            return *(T *)((std::uintptr_t)this + 0x95C);
        }
        template <typename T = bool> T &m_islastgroudhitpawn() {
            return *(T *)((std::uintptr_t)this + 0x960);
        }
        template <typename T = bool> T &m_islastcchitvehicle() {
            return *(T *)((std::uintptr_t)this + 0x961);
        }
        template <typename T = std::int32_t> T &m_islastcchitvehicleframe() {
            return *(T *)((std::uintptr_t)this + 0x964);
        }
        template <typename T = il2cpp_vec3> T &m_lastcchitvehiclenormal() {
            return *(T *)((std::uintptr_t)this + 0x968);
        }
        template <typename T = il2cpp_vec3> T &m_lastcchitvehiclepoint() {
            return *(T *)((std::uintptr_t)this + 0x974);
        }
        template <typename T = std::int32_t> T &m_islasthitceilframe() {
            return *(T *)((std::uintptr_t)this + 0x980);
        }
        template <typename T = bool> T &m_lastcchitceil() {
            return *(T *)((std::uintptr_t)this + 0x984);
        }
        template <typename T = il2cpp_vec3> T &m_lastceilcchitnormal() {
            return *(T *)((std::uintptr_t)this + 0x988);
        }
        template <typename T = il2cpp_vec3> T &m_lastceilcchitpoint() {
            return *(T *)((std::uintptr_t)this + 0x994);
        }
        template <typename T = il2cpp_vec3> T &beginfallpos() {
            return *(T *)((std::uintptr_t)this + 0x9A0);
        }
        template <typename T = il2cpp_vec3> T &fallmaxheightpos() {
            return *(T *)((std::uintptr_t)this + 0x9AC);
        }
        template <typename T = il2cpp_vec3> T &lastvehiclelocalpos() {
            return *(T *)((std::uintptr_t)this + 0x9B8);
        }
        template <typename T = il2cpp_vec3> T &lastvehicleworldpos() {
            return *(T *)((std::uintptr_t)this + 0x9C4);
        }
        template <typename T = il2cpp_vec3> T &lastvehicleangle() {
            return *(T *)((std::uintptr_t)this + 0x9D0);
        }
        template <typename T = bool> T &m_issetfromserver() {
            return *(T *)((std::uintptr_t)this + 0x9DC);
        }
        template <typename T = il2cpp_list<il2cpp_list<std::uintptr_t> *> *>
        T &m_rendererdict() {
            return *(T *)((std::uintptr_t)this + 0x9E0);
        }
        template <typename T = il2cpp_list<std::uintptr_t> *>
        T &allrenderers() {
            return *(T *)((std::uintptr_t)this + 0x9E4);
        }
        template <typename T = bool> T &isweaponswitching() {
            return *(T *)((std::uintptr_t)this + 0x9E8);
        }
        template <typename T = std::uintptr_t> T &cachediscardinfo() {
            return *(T *)((std::uintptr_t)this + 0x9EC);
        }
        template <typename T = il2cpp_dict<std::int32_t, std::uintptr_t> *>
        T &m_activeweaponnextstatemapbyitemid() {
            return *(T *)((std::uintptr_t)this + 0x9F0);
        }
        template <typename T = il2cpp_list<std::uint32_t> *>
        T &beaimedatinhighalertlist() {
            return *(T *)((std::uintptr_t)this + 0x9F4);
        }
        template <typename T = bool> T &m_needdelaytriggerads() {
            return *(T *)((std::uintptr_t)this + 0x9F8);
        }
        template <typename T = bool> T &m_resetaiminput() {
            return *(T *)((std::uintptr_t)this + 0x9F9);
        }
        template <typename T = bool> T &mresetadsinput() {
            return *(T *)((std::uintptr_t)this + 0x9FA);
        }
        template <typename T = bool> T &mresetfireinput() {
            return *(T *)((std::uintptr_t)this + 0x9FB);
        }
        template <typename T = bool> T &isbuttondown() {
            return *(T *)((std::uintptr_t)this + 0x9FC);
        }
        template <typename T = float> T &lockcontrolwhenempty() {
            return *(T *)((std::uintptr_t)this + 0xA00);
        }
        template <typename T = il2cpp_array<std::uintptr_t> *>
        T &onuseitemfinish() {
            return *(T *)((std::uintptr_t)this + 0xA04);
        }

        template <typename T = void>
        T copyproperties(std::uintptr_t _infrom, bool _includeparent) {
            return ((T(*)(pawn *, std::uintptr_t, bool))(
                il2cpp::il2cpp_base() + 0x1D43138))(this, _infrom,
                                                    _includeparent);
        }

        template <typename T = std::uintptr_t> T get_datatype() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D43644))(this);
        }

        template <typename T = std::int32_t> T get_reloadcount() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D43700))(this);
        }

        template <typename T = void> T set_reloadcount(std::int32_t _value) {
            return ((T(*)(pawn *, std::int32_t))(il2cpp::il2cpp_base() +
                                                 0x1D43708))(this, _value);
        }

        template <typename T = void> T onreloadfinish() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D43710))(this);
        }

        template <typename T = bool> T get_isstartfireinsprint() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D437D8))(this);
        }

        template <typename T = std::uintptr_t> T get_logictype() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D437E0))(this);
        }

        template <typename T = float> T get_walkingtoskydivingheight() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D437E8))(this);
        }

        template <typename T = std::uintptr_t> T get_pendingswitchweapon() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D43830))(this);
        }

        template <typename T = void> T fixedupdate() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D43838))(this);
        }

        template <typename T = bool> T get_ispendingswitchweapon() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D439FC))(this);
        }

        template <typename T = il2cpp_string *> T get_pawnconfigpath() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D43AAC))(this);
        }

        template <typename T = void>
        T set_pawnconfigpath(il2cpp_string *_value) {
            return ((T(*)(pawn *, il2cpp_string *))(il2cpp::il2cpp_base() +
                                                    0x1D43AB4))(this, _value);
        }

        template <typename T = bool> T get_isgrapdestpoint() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D43ABC))(this);
        }

        template <typename T = void> T set_isgrapdestpoint(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D43AC4))(
                this, _value);
        }

        template <typename T = il2cpp_vec3> T get_grapplegundestpoint() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D43ACC))(this);
        }

        template <typename T = std::uintptr_t> T get_pawntransitiontype() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D43AE0))(this);
        }

        template <typename T = void>
        T set_pawntransitiontype(std::uintptr_t _value) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D43AE8))(this, _value);
        }

        template <typename T = float> T get_pronebodyangle() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D43AF0))(this);
        }

        template <typename T = void> T set_pronebodyangle(float _value) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D43AF8))(
                this, _value);
        }

        template <typename T = std::int32_t> T get_inregionid() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D43B00))(this);
        }

        template <typename T = void> T set_inregionid(std::int32_t _value) {
            return ((T(*)(pawn *, std::int32_t))(il2cpp::il2cpp_base() +
                                                 0x1D43B08))(this, _value);
        }

        template <typename T = float> T get_maxmovespeed() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D43B10))(this);
        }

        template <typename T = void> T set_maxmovespeed(float _value) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D43B18))(
                this, _value);
        }

        template <typename T = std::uintptr_t> T get_soundemitter() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D43B20))(this);
        }

        template <typename T = std::uintptr_t> T get_weaponsyncmodule() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D43B28))(this);
        }

        template <typename T = bool> T get_shouldshowpawninfowhenaimedat() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D43B30))(this);
        }

        template <typename T = bool> T get_shoulddisplayhp() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D43B38))(this);
        }

        template <typename T = bool> T get_calcweaponaccuracy() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D43B40))(this);
        }

        template <typename T = bool> T get_usefixedweaponaccuracy() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D43B48))(this);
        }

        template <typename T = float> T get_fixedweaponaccuracy() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D43B50))(this);
        }

        template <typename T = void> T set_fixedweaponaccuracy(float _value) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D43B58))(
                this, _value);
        }

        template <typename T = void>
        T settpscameraoffset(il2cpp_vec3 _setvalue, float _inlerptime) {
            return ((T(*)(pawn *, il2cpp_vec3, float))(
                il2cpp::il2cpp_base() + 0x1D43B60))(this, _setvalue,
                                                    _inlerptime);
        }

        template <typename T = void> static T nullaction() {
            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x1D4414C))(0);
        }

        template <typename T = void> T cameraoffsetlerptick() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4420C))(this);
        }

        template <typename T = void> T set_pronetransitionrate(float _value) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D44514))(
                this, _value);
        }

        template <typename T = void>
        T set_istransitiontopronestate(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D4451C))(
                this, _value);
        }

        template <typename T = void>
        T set_istransitionfrompronestate(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D44524))(
                this, _value);
        }

        template <typename T = bool> T get_canseesmokein() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4452C))(this);
        }

        template <typename T = void> T set_canseesmokein(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D44534))(
                this, _value);
        }

        template <typename T = bool> T get_canseestreakfront() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4453C))(this);
        }

        template <typename T = void> T set_canseestreakfront(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D44544))(
                this, _value);
        }

        template <typename T = il2cpp_vec3> T get_mapshowposition() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D44764))(this);
        }

        template <typename T = il2cpp_quaternion> T get_mapshowrotation() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D447A4))(this);
        }

        template <typename T = std::int32_t> T get_attackanimindex() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D447B4))(this);
        }

        template <typename T = void>
        T set_attackanimindex(std::int32_t _value) {
            return ((T(*)(pawn *, std::int32_t))(il2cpp::il2cpp_base() +
                                                 0x1D447BC))(this, _value);
        }

        template <typename T = void> T set_blandaimeanble(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D44C44))(
                this, _value);
        }

        template <typename T = bool> T canstand() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D44D7C))(this);
        }

        template <typename T = il2cpp_vec3> T gettpscameraoffset() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4507C))(this);
        }

        template <typename T = void> T resettpscameraoffset() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4544C))(this);
        }

        template <typename T = void> T set_forcesyncmove(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D45618))(
                this, _value);
        }

        template <typename T = bool> T get_forcesyncmove() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D45624))(this);
        }

        template <typename T = bool> T get_ismove() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4562C))(this);
        }

        template <typename T = il2cpp_string *>
        T getfirspesronweaponsocketname() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D45740))(this);
        }

        template <typename T = il2cpp_string *> T getweaponsocketname() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D45828))(this);
        }

        template <typename T = il2cpp_string *> T getleftweaponsocketname() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D45958))(this);
        }

        template <typename T = std::uintptr_t> T get_invmanager() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D45A88))(this);
        }

        template <typename T = void> T set_invmanager(std::uintptr_t _value) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D45A90))(this, _value);
        }

        template <typename T = bool>
        T get_shouldcheckcollisionwithlocalplayer() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D45A98))(this);
        }

        template <typename T = bool> T get_isattachknifefordropweapon() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D45AA0))(this);
        }

        template <typename T = void>
        T set_isattachknifefordropweapon(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D45AA8))(
                this, _value);
        }

        template <typename T = bool> T get_hasinit() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D45AAC))(this);
        }

        template <typename T = void> T set_hasinit(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D45AB4))(
                this, _value);
        }

        template <typename T = std::uintptr_t> T get_currentweaponattachment() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D45ABC))(this);
        }

        template <typename T = std::uintptr_t>
        T get_currentsubweaponattachment() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D45AC4))(this);
        }

        template <typename T = std::uintptr_t> T get_currentweapon() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D45ACC))(this);
        }

        template <typename T = std::uintptr_t> T get_firstweapon() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D45B9C))(this);
        }

        template <typename T = std::uintptr_t> T get_secondweapon() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D45C6C))(this);
        }

        template <typename T = std::uintptr_t> T get_currentsubweapon() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D45D3C))(this);
        }

        template <typename T = void> T setreloadingmagactive(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D45E0C))(
                this, _value);
        }

        template <typename T = std::uintptr_t> T getlefthandcenter() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D46014))(this);
        }

        template <typename T = std::uintptr_t> T getreloadingmag() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D46214))(this);
        }

        template <typename T = bool> T get_inwater() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D46414))(this);
        }

        template <typename T = void> T set_inwater(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D4641C))(
                this, _value);
        }

        template <typename T = float> T get_currentwatersurfaceheight() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D46424))(this);
        }

        template <typename T = std::uintptr_t>
        T get_cachedupperbodytransform() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4642C))(this);
        }

        template <typename T = std::uintptr_t> T get_headbone() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D46434))(this);
        }

        template <typename T = std::uintptr_t> T get_aimtargetforbot() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4643C))(this);
        }

        template <typename T = std::uintptr_t> T get_m_collisionflags() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D46480))(this);
        }

        template <typename T = std::uintptr_t>
        T get_currentmovecollisionflags() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D46568))(this);
        }

        template <typename T = il2cpp_vec3> T get_accelerationreal() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D465A4))(this);
        }

        template <typename T = il2cpp_vec3> T get_acceleration() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D465B8))(this);
        }

        template <typename T = void> T set_acceleration(il2cpp_vec3 _value) {
            return ((T(*)(pawn *, il2cpp_vec3))(il2cpp::il2cpp_base() +
                                                0x1D465CC))(this, _value);
        }

        template <typename T = il2cpp_vec3> T get_velocity() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D465D8))(this);
        }

        template <typename T = void> T set_velocity(il2cpp_vec3 _value) {
            return ((T(*)(pawn *, il2cpp_vec3))(il2cpp::il2cpp_base() +
                                                0x1D465EC))(this, _value);
        }

        template <typename T = void>
        T set_remotecontrolledvehicle(std::uintptr_t _value) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D465F8))(this, _value);
        }

        template <typename T = std::uintptr_t> T get_remotecontrolledvehicle() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D46600))(this);
        }

        template <typename T = std::uintptr_t> T get_currentvehicle() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D2AE10))(this);
        }

        template <typename T = void>
        T set_currentvehicle(std::uintptr_t _value) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D46608))(this, _value);
        }

        template <typename T = void>
        T setlastvehicleinfo(float _lastgetofftime, std::uint32_t _vehicleid) {
            return ((T(*)(pawn *, float, std::uint32_t))(
                il2cpp::il2cpp_base() + 0x1D467C4))(this, _lastgetofftime,
                                                    _vehicleid);
        }

        template <typename T = bool> T get_isridingvehicle() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D468BC))(this);
        }

        template <typename T = bool> T get_isonplateformvehicle() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4696C))(this);
        }

        template <typename T = std::uintptr_t> T get_currentseatmode() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D46A60))(this);
        }

        template <typename T = bool> T get_isonforbidshootseat() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D46B44))(this);
        }

        template <typename T = bool> T get_iscontrollingvehicleweapon() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D15998))(this);
        }

        template <typename T = std::uintptr_t>
        T get_currentvehicleweaponmode() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D46C38))(this);
        }

        template <typename T = il2cpp_list<std::uintptr_t> *>
        T get_availablevehicles() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D3CB7C))(this);
        }

        template <typename T = float> T get_penetrationvalue() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D46D1C))(this);
        }

        template <typename T = void> T set_penetrationvalue(float _value) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D46D24))(
                this, _value);
        }

        template <typename T = float> T get_health() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D46D2C))(this);
        }

        template <typename T = void> T set_health(float _value) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D46D34))(
                this, _value);
        }

        template <typename T = bool> T get_isfullhpprogressbar() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D46E44))(this);
        }

        template <typename T = il2cpp_vec3> T get_fireblockworldpos() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D46E4C))(this);
        }

        template <typename T = void>
        T set_fireblockworldpos(il2cpp_vec3 _value) {
            return ((T(*)(pawn *, il2cpp_vec3))(il2cpp::il2cpp_base() +
                                                0x1D46E60))(this, _value);
        }

        template <typename T = il2cpp_quaternion> T get_aimrotation() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D46E6C))(this);
        }

        template <typename T = void>
        T set_aimrotation(il2cpp_quaternion _value) {
            return ((T(*)(pawn *, il2cpp_quaternion))(il2cpp::il2cpp_base() +
                                                      0x1D46EB8))(this, _value);
        }

        template <typename T = il2cpp_quaternion>
        T get_delayshootaimrotationlocal() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D46ED0))(this);
        }

        template <typename T = void>
        T set_delayshootaimrotationlocal(il2cpp_quaternion _value) {
            return ((T(*)(pawn *, il2cpp_quaternion))(il2cpp::il2cpp_base() +
                                                      0x1D46EE0))(this, _value);
        }

        template <typename T = il2cpp_quaternion>
        T get_delayshootaimrotation() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D46EF8))(this);
        }

        template <typename T = void>
        T set_delayshootaimrotation(il2cpp_quaternion _value) {
            return ((T(*)(pawn *, il2cpp_quaternion))(il2cpp::il2cpp_base() +
                                                      0x1D46F08))(this, _value);
        }

        template <typename T = il2cpp_quaternion> T get_aimrotationlocal() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D46F20))(this);
        }

        template <typename T = void>
        T set_aimrotationlocal(il2cpp_quaternion _value) {
            return ((T(*)(pawn *, il2cpp_quaternion))(il2cpp::il2cpp_base() +
                                                      0x1D46F30))(this, _value);
        }

        template <typename T = il2cpp_vec3> T get_pawnservermoveangle() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D46F48))(this);
        }

        template <typename T = bool> T get_inindividuationplay() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4715C))(this);
        }

        template <typename T = bool> T get_isintransition() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D47184))(this);
        }

        template <typename T = std::uintptr_t> T getswitchrolecomponenttype() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D471D8))(this);
        }

        template <typename T = std::uintptr_t> T gettakedamagecomponenttype() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D47304))(this);
        }

        template <typename T = std::uintptr_t> T getspectatorcomponenttype() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D47430))(this);
        }

        template <typename T = std::uintptr_t> T getactioncomponenttype() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4755C))(this);
        }

        template <typename T = std::uintptr_t> T getcrouchcomponenttype() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D47688))(this);
        }

        template <typename T = std::uintptr_t> T getsponecomponenttype() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D477B4))(this);
        }

        template <typename T = std::uintptr_t> T getgraprushcomponenttype() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D478E0))(this);
        }

        template <typename T = std::uintptr_t>
        T getupwardlaunchcomponenttype() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D47A0C))(this);
        }

        template <typename T = std::uintptr_t>
        T getinvisibleskillcomponenttype() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D47B38))(this);
        }

        template <typename T = std::uintptr_t> T getadaptiverootmotiontype() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D47C64))(this);
        }

        template <typename T = std::uintptr_t> T getiksolvercomponenttype() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D47D90))(this);
        }

        template <typename T = std::uintptr_t>
        T getavatarrotationcomponenttype() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D47EBC))(this);
        }

        template <typename T = std::uintptr_t> T getladdercomponenttype() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D47FE8))(this);
        }

        template <typename T = std::uintptr_t> T getjumpcomponenttype() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D48114))(this);
        }

        template <typename T = std::uintptr_t> T getpawndeadcomponenttype() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D48240))(this);
        }

        template <typename T = std::uintptr_t> T getpawnsoundcomponenttype() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4836C))(this);
        }

        template <typename T = std::uintptr_t> T getpawneffectmanagertype() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D48498))(this);
        }

        template <typename T = std::uintptr_t> T get_pawntakedamagecomponent() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D485C4))(this);
        }

        template <typename T = std::uintptr_t> T get_trickycomponent() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D485CC))(this);
        }

        template <typename T = std::uintptr_t> T get_jumpcomponent() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D485D4))(this);
        }

        template <typename T = std::uintptr_t> T get_gravityspikescomponent() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D485DC))(this);
        }

        template <typename T = std::uintptr_t> T get_shadowbladecomponent() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D485E4))(this);
        }

        template <typename T = std::uintptr_t>
        T get_pawnslidetacklecomponent() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D485EC))(this);
        }

        template <typename T = std::uintptr_t> T get_pawnrollcomponent() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D485F4))(this);
        }

        template <typename T = std::uintptr_t> T get_avatar() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D485FC))(this);
        }

        template <typename T = std::uintptr_t> T get_ragdollcomponent() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D43914))(this);
        }

        template <typename T = std::uintptr_t> T get_spectatorcomp() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D48628))(this);
        }

        template <typename T = std::uintptr_t> T get_actioncomponent() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D48630))(this);
        }

        template <typename T = std::uintptr_t> T get_dynamicskincomponent() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D48638))(this);
        }

        template <typename T = std::uintptr_t> T get_individuationcomponent() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D48640))(this);
        }

        template <typename T = std::uintptr_t> T get_laddercomponent() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D48648))(this);
        }

        template <typename T = std::uintptr_t> T get_graprushcomp() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D48650))(this);
        }

        template <typename T = std::uintptr_t> T get_upwardlaunchcomp() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D48658))(this);
        }

        template <typename T = std::uintptr_t> T get_invisibleskillcomp() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D48660))(this);
        }

        template <typename T = std::uintptr_t> T get_paintcomp() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D48668))(this);
        }

        template <typename T = std::uintptr_t>
        T get_currentiksolvercomponent() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D48670))(this);
        }

        template <typename T = std::uintptr_t> T get_pawnsoundcom() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D48678))(this);
        }

        template <typename T = std::uintptr_t> T get_pawneffectmgr() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D48680))(this);
        }

        template <typename T = il2cpp_vec3> T get_lastsimulatedvelocity() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D48688))(this);
        }

        template <typename T = il2cpp_quaternion> T get_simulatedaimrotation() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4869C))(this);
        }

        template <typename T = void>
        T set_simulatedaimrotation(il2cpp_quaternion _value) {
            return ((T(*)(pawn *, il2cpp_quaternion))(il2cpp::il2cpp_base() +
                                                      0x1D486AC))(this, _value);
        }

        template <typename T = void> T set_ladderforceyangle(float _value) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D486C4))(
                this, _value);
        }

        template <typename T = float> T get_ladderforceyangle() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D486CC))(this);
        }

        template <typename T = bool> T get_shouldforceangle() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D486D4))(this);
        }

        template <typename T = bool> T get_inladder() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D486E8))(this);
        }

        template <typename T = std::uintptr_t> T get_pawnreliablesounddata() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D486FC))(this);
        }

        template <typename T = bool> T get_inelectric() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D48894))(this);
        }

        template <typename T = void> T set_inelectric(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D4889C))(
                this, _value);
        }

        template <typename T = bool> T get_isinsmoke() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D488A4))(this);
        }

        template <typename T = void> T set_isinsmoke(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D488AC))(
                this, _value);
        }

        template <typename T = bool> T get_needforceswitchweapon() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D488B4))(this);
        }

        template <typename T = void> T inittargetrotationyangle(float _y) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D488BC))(
                this, _y);
        }

        template <typename T = il2cpp_quaternion> T getweaponaimrotation() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4898C))(this);
        }

        template <typename T = void> T simulatedstartprone() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D48ACC))(this);
        }

        template <typename T = void> T simulatedendprone() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D48BD8))(this);
        }

        template <typename T = void> T simulatedendcrouch() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D48CBC))(this);
        }

        template <typename T = void>
        T simulatedstartgraprush(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D48D84))(
                this, _deltatime);
        }

        template <typename T = void> T invokesimulatedendgraprush() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D48E70))(this);
        }

        template <typename T = void> T simulatedendgraprush() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D48F98))(this);
        }

        template <typename T = void> T simulatedgraprush(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D49078))(
                this, _deltatime);
        }

        template <typename T = void> T setgraprushparam(il2cpp_vec3 _inpos) {
            return ((T(*)(pawn *, il2cpp_vec3))(il2cpp::il2cpp_base() +
                                                0x1D49164))(this, _inpos);
        }

        template <typename T = void> T startgraprush(il2cpp_vec3 _inpos) {
            return ((T(*)(pawn *, il2cpp_vec3))(il2cpp::il2cpp_base() +
                                                0x1D49278))(this, _inpos);
        }

        template <typename T = void> T ongrapplegunstickmiss() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D493AC))(this);
        }

        template <typename T = void> T onchangeclip() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4998C))(this);
        }

        template <typename T = void>
        T attachproppawn(std::uintptr_t _proppawn,
                         std::uint32_t _ulauncheractorid) {
            return ((T(*)(pawn *, std::uintptr_t, std::uint32_t))(
                il2cpp::il2cpp_base() + 0x1D49A64))(this, _proppawn,
                                                    _ulauncheractorid);
        }

        template <typename T = void> T dettachproppawn() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D49BDC))(this);
        }

        template <typename T = void>
        T setlaunchparam(std::uintptr_t _launchparam) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D49CC4))(this, _launchparam);
        }

        template <typename T = std::uintptr_t> T getlaunchparam() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D49DB8))(this);
        }

        template <typename T = void>
        T changeupwardlaunchstate(std::uintptr_t _state) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D49EA0))(this, _state);
        }

        template <typename T = void>
        T simulatedstartlauncheruprush(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D49F8C))(
                this, _deltatime);
        }

        template <typename T = void> T simulatedendlauncheruprush() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4A078))(this);
        }

        template <typename T = void>
        T simulatedlauncheruprush(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D4A15C))(
                this, _deltatime);
        }

        template <typename T = void>
        T forcechangeskydivinginupwardlaunchstate() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4A248))(this);
        }

        template <typename T = std::uintptr_t> T getroottransform() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4A328))(this);
        }

        template <typename T = std::uintptr_t> T getsnipe2transform() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4A49C))(this);
        }

        template <typename T = void> T setfallingstartinhigh() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4A608))(this);
        }

        template <typename T = void> T ondeactivatesubweapon() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4974C))(this);
        }

        template <typename T = void> T lockstateinusingsubweapon(bool _block) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D4A890))(
                this, _block);
        }

        template <typename T = void> T lockstateinusingairborne(bool _block) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D4A9C4))(
                this, _block);
        }

        template <typename T = void> T endsubweaponaction() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4AAF8))(this);
        }

        template <typename T = void>
        T endupwardlaunchaction(bool _bchangestate) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D4ABE0))(
                this, _bchangestate);
        }

        template <typename T = void>
        T subweaponspawnfireimpact(std::uintptr_t _info) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D4ACB0))(this, _info);
        }

        template <typename T = bool> T get_lastinputsprint() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4AF9C))(this);
        }

        template <typename T = float> T get_horizontalspeed() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4AFA4))(this);
        }

        template <typename T = void> T set_horizontalspeed(float _value) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D4AFAC))(
                this, _value);
        }

        template <typename T = float> T get_maxclientforcemovedistance() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4AFB4))(this);
        }

        template <typename T = void> T set_canswitchweapon(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D4B0EC))(
                this, _value);
        }

        template <typename T = float> T get_maxacceleration() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B0F4))(this);
        }

        template <typename T = bool> T get_isreachout() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B114))(this);
        }

        template <typename T = bool> T get_isbacktoseattransition() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B11C))(this);
        }

        template <typename T = bool> T get_isdriving() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B124))(this);
        }

        template <typename T = bool> T get_isride() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B1D4))(this);
        }

        template <typename T = float> T get_sprintingwaterheight() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B1DC))(this);
        }

        template <typename T = void> T set_maxspeed(float _value) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D4B1E4))(
                this, _value);
        }

        template <typename T = float> T get_maxspeed() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B1EC))(this);
        }

        template <typename T = bool> T isbackward() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B360))(this);
        }

        template <typename T = float> T get_initialmaxjumpheight() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B4F0))(this);
        }

        template <typename T = float> T get_maxangleturnleftdeltaprone() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B544))(this);
        }

        template <typename T = float> T get_maxangleturnrightdeltaprone() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B54C))(this);
        }

        template <typename T = il2cpp_vec2> T get_horizontalroationlimit() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B554))(this);
        }

        template <typename T = il2cpp_vec2> T get_verticalroationlimit() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B570))(this);
        }

        template <typename T = il2cpp_vec2>
        T get_maxhorizontalturndeltaprone() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B58C))(this);
        }

        template <typename T = il2cpp_vec2> T get_verticalroationlimitprone() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B5A8))(this);
        }

        template <typename T = bool> T get_isclimbing() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B5C4))(this);
        }

        template <typename T = bool> T get_isladder() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B5E0))(this);
        }

        template <typename T = bool> T get_isusingzipline() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B0D8))(this);
        }

        template <typename T = bool> T get_isskydiving() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B5F4))(this);
        }

        template <typename T = bool> T get_isaircrftskydiving() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B618))(this);
        }

        template <typename T = void> T set_easyskyfly(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D4B62C))(
                this, _value);
        }

        template <typename T = bool> T get_easyskyfly() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B634))(this);
        }

        template <typename T = bool> T get_isskyfly() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B63C))(this);
        }

        template <typename T = bool> T get_isfalling() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B650))(this);
        }

        template <typename T = void> T set_iscrouching(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D4B664))(
                this, _value);
        }

        template <typename T = bool> T get_iscrouching() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B66C))(this);
        }

        template <typename T = bool> T get_isstanding() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B674))(this);
        }

        template <typename T = void> T set_isproneing(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D4B69C))(
                this, _value);
        }

        template <typename T = bool> T get_isproneing() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D45444))(this);
        }

        template <typename T = void> T set_isrotation(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D4B6A4))(
                this, _value);
        }

        template <typename T = bool> T get_isrotation() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B6AC))(this);
        }

        template <typename T = float> T get_currentinwaterdepth() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B6B4))(this);
        }

        template <typename T = bool> T get_isswimming() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B6BC))(this);
        }

        template <typename T = bool> T get_isblind() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B6C4))(this);
        }

        template <typename T = bool> T get_shouldswimsprint() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B784))(this);
        }

        template <typename T = bool> T get_isdying() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B7BC))(this);
        }

        template <typename T = void> T set_isinaircraft(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D4B7C4))(
                this, _value);
        }

        template <typename T = bool> T get_isinaircraft() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B7CC))(this);
        }

        template <typename T = void> T set_isinnonbattlearea(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D4B7D4))(
                this, _value);
        }

        template <typename T = bool> T get_isinnonbattlearea() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B7DC))(this);
        }

        template <typename T = bool> T get_landafterjumping() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B7E4))(this);
        }

        template <typename T = bool> T get_lockyrotation() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B7FC))(this);
        }

        template <typename T = void> T set_lockyrotation(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D4B804))(
                this, _value);
        }

        template <typename T = bool> T get_isgod() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B80C))(this);
        }

        template <typename T = std::uintptr_t> T get_initloginphysicsstate() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B8A8))(this);
        }

        template <typename T = void>
        T set_initloginphysicsstate(std::uintptr_t _value) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D4B8B0))(this, _value);
        }

        template <typename T = std::uintptr_t> T get_physicsstate() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B5D8))(this);
        }

        template <typename T = void> T set_physicsstate(std::uintptr_t _value) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D4B8B8))(this, _value);
        }

        template <typename T = void>
        T rawsetphysicsstate(std::uintptr_t _newstate) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D4B91C))(this, _newstate);
        }

        template <typename T = std::uintptr_t> T get_defaultphysstate() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B9F4))(this);
        }

        template <typename T = std::uintptr_t> T get_physicsvolume() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B9FC))(this);
        }

        template <typename T = std::uintptr_t> T get_animationcomponent() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D44B40))(this);
        }

        template <typename T = void>
        T set_animationcomponent(std::uintptr_t _value) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D4BA04))(this, _value);
        }

        template <typename T = std::uintptr_t>
        T get_currentactiveanimationcomponent() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4BA0C))(this);
        }

        template <typename T = std::uintptr_t>
        T get_adaptiverootmotioncomponent() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4BB78))(this);
        }

        template <typename T = bool> T get_isalive() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4BB80))(this);
        }

        template <typename T = bool> T get_isplaydying() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4BB88))(this);
        }

        template <typename T = bool> T get_isfiring() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D3E624))(this);
        }

        template <typename T = bool> T get_indeadeye() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4BB90))(this);
        }

        template <typename T = void> T set_indeadeye(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D4BB98))(
                this, _value);
        }

        template <typename T = void> T set_lastbebulletdamged(float _value) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D4BBA0))(
                this, _value);
        }

        template <typename T = void> T set_lastbeexplodedamged(float _value) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D4BBA8))(
                this, _value);
        }

        template <typename T = bool> T get_showfireloconradar() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4BBB0))(this);
        }

        template <typename T = bool> T get_showfacerotonradar() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4BE80))(this);
        }

        template <typename T = bool> T get_showbombonradar() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4BF5C))(this);
        }

        template <typename T = bool> T get_triggerquickknife() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4C134))(this);
        }

        template <typename T = void> T set_triggerquickknife(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D4C278))(
                this, _value);
        }

        template <typename T = float> T get_lastfiretime() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4C280))(this);
        }

        template <typename T = void> T set_lastfiretime(float _value) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D4C288))(
                this, _value);
        }

        template <typename T = void>
        T set_lastfireweaponname(std::uintptr_t _value) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D4C290))(this, _value);
        }

        template <typename T = float> T get_lastrespawntime() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4C298))(this);
        }

        template <typename T = il2cpp_vec3> T get_lastfireloc() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4C2A0))(this);
        }

        template <typename T = void> T set_lastfireloc(il2cpp_vec3 _value) {
            return ((T(*)(pawn *, il2cpp_vec3))(il2cpp::il2cpp_base() +
                                                0x1D4C2B4))(this, _value);
        }

        template <typename T = il2cpp_vec3> T getradarposition() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4C2C0))(this);
        }

        template <typename T = il2cpp_quaternion> T get_radarrotation() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4C438))(this);
        }

        template <typename T = il2cpp_vec3> T get_headposition() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4C448))(this);
        }

        template <typename T = il2cpp_vec3> T get_eyeposition() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4C518))(this);
        }

        template <typename T = il2cpp_vec3> T get_fireposition() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4C6D0))(this);
        }

        template <typename T = std::uint32_t> T get_teamid() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4C7E0))(this);
        }

        template <typename T = std::uint32_t> T get_teamseatid() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4C7F8))(this);
        }

        template <typename T = std::uintptr_t> T get_targetpriority() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4C810))(this);
        }

        template <typename T = std::uintptr_t> T infotype() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4C818))(this);
        }

        template <typename T = std::uint32_t> T get_playerid() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4C944))(this);
        }

        template <typename T = std::uint32_t> T get_ownerplayerid() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4C95C))(this);
        }

        template <typename T = std::uintptr_t> T get_propertyset() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4C974))(this);
        }

        template <typename T = il2cpp_string *> T get_playername() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4C998))(this);
        }

        template <typename T = bool> T get_shownameontacticalmap() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4CA64))(this);
        }

        template <typename T = bool> T get_iszombie() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4CA6C))(this);
        }

        template <typename T = std::uintptr_t> T get_playerinfo() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D46EB0))(this);
        }

        template <typename T = void> T setattackableinfo(std::uintptr_t _info) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D4CA74))(this, _info);
        }

        template <typename T = bool> T issentrygunpawn() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4CBB0))(this);
        }

        template <typename T = bool> T ishelicopterpawn() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4CC80))(this);
        }

        template <typename T = bool> T issamturretpawn() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4CD50))(this);
        }

        template <typename T = bool> T isemptyhand() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4CE20))(this);
        }

        template <typename T = bool> T islocalplayer() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D32894))(this);
        }

        template <typename T = il2cpp_vec3> T getrealpawnheadposition() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4CFB0))(this);
        }

        template <typename T = std::uintptr_t> T get_controller() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4D21C))(this);
        }

        template <typename T = void> T set_controller(std::uintptr_t _value) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D4D224))(this, _value);
        }

        template <typename T = bool> T iscontrollerof() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x0))(this);
        }

        template <typename T = std::uintptr_t> T get_currentmesh() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4A494))(this);
        }

        template <typename T = void> T set_currentmesh(std::uintptr_t _value) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D4D31C))(this, _value);
        }

        template <typename T = bool> T hadmesh() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4D324))(this);
        }

        template <typename T = std::uintptr_t> T get_modelroot() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4D478))(this);
        }

        template <typename T = void> T set_modelroot(std::uintptr_t _value) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D4D480))(this, _value);
        }

        template <typename T = il2cpp_quaternion> T get_currentmeshrotation() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4D488))(this);
        }

        template <typename T = float> T getsyncbodyrotationx() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4D5A8))(this);
        }

        template <typename T = float> T getmeshrotationx() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4D6F8))(this);
        }

        template <typename T = void>
        T setcurrentmeshrotation(il2cpp_quaternion _setrot) {
            return ((T(*)(pawn *, il2cpp_quaternion))(
                il2cpp::il2cpp_base() + 0x1D4D808))(this, _setrot);
        }

        template <typename T = void>
        T setcurrentmeshlocalposition(il2cpp_vec3 _localposition) {
            return ((T(*)(pawn *, il2cpp_vec3))(
                il2cpp::il2cpp_base() + 0x1D4D9A4))(this, _localposition);
        }

        template <typename T = void>
        T setcurrentmeshlocalrotation(il2cpp_quaternion _rotation) {
            return ((T(*)(pawn *, il2cpp_quaternion))(
                il2cpp::il2cpp_base() + 0x1D4DB60))(this, _rotation);
        }

        template <typename T = void>
        T setcurrentmeshlocaleulerangles(il2cpp_vec3 _localeulerangles) {
            return ((T(*)(pawn *, il2cpp_vec3))(
                il2cpp::il2cpp_base() + 0x1D4DD0C))(this, _localeulerangles);
        }

        template <typename T = il2cpp_list<std::uintptr_t> *>
        T get_m_meshrenderers() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4DEB0))(this);
        }

        template <typename T = il2cpp_list<std::uintptr_t> *>
        T get_meshrenderers() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4DEB8))(this);
        }

        template <typename T = bool> T get_brmeshshow() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4DEC0))(this);
        }

        template <typename T = void> T setcurrentmeshrenderer(bool _isactive) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D4DED4))(
                this, _isactive);
        }

        template <typename T = bool> T get_isfirstpersonview() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4E480))(this);
        }

        template <typename T = bool> T get_isautonomouse() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4E494))(this);
        }

        template <typename T = std::uintptr_t> T get_role() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4E4A8))(this);
        }

        template <typename T = void> T set_role(std::uintptr_t _value) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D4E4B0))(this, _value);
        }

        template <typename T = bool> T get_isonvehicle() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D3CAA4))(this);
        }

        template <typename T = bool> T get_firsttimeresapwn() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4E4B8))(this);
        }

        template <typename T = void> T set_firsttimeresapwn(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D4E4C0))(
                this, _value);
        }

        template <typename T = std::int32_t> T get_grenadecount() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4E4C8))(this);
        }

        template <typename T = bool> T get_shouldcheckdetailcollider() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4E4E0))(this);
        }

        template <typename T = bool> T get_isavatarloadsync() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4E4E8))(this);
        }

        template <typename T = bool> T get_recentlyrendered() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4E4F0))(this);
        }

        template <typename T = bool> T get_lastoccvisible() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4E5A0))(this);
        }

        template <typename T = bool> T get_isspectated() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4E650))(this);
        }

        template <typename T = il2cpp_vec3> T get_actualwalkingvelocity() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4E7B4))(this);
        }

        template <typename T = std::uintptr_t> T get_weaponshakecol() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4E86C))(this);
        }

        template <typename T = il2cpp_vec3> T get_deltaeulerangles() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4E874))(this);
        }

        template <typename T = float> T get_guidemovecheckangle() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4E890))(this);
        }

        template <typename T = float> T get_guidemovecheckspeed() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4E898))(this);
        }

        template <typename T = float> T get_guidemovechecktime() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4E8A0))(this);
        }

        template <typename T = std::uintptr_t>
        T getlogicalcomponent(std::uintptr_t _intype) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D4E8A8))(this, _intype);
        }

        template <typename T = std::uintptr_t> T getlogicalcomponent_1() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x0))(this);
        }

        template <typename T = std::uintptr_t>
        T addlogicalcomponentimpl(std::uintptr_t _type) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D4EA50))(this, _type);
        }

        template <typename T = std::uintptr_t> T addlogicalcomponent() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x0))(this);
        }

        template <typename T = void> T ticklogicalcomponents(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D4EBE8))(
                this, _deltatime);
        }

        template <typename T = std::uintptr_t>
        T addlogicalcomponent_1(std::uintptr_t _type) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D4ED84))(this, _type);
        }

        template <typename T = void> T createlogicalcomponents() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4EE84))(this);
        }

        template <typename T = void> T recoverfirstpersonsockettransform() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4FB98))(this);
        }

        template <typename T = void> T awake() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4FFE0))(this);
        }

        template <typename T = void> T preinit() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D5026C))(this);
        }

        template <typename T = void> T createinventorymanager() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D50394))(this);
        }

        template <typename T = void> T initcomponents() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D50494))(this);
        }

        template <typename T = float> T getsimulatedistance() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D506E0))(this);
        }

        template <typename T = void>
        T disableforceserverposition(float _duration) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D507B0))(
                this, _duration);
        }

        template <typename T = float> T getforcemovedist() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B008))(this);
        }

        template <typename T = float> T getmaxacceleration() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D50880))(this);
        }

        template <typename T = void> T initvector3objects() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D50968))(this);
        }

        template <typename T = float> T getcroucheyeheight() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D50A80))(this);
        }

        template <typename T = void> T tryinitlocalpawn() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D50B6C))(this);
        }

        template <typename T = void> T initpawn(std::uintptr_t _info) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D50CD0))(this, _info);
        }

        template <typename T = void> T initrole() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D522E8))(this);
        }

        template <typename T = void> T initrolecharactercolliderdata() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D52464))(this);
        }

        template <typename T = void> T resetrolecharactercolliderdata() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D52EA0))(this);
        }

        template <typename T = void> T playgoliathinitsound() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D52FA0))(this);
        }

        template <typename T = void> T resetrolephysicstate() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D531CC))(this);
        }

        template <typename T = void> T checkrespawnprotection() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D5334C))(this);
        }

        template <typename T = void>
        T initswitchrole(std::uintptr_t _viewtype) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D53414))(this, _viewtype);
        }

        template <typename T = void>
        T switchrole(std::uintptr_t _viewtype, bool _needtoresetpose) {
            return ((T(*)(pawn *, std::uintptr_t, bool))(
                il2cpp::il2cpp_base() + 0x1D53784))(this, _viewtype,
                                                    _needtoresetpose);
        }

        template <typename T = void> T endswitchrole() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D53B00))(this);
        }

        template <typename T = void>
        T onspectatingviewchange(std::uintptr_t _spectatingviewtype) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D54500))(this, _spectatingviewtype);
        }

        template <typename T = void> T notifycomponentweaponchanged() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D548A0))(this);
        }

        template <typename T = void> T notifycomponentsubweaponchanged() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D54CD8))(this);
        }

        template <typename T = void> T notifycomponentswitchrole() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D54348))(this);
        }

        template <typename T = void> T notifycomponentrespawn() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D54E90))(this);
        }

        template <typename T = void> T notifycomponentswitchview() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D55048))(this);
        }

        template <typename T = void>
        T notifycomponentclientrelevant(bool _isrelevant) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D55200))(
                this, _isrelevant);
        }

        template <typename T = void>
        T notifycomponentspectatingviewchange(
            std::uintptr_t _spectatingviewtype) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D546D0))(this, _spectatingviewtype);
        }

        template <typename T = void> T notifycomponentspectatingstart() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D553D0))(this);
        }

        template <typename T = void> T notifycomponentspectatingend() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D55588))(this);
        }

        template <typename T = void> T notifycomponentbegindestroy() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D55740))(this);
        }

        template <typename T = void> T notifycomponentdie() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D558F8))(this);
        }

        template <typename T = bool> T isswitchingrole() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D55AB0))(this);
        }

        template <typename T = std::uintptr_t> T getswitchingstep() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D55BB4))(this);
        }

        template <typename T = std::uintptr_t>
        T createplayerinfo(std::uint32_t _playerid, std::uint32_t _actorid,
                           std::uintptr_t _camp) {
            return ((T(*)(pawn *, std::uint32_t, std::uint32_t,
                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x1D55C9C))(
                this, _playerid, _actorid, _camp);
        }

        template <typename T = void> T initplayerinfo(std::uintptr_t _info) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D55F00))(this, _info);
        }

        template <typename T = void> T cachetransform() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D562FC))(this);
        }

        template <typename T = void> T cachemeshsocket() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D56DEC))(this);
        }

        template <typename T = void> T loadproperties() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D56F58))(this);
        }

        template <typename T = void> T clearasyncloadcallback() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D5728C))(this);
        }

        template <typename T = void> T destroycomponent() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D5736C))(this);
        }

        template <typename T = void> T destroypawn() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D57A48))(this);
        }

        template <typename T = void> T begindestroy() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D57D34))(this);
        }

        template <typename T = void> T destroyinventory() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D5756C))(this);
        }

        template <typename T = void> T destroycurrentweapon() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D57E30))(this);
        }

        template <typename T = void> T resetplayer() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D5813C))(this);
        }

        template <typename T = void>
        T addavailablevehicle(std::uintptr_t _vehicle) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D58558))(this, _vehicle);
        }

        template <typename T = void>
        T removeavailablevehicle(std::uintptr_t _vehicle) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D58684))(this, _vehicle);
        }

        template <typename T = void> T removeallavailablevehicle() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D587B0))(this);
        }

        template <typename T = bool>
        T isforbidvehiclecontrollwithcurrentweapon() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D589DC))(this);
        }

        template <typename T = void> T vehiclecontrol(std::uintptr_t _type) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D58D30))(this, _type);
        }

        template <typename T = void> T vehicledrive() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D599CC))(this);
        }

        template <typename T = void> T vehicleride() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D59F54))(this);
        }

        template <typename T = void> T vehicleseatchange() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D5A468))(this);
        }

        template <typename T = void> T vehiclegetoff() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D5A7C8))(this);
        }

        template <typename T = std::uintptr_t> T getbestavailablevehicle() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D592B8))(this);
        }

        template <typename T = void> T tick(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D5B3C8))(
                this, _deltatime);
        }

        template <typename T = void>
        T updatefirstpersoncameraoffset(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D5BC04))(
                this, _deltatime);
        }

        template <typename T = void>
        T smoothmovefirstpersoncameraviewportoffsetx(float _destlocaloffsetx,
                                                     float _duration) {
            return ((T(*)(pawn *, float, float))(
                il2cpp::il2cpp_base() + 0x1D5BFAC))(this, _destlocaloffsetx,
                                                    _duration);
        }

        template <typename T = float>
        T getfirstpersoncameraoffsetx_originalvalue() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D5C160))(this);
        }

        template <typename T = void> T updatelod() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D5C230))(this);
        }

        template <typename T = void> T notifyanimcomponentinitialized() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D5C374))(this);
        }

        template <typename T = void> T notifywearablethingschanged() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D5C468))(this);
        }

        template <typename T = void> T configanimcomponent() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D5C530))(this);
        }

        template <typename T = std::uintptr_t> T get_cachedmaincamera() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D5C5F8))(this);
        }

        template <typename T = bool> T cancamerasee(std::uintptr_t _dstcamera) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D5C6C8))(this, _dstcamera);
        }

        template <typename T = void> T processsprint(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D5C950))(
                this, _deltatime);
        }

        template <typename T = void> T processservermove(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D5CA20))(
                this, _deltatime);
        }

        template <typename T = void> T processstandalonemove(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D5CAF0))(
                this, _deltatime);
        }

        template <typename T = void> T ticksimulate(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D5CBC0))(
                this, _deltatime);
        }

        template <typename T = void>
        T possessedby(std::uintptr_t _playercontroller) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D5CC90))(this, _playercontroller);
        }

        template <typename T = void> T unpossessed() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D5CDB8))(this);
        }

        template <typename T = void> T initmeshrenderers() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D5CEA4))(this);
        }

        template <typename T = void> T initmesh(std::uintptr_t _model) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D5CFF4))(this, _model);
        }

        template <typename T = void>
        T checkcreatearmobj(std::uintptr_t _model) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D5DCC8))(this, _model);
        }

        template <typename T = void> T createuparmobj(std::uintptr_t _model) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D5E73C))(this, _model);
        }

        template <typename T = void> T setuparmobjscale(float _value) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D5E930))(
                this, _value);
        }

        template <typename T = std::int32_t>
        T getuparmfxassetid(bool _isleftarm) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D5EA00))(
                this, _isleftarm);
        }

        template <typename T = void> T setuparmfxshoworhide(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D5EC34))(
                this, _value);
        }

        template <typename T = void> T refreshuparmfxshoworhide() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D5EEEC))(this);
        }

        template <typename T = bool> T isneeddistinguish(bool _iscreate) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D5F014))(
                this, _iscreate);
        }

        template <typename T = void> T setinitialvisibility() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D5F4F4))(this);
        }

        template <typename T = void> T sethidden(bool _ishidden) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D5F690))(
                this, _ishidden);
        }

        template <typename T = bool> T get_ishide() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D5FB1C))(this);
        }

        template <typename T = void> T setrelevent(bool _isrelevent) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D5FB24))(
                this, _isrelevent);
        }

        template <typename T = void> T setoccvisible(bool _occvisible) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D5FEA0))(
                this, _occvisible);
        }

        template <typename T = void> T setlocation(il2cpp_vec3 _location) {
            return ((T(*)(pawn *, il2cpp_vec3))(il2cpp::il2cpp_base() +
                                                0x1D601D8))(this, _location);
        }

        template <typename T = void>
        T setrotation(il2cpp_quaternion _rotation) {
            return ((T(*)(pawn *, il2cpp_quaternion))(
                il2cpp::il2cpp_base() + 0x1D60310))(this, _rotation);
        }

        template <typename T = void>
        T setrotation_1(float _yangle, float _inputyangle) {
            return ((T(*)(pawn *, float, float))(il2cpp::il2cpp_base() +
                                                 0x1D60494))(this, _yangle,
                                                             _inputyangle);
        }

        template <typename T = void>
        T syncposition(il2cpp_vec3 _pos, bool _checkcolliders) {
            return ((T(*)(pawn *, il2cpp_vec3, bool))(
                il2cpp::il2cpp_base() + 0x1D605EC))(this, _pos,
                                                    _checkcolliders);
        }

        template <typename T = il2cpp_vec3> T getraystartpos() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6116C))(this);
        }

        template <typename T = void>
        T onbyvehicle(std::uintptr_t _vehicletype) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D61464))(this, _vehicletype);
        }

        template <typename T = void> T onleavevehicle() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D61534))(this);
        }

        template <typename T = void> T onchangeseat() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D615FC))(this);
        }

        template <typename T = void>
        T teleport(il2cpp_vec3 _pos, il2cpp_quaternion _rot,
                   bool _snaptoground) {
            return ((T(*)(pawn *, il2cpp_vec3, il2cpp_quaternion, bool))(
                il2cpp::il2cpp_base() + 0x1D616C4))(this, _pos, _rot,
                                                    _snaptoground);
        }

        template <typename T = void>
        T setaimrotation(il2cpp_quaternion _rotation) {
            return ((T(*)(pawn *, il2cpp_quaternion))(
                il2cpp::il2cpp_base() + 0x1D61B10))(this, _rotation);
        }

        template <typename T = il2cpp_vec3>
        T clamprotation(il2cpp_vec3 _eulerangle) {
            return ((T(*)(pawn *, il2cpp_vec3))(il2cpp::il2cpp_base() +
                                                0x1D61EBC))(this, _eulerangle);
        }

        template <typename T = void>
        T addrotation(il2cpp_vec3 _targetpos, bool _onlyy) {
            return ((T(*)(pawn *, il2cpp_vec3, bool))(
                il2cpp::il2cpp_base() + 0x1D621B8))(this, _targetpos, _onlyy);
        }

        template <typename T = void>
        T addrotation_1(il2cpp_quaternion _targetrotation, bool _onlyy) {
            return ((T(*)(pawn *, il2cpp_quaternion, bool))(
                il2cpp::il2cpp_base() + 0x1D62440))(this, _targetrotation,
                                                    _onlyy);
        }

        template <typename T = void>
        T addrotation_2(il2cpp_quaternion _deltarotation) {
            return ((T(*)(pawn *, il2cpp_quaternion))(
                il2cpp::il2cpp_base() + 0x1D62668))(this, _deltarotation);
        }

        template <typename T = void> T updaterealrotation(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D62920))(
                this, _deltatime);
        }

        template <typename T = void>
        T internalupdatesetrotation(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D62A20))(
                this, _deltatime);
        }

        template <typename T = void>
        T updaterotation(il2cpp_vec3 _deltaeulerangles) {
            return ((T(*)(pawn *, il2cpp_vec3))(
                il2cpp::il2cpp_base() + 0x1D62AF0))(this, _deltaeulerangles);
        }

        template <typename T = void>
        T updatepassengerrotation(il2cpp_vec3 _angles) {
            return ((T(*)(pawn *, il2cpp_vec3))(il2cpp::il2cpp_base() +
                                                0x1D63228))(this, _angles);
        }

        template <typename T = il2cpp_quaternion> T getvehiclesocketrotation() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D63BC8))(this);
        }

        template <typename T = void> T updatepasseneranimation() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D63814))(this);
        }

        template <typename T = float> T get_currentpassengeraniangle() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D63DD0))(this);
        }

        template <typename T = void> T tickpasseneranimation(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D63DD8))(
                this, _deltatime);
        }

        template <typename T = void>
        T refreshvehicleaimrotation(bool _isforcerotate) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D64394))(
                this, _isforcerotate);
        }

        template <typename T = void>
        T updateinvehiclerotation(il2cpp_vec3 _eulerangle) {
            return ((T(*)(pawn *, il2cpp_vec3))(il2cpp::il2cpp_base() +
                                                0x1D64DC8))(this, _eulerangle);
        }

        template <typename T = void>
        T setupperbodyrotation(il2cpp_quaternion _setrot) {
            return ((T(*)(pawn *, il2cpp_quaternion))(
                il2cpp::il2cpp_base() + 0x1D61CA4))(this, _setrot);
        }

        template <typename T = void>
        T setupperbodylocalrotation(il2cpp_quaternion _setrot) {
            return ((T(*)(pawn *, il2cpp_quaternion))(
                il2cpp::il2cpp_base() + 0x1D65220))(this, _setrot);
        }

        template <typename T = void>
        T updateinnonbattlearearotation(il2cpp_vec3 _eulerangle) {
            return ((T(*)(pawn *, il2cpp_vec3))(il2cpp::il2cpp_base() +
                                                0x1D653E4))(this, _eulerangle);
        }

        template <typename T = bool> T checkceiling() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D65574))(this);
        }

        template <typename T = bool> T checkpronerotation(bool _inleftorright) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D65754))(
                this, _inleftorright);
        }

        template <typename T = bool>
        T ispronerotationcollision(il2cpp_vec3 _deltaeulerangles,
                                   il2cpp_vec3 _aimeulerangles,
                                   il2cpp_vec3 _cureulerangles,
                                   std::uintptr_t _issetbodyangle) {
            return ((T(*)(pawn *, il2cpp_vec3, il2cpp_vec3, il2cpp_vec3,
                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x1D63010))(
                this, _deltaeulerangles, _aimeulerangles, _cureulerangles,
                _issetbodyangle);
        }

        template <typename T = void>
        T updateacceleration(float _forward, float _strafe) {
            return ((T(*)(pawn *, float, float))(
                il2cpp::il2cpp_base() + 0x1D65D18))(this, _forward, _strafe);
        }

        template <typename T = void>
        T setphysicsvolume(std::uintptr_t _volume, bool _benter) {
            return ((T(*)(pawn *, std::uintptr_t, bool))(
                il2cpp::il2cpp_base() + 0x1D664E0))(this, _volume, _benter);
        }

        template <typename T = void> T performphysics(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D66A74))(
                this, _deltatime);
        }

        template <typename T = void> T soundemitterperformphysics() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D5BA34))(this);
        }

        template <typename T = bool> T isholdweapon() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D66F78))(this);
        }

        template <typename T = float> T calcmaxmovespeed() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D67048))(this);
        }

        template <typename T = float> T getweaponmovescale() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D67328))(this);
        }

        template <typename T = float> T calcfinalmovescale() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D67204))(this);
        }

        template <typename T = il2cpp_vec3> T calcfinalmovevelocity() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D67720))(this);
        }

        template <typename T = il2cpp_vec3> T getoverrideacceleration() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6785C))(this);
        }

        template <typename T = float> T getjumpscale() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6799C))(this);
        }

        template <typename T = float> T getcurrentdisttowatersurface() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D67A6C))(this);
        }

        template <typename T = bool>
        T isvalidfallingheight(float _fallingheight,
                               std::uintptr_t _disttofloor) {
            return ((T(*)(pawn *, float, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D67D4C))(this, _fallingheight,
                                                    _disttofloor);
        }

        template <typename T = bool> T isforbiddenmove() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D68050))(this);
        }

        template <typename T = bool>
        T istowarddeepwater(il2cpp_vec3 _deltamove) {
            return ((T(*)(pawn *, il2cpp_vec3))(il2cpp::il2cpp_base() +
                                                0x1D6827C))(this, _deltamove);
        }

        template <typename T = bool> T ispositionchange() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D68374))(this);
        }

        template <typename T = bool> T ispositionsubtlechange() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D68584))(this);
        }

        template <typename T = il2cpp_vec3> T getposistiondeltachange() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D686F4))(this);
        }

        template <typename T = float> T getlastmovedistance() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6883C))(this);
        }

        template <typename T = il2cpp_string *> T getdebugstring() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D68998))(this);
        }

        template <typename T = float> T getmaxspeed() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D68A68))(this);
        }

        template <typename T = bool> T couldsprintingincrounch() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D68B84))(this);
        }

        template <typename T = bool> T checkstopsprintintwithweapon() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D68C60))(this);
        }

        template <typename T = bool> T checkstopsprintintwithsubweapon() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D68E24))(this);
        }

        template <typename T = void> T physgravityspikes(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D68FE8))(
                this, _deltatime);
        }

        template <typename T = void>
        T fallinggravityspikesground(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D69BF8))(
                this, _deltatime);
        }

        template <typename T = void>
        T checkgravityspikesdown(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D69D38))(
                this, _deltatime);
        }

        template <typename T = void> T forcechecksprint() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D69E5C))(this);
        }

        template <typename T = bool> T get_isinfosprint() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D69F48))(this);
        }

        template <typename T = bool> T issprinting() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D69F70))(this);
        }

        template <typename T = bool> T cansprint() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6A0B4))(this);
        }

        template <typename T = void> T startsprint() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6A288))(this);
        }

        template <typename T = void> T stopsprintbeforechangepawn() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6A788))(this);
        }

        template <typename T = void> T stopsprint() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6A87C))(this);
        }

        template <typename T = void> T stopmove() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6AB1C))(this);
        }

        template <typename T = void> T climbladder(std::uintptr_t _ladder) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D6ABE4))(this, _ladder);
        }

        template <typename T = void> T endclimbladder(std::uintptr_t _ladder) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D6ACF4))(this, _ladder);
        }

        template <typename T = void>
        T togglephysicsfollowpath(bool _enable, std::uintptr_t _followtarget) {
            return ((T(*)(pawn *, bool, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D6AE08))(this, _enable,
                                                    _followtarget);
        }

        template <typename T = void> T enterwater(std::uintptr_t _water) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D6AF2C))(this, _water);
        }

        template <typename T = void> T leavewater(std::uintptr_t _water) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D6B02C))(this, _water);
        }

        template <typename T = bool> T cangrabladder() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6B12C))(this);
        }

        template <typename T = bool> T canshowladderhud() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6B214))(this);
        }

        template <typename T = void> T onstartindividuationanim() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6B3BC))(this);
        }

        template <typename T = bool>
        T forceplayindividuationanim(std::int32_t _itemid,
                                     std::uint32_t _posindex,
                                     std::uintptr_t _callback) {
            return ((T(*)(pawn *, std::int32_t, std::uint32_t, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D6B594))(this, _itemid, _posindex,
                                                    _callback);
        }

        template <typename T = void> T trystopindividuationanim() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D545E8))(this);
        }

        template <typename T = bool> T get_isinuseitem() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6BF44))(this);
        }

        template <typename T = void> T trystopuseitem() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6BF4C))(this);
        }

        template <typename T = void> T trystoppickup() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6C014))(this);
        }

        template <typename T = void> T trystopplaytrick() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6C128))(this);
        }

        template <typename T = void> T trystopusesubweapon() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6C318))(this);
        }

        template <typename T = bool> T cangravityspikes() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6C41C))(this);
        }

        template <typename T = bool> T dogravityspikes() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6C558))(this);
        }

        template <typename T = void> T dogravityspikes1porspectator() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6C670))(this);
        }

        template <typename T = bool> T get_isshadowblade() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6CAF4))(this);
        }

        template <typename T = bool> T get_canshadowbladefire() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6CAFC))(this);
        }

        template <typename T = bool> T canshadowblade() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6CB04))(this);
        }

        template <typename T = bool> T doshadowbladeattack() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6CC34))(this);
        }

        template <typename T = void> T dophysicsprint() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6CD6C))(this);
        }

        template <typename T = void> T shadowbladefire() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6CE88))(this);
        }

        template <typename T = void>
        T setshadowbladestate(bool _state, bool _setview) {
            return ((T(*)(pawn *, bool, bool))(
                il2cpp::il2cpp_base() + 0x1D6D04C))(this, _state, _setview);
        }

        template <typename T = bool> T isjumpmeleefire() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6D480))(this);
        }

        template <typename T = void> T dropdowneyeheightforcrouching() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6D59C))(this);
        }

        template <typename T = void> T recovereyeheightforcrouching() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6D680))(this);
        }

        template <typename T = float> T getcollisionheight() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6D764))(this);
        }

        template <typename T = float> T getcollisionradius() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6D868))(this);
        }

        template <typename T = void>
        T chooseinitthirdpersoncamera(float _mindist,
                                      std::uintptr_t _out_camrot) {
            return ((T(*)(pawn *, float, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D6D96C))(this, _mindist,
                                                    _out_camrot);
        }

        template <typename T = float> T get_spectatecameraradiusscale() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6E094))(this);
        }

        template <typename T = void>
        T calcthirdpersoncamera(float _delattime, std::uintptr_t _out_camloc,
                                std::uintptr_t _out_camrot) {
            return ((T(*)(pawn *, float, std::uintptr_t, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D6E0A0))(this, _delattime,
                                                    _out_camloc, _out_camrot);
        }

        template <typename T = void>
        T calcbrthirdpersoncamera(float _delattime, std::uintptr_t _out_camloc,
                                  std::uintptr_t _out_camrot) {
            return ((T(*)(pawn *, float, std::uintptr_t, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D6E540))(this, _delattime,
                                                    _out_camloc, _out_camrot);
        }

        template <typename T = void>
        T calcdeathcam(float _delattime, std::uintptr_t _out_camloc,
                       std::uintptr_t _out_camrot) {
            return ((T(*)(pawn *, float, std::uintptr_t, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D6E9D4))(this, _delattime,
                                                    _out_camloc, _out_camrot);
        }

        template <typename T = void> T resetupperbodyrelativepos() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6ED38))(this);
        }

        template <typename T = void>
        T startsubweaponfire(bool _isopenaimstate) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D6EE9C))(
                this, _isopenaimstate);
        }

        template <typename T = void>
        T setsubweaponfirestate(bool _isopenaimstate) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D6EF6C))(
                this, _isopenaimstate);
        }

        template <typename T = il2cpp_vec3> T getleftmuzzleflashsocketpos() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6F03C))(this);
        }

        template <typename T = bool> T canswitchfiremode() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6F11C))(this);
        }

        template <typename T = bool> T canswitchview() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6F22C))(this);
        }

        template <typename T = void> T switchtomelee(bool _isdirectly) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D6F78C))(
                this, _isdirectly);
        }

        template <typename T = void> T switchtolastusedweapon() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6F9C0))(this);
        }

        template <typename T = void>
        T onsyncanimation3p(std::uintptr_t _animname, float _animlength,
                            float _param1) {
            return ((T(*)(pawn *, std::uintptr_t, float, float))(
                il2cpp::il2cpp_base() + 0x1D6FE94))(this, _animname,
                                                    _animlength, _param1);
        }

        template <typename T = bool>
        T shouldignoreaimtarget(std::uintptr_t _target) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D700A0))(this, _target);
        }

        template <typename T = void>
        T onsynchpchange(float _newhp, float _maxhp) {
            return ((T(*)(pawn *, float, float))(
                il2cpp::il2cpp_base() + 0x1D70178))(this, _newhp, _maxhp);
        }

        template <typename T = il2cpp_vec3> T getpassengerviewposition() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D70418))(this);
        }

        template <typename T = il2cpp_vec3> T getcameraposition() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D70588))(this);
        }

        template <typename T = il2cpp_vec3>
        T getworldcamerasockettransformposition() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D70688))(this);
        }

        template <typename T = il2cpp_vec3> T getcameraposition_tps() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D70844))(this);
        }

        template <typename T = bool> T get_istpsclimb() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D70A00))(this);
        }

        template <typename T = void> T set_istpsclimb(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D70A08))(
                this, _value);
        }

        template <typename T = il2cpp_vec3> T getcameraposition_headtps() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D70A10))(this);
        }

        template <typename T = il2cpp_vec3> T getcameraposition_firstperson() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D70BE8))(this);
        }

        template <typename T = il2cpp_vec3> T getfirstpersonsocketpositioin() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D70DA4))(this);
        }

        template <typename T = il2cpp_vec3>
        T getcameralocalposition_firstperson() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D70F60))(this);
        }

        template <typename T = il2cpp_vec3>
        T getcameralocalposition_thirdperson() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D710C4))(this);
        }

        template <typename T = il2cpp_vec3> T get_cameraposition_thirdperson() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D71228))(this);
        }

        template <typename T = void>
        T set_cameraposition_thirdperson(il2cpp_vec3 _value) {
            return ((T(*)(pawn *, il2cpp_vec3))(il2cpp::il2cpp_base() +
                                                0x1D7131C))(this, _value);
        }

        template <typename T = il2cpp_vec3> T get_cameraposition_firstperson() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D71418))(this);
        }

        template <typename T = void>
        T set_cameraposition_firstperson(il2cpp_vec3 _value) {
            return ((T(*)(pawn *, il2cpp_vec3))(il2cpp::il2cpp_base() +
                                                0x1D71560))(this, _value);
        }

        template <typename T = void>
        T setcameralocalposition_firstperson(il2cpp_vec3 _localpos) {
            return ((T(*)(pawn *, il2cpp_vec3))(il2cpp::il2cpp_base() +
                                                0x1D7165C))(this, _localpos);
        }

        template <typename T = void> T recovecameralocalposition_firstperson() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D71850))(this);
        }

        template <typename T = il2cpp_quaternion> T getaimrotation() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D7196C))(this);
        }

        template <typename T = il2cpp_quaternion>
        T getcamerarotation(il2cpp_quaternion _aimrotation) {
            return ((T(*)(pawn *, il2cpp_quaternion))(
                il2cpp::il2cpp_base() + 0x1D71A4C))(this, _aimrotation);
        }

        template <typename T = il2cpp_quaternion> T getcamerarotation_1() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D71BB0))(this);
        }

        template <typename T = il2cpp_quaternion>
        T getupperbodyrotationonvehicle(bool _isdelayrotate) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D64BF8))(
                this, _isdelayrotate);
        }

        template <typename T = il2cpp_quaternion> T getupperbodyrotation() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D71D70))(this);
        }

        template <typename T = void>
        T playanimationstate(il2cpp_string *_statename) {
            return ((T(*)(pawn *, il2cpp_string *))(
                il2cpp::il2cpp_base() + 0x1D71F30))(this, _statename);
        }

        template <typename T = void>
        T playanimationstate_1(std::int32_t _stateid) {
            return ((T(*)(pawn *, std::int32_t))(il2cpp::il2cpp_base() +
                                                 0x1D72080))(this, _stateid);
        }

        template <typename T = void>
        T tryspawnsnowtrack(std::uintptr_t _pimpactinfo) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D721D0))(this, _pimpactinfo);
        }

        template <typename T = void> T trystopchangeclip() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D722A0))(this);
        }

        template <typename T = void> T forcestopchangeclip() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D72478))(this);
        }

        template <typename T = void>
        T playeventsound(il2cpp_string *_soundname) {
            return ((T(*)(pawn *, il2cpp_string *))(
                il2cpp::il2cpp_base() + 0x1D72890))(this, _soundname);
        }

        template <typename T = void> T onfinishitem(il2cpp_string *_soundname) {
            return ((T(*)(pawn *, il2cpp_string *))(
                il2cpp::il2cpp_base() + 0x1D72BC0))(this, _soundname);
        }

        template <typename T = std::int32_t> T getmeshassetid_1p() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D72C90))(this);
        }

        template <typename T = std::int32_t> T getmeshassetid_3p() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D72D60))(this);
        }

        template <typename T = std::int32_t> T getdefaultassetid_3p() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D72E30))(this);
        }

        template <typename T = void>
        T setstandanimationtransition(float _transitiontime,
                                      bool _deceleratestand) {
            return (
                (T(*)(pawn *, float, bool))(il2cpp::il2cpp_base() + 0x1D73038))(
                this, _transitiontime, _deceleratestand);
        }

        template <typename T = void>
        T setanimatinspeedtransition(float _transitiontime, float _speed) {
            return ((T(*)(pawn *, float, float))(
                il2cpp::il2cpp_base() + 0x1D731BC))(this, _transitiontime,
                                                    _speed);
        }

        template <typename T = void>
        T internaltickstandanimationtransition(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D5B920))(
                this, _deltatime);
        }

        template <typename T = void> T setmeshvisible(bool _visible) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D732A0))(
                this, _visible);
        }

        template <typename T = void> T onspectatingstart() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D73438))(this);
        }

        template <typename T = void> T onspectatingstartseteyeheight() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D736F0))(this);
        }

        template <typename T = void> T onspectatingend() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D73E7C))(this);
        }

        template <typename T = void> T spectatingendclearposteffect() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D74200))(this);
        }

        template <typename T = std::uintptr_t>
        T getpawnfirpersonweaponsocket() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D74388))(this);
        }

        template <typename T = std::uintptr_t> T getpawnfirstpersonarmsocket() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D7445C))(this);
        }

        template <typename T = std::uintptr_t> T get_firstpersonweaponsocket() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4FDC8))(this);
        }

        template <typename T = std::uintptr_t> T get_firstpersonarmsocket() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4FED4))(this);
        }

        template <typename T = std::uintptr_t> T get_thirdpersonmodelsocket() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D74530))(this);
        }

        template <typename T = std::uintptr_t> T getcomponent_fps() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x0))(this);
        }

        template <typename T = std::uintptr_t> T getcomponent_tps() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x0))(this);
        }

        template <typename T = il2cpp_array<std::uintptr_t> *>
        T getcomponents_tps() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x0))(this);
        }

        template <typename T = void> T onupdatefirstpersonsocketinit() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D7463C))(this);
        }

        template <typename T = std::uintptr_t>
        T spawnpooledmeshgo(std::uintptr_t _sockettrans,
                            std::int32_t _assetid) {
            return ((T(*)(pawn *, std::uintptr_t, std::int32_t))(
                il2cpp::il2cpp_base() + 0x1D74704))(this, _sockettrans,
                                                    _assetid);
        }

        template <typename T = void>
        T despawnpooledmeshgo(std::uintptr_t _meshgo, bool _is3p) {
            return ((T(*)(pawn *, std::uintptr_t, bool))(
                il2cpp::il2cpp_base() + 0x1D748D8))(this, _meshgo, _is3p);
        }

        template <typename T = void> T initcolliders() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D74DB4))(this);
        }

        template <typename T = void> T resetcollidersonmesh() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D74EE4))(this);
        }

        template <typename T = void> T onavatarloadcompleted() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D7533C))(this);
        }

        template <typename T = void>
        T simulatedpreplaygetweaponanim(std::int32_t _actorid,
                                        std::int32_t _itemid,
                                        float _equiptime) {
            return ((T(*)(pawn *, std::int32_t, std::int32_t, float))(
                il2cpp::il2cpp_base() + 0x1D75ADC))(this, _actorid, _itemid,
                                                    _equiptime);
        }

        template <typename T = std::uintptr_t>
        T giveweaponsilenced(std::uintptr_t _info, bool _baddforce) {
            return ((T(*)(pawn *, std::uintptr_t, bool))(
                il2cpp::il2cpp_base() + 0x1D75BCC))(this, _info, _baddforce);
        }

        template <typename T = std::uintptr_t>
        T giveweaponsilenced_1(std::int32_t _weaponid, unsigned char _slot,
                               bool _baddforce,
                               il2cpp_list<std::uintptr_t> *_partinfolist,
                               std::uint32_t _skinid, std::int32_t _actorid,
                               std::int32_t _weaponlv,
                               std::int32_t _crosshairitemid,
                               il2cpp_list<std::uint32_t> *_stickers) {
            return ((T(*)(pawn *, std::int32_t, unsigned char, bool,
                          il2cpp_list<std::uintptr_t> *, std::uint32_t,
                          std::int32_t, std::int32_t, std::int32_t,
                          il2cpp_list<std::uint32_t> *))(il2cpp::il2cpp_base() +
                                                         0x1D75E28))(
                this, _weaponid, _slot, _baddforce, _partinfolist, _skinid,
                _actorid, _weaponlv, _crosshairitemid, _stickers);
        }

        template <typename T = std::uintptr_t>
        T giveweaponbypickup(std::int32_t _weaponid, unsigned char _slot,
                             bool _baddforce,
                             il2cpp_list<std::uintptr_t> *_partinfolist,
                             std::uint32_t _skinid, std::int32_t _actorid,
                             std::int32_t _weaponlevel,
                             std::int32_t _crosshairitemid,
                             il2cpp_list<std::uint32_t> *_stickers) {
            return ((T(*)(pawn *, std::int32_t, unsigned char, bool,
                          il2cpp_list<std::uintptr_t> *, std::uint32_t,
                          std::int32_t, std::int32_t, std::int32_t,
                          il2cpp_list<std::uint32_t> *))(il2cpp::il2cpp_base() +
                                                         0x1D76108))(
                this, _weaponid, _slot, _baddforce, _partinfolist, _skinid,
                _actorid, _weaponlevel, _crosshairitemid, _stickers);
        }

        template <typename T = std::uintptr_t>
        T giveweapon(std::uintptr_t _info, bool _baddforce) {
            return ((T(*)(pawn *, std::uintptr_t, bool))(
                il2cpp::il2cpp_base() + 0x1D7629C))(this, _info, _baddforce);
        }

        template <typename T = std::uintptr_t>
        T giveweapon_1(std::int32_t _weaponid, unsigned char _slot,
                       bool _baddforce,
                       il2cpp_list<std::uintptr_t> *_partinfolist,
                       std::uint32_t _skinid, std::int32_t _actorid,
                       std::int32_t _weaponlevel, std::int32_t _crosshairitemid,
                       il2cpp_list<std::uint32_t> *_stickers) {
            return ((T(*)(pawn *, std::int32_t, unsigned char, bool,
                          il2cpp_list<std::uintptr_t> *, std::uint32_t,
                          std::int32_t, std::int32_t, std::int32_t,
                          il2cpp_list<std::uint32_t> *))(il2cpp::il2cpp_base() +
                                                         0x1D765F8))(
                this, _weaponid, _slot, _baddforce, _partinfolist, _skinid,
                _actorid, _weaponlevel, _crosshairitemid, _stickers);
        }

        template <typename T = void> T addallinventory() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D769D8))(this);
        }

        template <typename T = void>
        T die(bool _isheadshot, std::uintptr_t _damagetype) {
            return ((T(*)(pawn *, bool, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D76C8C))(this, _isheadshot,
                                                    _damagetype);
        }

        template <typename T = void> T reset() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D78CBC))(this);
        }

        template <typename T = void> T checkresetmeshrenderers() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D792C8))(this);
        }

        template <typename T = void> T resetmove() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D79520))(this);
        }

        template <typename T = void>
        T playdying(bool _isheadshot, std::uintptr_t _damagetype) {
            return ((T(*)(pawn *, bool, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D795E8))(this, _isheadshot,
                                                    _damagetype);
        }

        template <typename T = void> T playdieanim(bool _isheadshot) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D7997C))(
                this, _isheadshot);
        }

        template <typename T = void> T setdyingphysics() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D79B6C))(this);
        }

        template <typename T = void> T removeallinventories() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D79C44))(this);
        }

        template <typename T = void> T takedamage(std::uintptr_t _damageinfo) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D79D24))(this, _damageinfo);
        }

        template <typename T = void>
        T setongoingdamage(float _remainingtime, std::uintptr_t _dps,
                           std::int32_t _assetid) {
            return ((T(*)(pawn *, float, std::uintptr_t, std::int32_t))(
                il2cpp::il2cpp_base() + 0x1D79E34))(this, _remainingtime, _dps,
                                                    _assetid);
        }

        template <typename T = void>
        T playtakedamageeffect(std::uintptr_t _damageinfo) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D79F48))(this, _damageinfo);
        }

        template <typename T = std::uint32_t> T get_beforeinstigatorplayerid() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D7A058))(this);
        }

        template <typename T = void>
        T set_beforeinstigatorplayerid(std::uint32_t _value) {
            return ((T(*)(pawn *, std::uint32_t))(il2cpp::il2cpp_base() +
                                                  0x1D7A060))(this, _value);
        }

        template <typename T = std::int32_t>
        T getbloodeffectasset(std::uintptr_t _info) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D7A068))(this, _info);
        }

        template <typename T = bool> T ismatchobhidbloodeffect() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D7A368))(this);
        }

        template <typename T = void>
        T playhitbloodeffect(il2cpp_vec3 _pos, std::uintptr_t _info) {
            return ((T(*)(pawn *, il2cpp_vec3, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D7A58C))(this, _pos, _info);
        }

        template <typename T = void>
        T reporthitbylocalplayer(std::uintptr_t _info) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D7AB6C))(this, _info);
        }

        template <typename T = void>
        T playhiteffect(std::uintptr_t _hitmotiondir,
                        std::uintptr_t _damagetype) {
            return ((T(*)(pawn *, std::uintptr_t, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D7AC3C))(this, _hitmotiondir,
                                                    _damagetype);
        }

        template <typename T = void>
        T playhurteffect(std::uintptr_t _damageinfo) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D7AD60))(this, _damageinfo);
        }

        template <typename T = void>
        T playpawneffect(std::int32_t _assetid, il2cpp_string *_socket) {
            return ((T(*)(pawn *, std::int32_t, il2cpp_string *))(
                il2cpp::il2cpp_base() + 0x1D7B180))(this, _assetid, _socket);
        }

        template <typename T = std::uintptr_t>
        T findsocket(il2cpp_string *_socketname) {
            return ((T(*)(pawn *, il2cpp_string *))(
                il2cpp::il2cpp_base() + 0x1D7B524))(this, _socketname);
        }

        template <typename T = void>
        T adjustdamage(std::uintptr_t _damageinfo) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D7B770))(this, _damageinfo);
        }

        template <typename T = void>
        T simulatetakedamage(std::uintptr_t _damageinfo) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D7B880))(this, _damageinfo);
        }

        template <typename T = void>
        T simulatespecialdamage(std::uintptr_t _damageinfo) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D7BE90))(this, _damageinfo);
        }

        template <typename T = std::uintptr_t>
        T calhitmotiondirection(std::uintptr_t _damageinfo) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D7BF80))(this, _damageinfo);
        }

        template <typename T = void> T setviewtype(std::uintptr_t _viewtype) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D7C1FC))(this, _viewtype);
        }

        template <typename T = void> T stopdriving() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D7C678))(this);
        }

        template <typename T = std::int32_t> T getcameracolliderlayer() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D7C820))(this);
        }

        template <typename T = void> T getonselfvehicle() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D7C9EC))(this);
        }

        template <typename T = void>
        T getonvehicle(std::uintptr_t _vehicle, std::uintptr_t _seat) {
            return ((T(*)(pawn *, std::uintptr_t, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D7CD98))(this, _vehicle, _seat);
        }

        template <typename T = void> T resetrotation() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D7CF68))(this);
        }

        template <typename T = void> T getoffvehicle(std::uintptr_t _vehicle) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D7D0D0))(this, _vehicle);
        }

        template <typename T = void>
        T onpassengerstatechange(unsigned char _infotype) {
            return ((T(*)(pawn *, unsigned char))(il2cpp::il2cpp_base() +
                                                  0x1D7D1CC))(this, _infotype);
        }

        template <typename T = bool> T getultpickupstate() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D7D29C))(this);
        }

        template <typename T = void> T setultpickupcdstate() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D7D36C))(this);
        }

        template <typename T = void> T onentertrigger(std::uintptr_t _trigger) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D7D434))(this, _trigger);
        }

        template <typename T = void> T onleavetrigger(std::uintptr_t _trigger) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D7E780))(this, _trigger);
        }

        template <typename T = void>
        T onprocesscarepackagetrigger(std::uintptr_t _carepackage,
                                      bool _isenter) {
            return ((T(*)(pawn *, std::uintptr_t, bool))(
                il2cpp::il2cpp_base() + 0x1D7E3D0))(this, _carepackage,
                                                    _isenter);
        }

        template <typename T = void>
        T onentercarepackagetrigger(std::uintptr_t _carepackage) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D7EDE0))(this, _carepackage);
        }

        template <typename T = void>
        T onleavecarepackagetrigger(std::uintptr_t _carepackage) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D7F474))(this, _carepackage);
        }

        template <typename T = void>
        T onprocessshieldturrettrigger(std::uintptr_t _sentrygun,
                                       bool _isenter) {
            return ((T(*)(pawn *, std::uintptr_t, bool))(
                il2cpp::il2cpp_base() + 0x1D7E608))(this, _sentrygun, _isenter);
        }

        template <typename T = void> T recyclemesh() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D7F754))(this);
        }

        template <typename T = void> T ondestroy() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D7FA48))(this);
        }

        template <typename T = std::uintptr_t> T getsoundemittertype() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D7FC04))(this);
        }

        template <typename T = void>
        T createsoundemitter(std::uintptr_t _info) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D5160C))(this, _info);
        }

        template <typename T = void> T initaudiocomponents() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D7FCD4))(this);
        }

        template <typename T = void> T deinitaudiocomponents() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D80030))(this);
        }

        template <typename T = float> T getfootstepauditionrange() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D80200))(this);
        }

        template <typename T = void>
        T entercustomstepsoundvolume(il2cpp_string *_stepsnd1p,
                                     il2cpp_string *_stepsnd3p) {
            return ((T(*)(pawn *, il2cpp_string *, il2cpp_string *))(
                il2cpp::il2cpp_base() + 0x1D802D4))(this, _stepsnd1p,
                                                    _stepsnd3p);
        }

        template <typename T = void> T leavecustomstepsoundvolume() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D803B8))(this);
        }

        template <typename T = std::uintptr_t> T getpriority() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D80480))(this);
        }

        template <typename T = float>
        T getheightfromground(bool _bceilzero, float _offset) {
            return ((T(*)(pawn *, bool, float))(
                il2cpp::il2cpp_base() + 0x1D80550))(this, _bceilzero, _offset);
        }

        template <typename T = float>
        T gettargetposheightfromground(il2cpp_vec3 _pos, bool _bceilzero,
                                       float _offset) {
            return ((T(*)(pawn *, il2cpp_vec3, bool, float))(
                il2cpp::il2cpp_base() + 0x1D618CC))(this, _pos, _bceilzero,
                                                    _offset);
        }

        template <typename T = void>
        T removeweaponprojectile(std::uintptr_t _projectile) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D80688))(this, _projectile);
        }

        template <typename T = void> T onhpchange() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D80758))(this);
        }

        template <typename T = float> T getcamerarotaterate() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D80928))(this);
        }

        template <typename T = void> T canceluseitem(std::uint64_t _itemid) {
            return ((T(*)(pawn *, std::uint64_t))(il2cpp::il2cpp_base() +
                                                  0x1D80B14))(this, _itemid);
        }

        template <typename T = void>
        T ondiscardweapon(std::int32_t _inweaponitemid,
                          unsigned char _inweaponslot, std::int32_t _actorid) {
            return ((T(*)(pawn *, std::int32_t, unsigned char, std::int32_t))(
                il2cpp::il2cpp_base() + 0x1D80BF8))(this, _inweaponitemid,
                                                    _inweaponslot, _actorid);
        }

        template <typename T = void>
        T onflashbangexplode(std::int32_t _weaponitemid, float _lifespanscale,
                             float _intensity) {
            return ((T(*)(pawn *, std::int32_t, float, float))(
                il2cpp::il2cpp_base() + 0x1D80CE4))(this, _weaponitemid,
                                                    _lifespanscale, _intensity);
        }

        template <typename T = void>
        T onrepulsegrenadeexplode(std::uint64_t _instigatorplayerid,
                                  il2cpp_vec3 _sourcepos,
                                  float _repulseduration,
                                  float _repulsespeedscale) {
            return ((T(*)(pawn *, std::uint64_t, il2cpp_vec3, float, float))(
                il2cpp::il2cpp_base() + 0x1D80DD4))(
                this, _instigatorplayerid, _sourcepos, _repulseduration,
                _repulsespeedscale);
        }

        template <typename T = bool> T couldplaysound() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D80EE0))(this);
        }

        template <typename T = void>
        T ondie(std::uint32_t _inkillerid, std::uint64_t _killweaponid) {
            return ((T(*)(pawn *, std::uint32_t, std::uint64_t))(
                il2cpp::il2cpp_base() + 0x1D80FB0))(this, _inkillerid,
                                                    _killweaponid);
        }

        template <typename T = void> T mirrorweapon() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8109C))(this);
        }

        template <typename T = void> T fullammo() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D81250))(this);
        }

        template <typename T = void>
        T syncweaponbulletinfo(il2cpp_array<std::uintptr_t> *_infoset,
                               std::int32_t _count) {
            return (
                (T(*)(pawn *, il2cpp_array<std::uintptr_t> *, std::int32_t))(
                    il2cpp::il2cpp_base() + 0x1D81330))(this, _infoset, _count);
        }

        template <typename T = std::uintptr_t>
        T get_cachedaimassistancecollider() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8145C))(this);
        }

        template <typename T = float> T get_hitscoretime() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8150C))(this);
        }

        template <typename T = void> T set_hitscoretime(float _value) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D81514))(
                this, _value);
        }

        template <typename T = il2cpp_vec3> T get_lastdamagesourcepos() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8151C))(this);
        }

        template <typename T = void>
        T set_lastdamagesourcepos(il2cpp_vec3 _value) {
            return ((T(*)(pawn *, il2cpp_vec3))(il2cpp::il2cpp_base() +
                                                0x1D81530))(this, _value);
        }

        template <typename T = float> T get_hitscoreintervaltime() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8153C))(this);
        }

        template <typename T = void> T set_hitscoreintervaltime(float _value) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D81544))(
                this, _value);
        }

        template <typename T = float> T get_lastplaybloodeffecttime() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8154C))(this);
        }

        template <typename T = void>
        T set_lastplaybloodeffecttime(float _value) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D81554))(
                this, _value);
        }

        template <typename T = bool> T get_shouldupdatejumpbob() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8155C))(this);
        }

        template <typename T = void> T set_shouldupdatejumpbob(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D81564))(
                this, _value);
        }

        template <typename T = float> T get_currenteyeheight() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8156C))(this);
        }

        template <typename T = void> T set_currenteyeheight(float _value) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D81574))(
                this, _value);
        }

        template <typename T = float> T get_standingeyeheight() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D515D8))(this);
        }

        template <typename T = float> T get_goliathstandingeyeheight() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8157C))(this);
        }

        template <typename T = il2cpp_vec3> T get_standingeyeposition() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8159C))(this);
        }

        template <typename T = il2cpp_vec3> T get_currenteyeposition() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D613B0))(this);
        }

        template <typename T = std::uintptr_t> T get_viewtype() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D44B38))(this);
        }

        template <typename T = void> T set_viewtype(std::uintptr_t _value) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D81670))(this, _value);
        }

        template <typename T = bool> T get_isincocussion() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B75C))(this);
        }

        template <typename T = void> T playconcussionsound(bool _isplay) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D81678))(
                this, _isplay);
        }

        template <typename T = void> T playexplodesound() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8187C))(this);
        }

        template <typename T = void>
        T beginconcussioneffect(float _duration,
                                bool _needtoshowwhitescreeneffect,
                                float _whitescreenintensityscale) {
            return ((T(*)(pawn *, float, bool, float))(il2cpp::il2cpp_base() +
                                                       0x1D81A38))(
                this, _duration, _needtoshowwhitescreeneffect,
                _whitescreenintensityscale);
        }

        template <typename T = void> T endconcussioneffect() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D82460))(this);
        }

        template <typename T = bool> T get_isinflasheffect() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B73C))(this);
        }

        template <typename T = void> T beginflasheffect(float _duration) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D82888))(
                this, _duration);
        }

        template <typename T = void> T endflasheffect() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D82974))(this);
        }

        template <typename T = bool> T get_isinemp() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B720))(this);
        }

        template <typename T = void>
        T beginempeffect(float _duration, std::uintptr_t _range) {
            return ((T(*)(pawn *, float, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D82A50))(this, _duration, _range);
        }

        template <typename T = void> T endempeffect() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D82E70))(this);
        }

        template <typename T = void> T checkblind() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D822B0))(this);
        }

        template <typename T = bool> T get_isinterferedbydrone() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4B77C))(this);
        }

        template <typename T = void> T set_isinterferedbydrone(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D830DC))(
                this, _value);
        }

        template <typename T = bool> T get_isstartbehacked() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D830E4))(this);
        }

        template <typename T = void> T set_isstartbehacked(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D830EC))(
                this, _value);
        }

        template <typename T = bool> T get_isfinishbehacked() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D830F4))(this);
        }

        template <typename T = void> T set_isfinishbehacked(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D830FC))(
                this, _value);
        }

        template <typename T = void> T endeffectsondead() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D781A0))(this);
        }

        template <typename T = void> T updateeffecttime(float _dt) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D5BDC8))(
                this, _dt);
        }

        template <typename T = bool> T isinenemysmoke() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D83104))(this);
        }

        template <typename T = bool> T isinallysmoke() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D832CC))(this);
        }

        template <typename T = bool> T get_hasocclusioneffect() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D83494))(this);
        }

        template <typename T = void> T set_hasocclusioneffect(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D8349C))(
                this, _value);
        }

        template <typename T = void> T onendmatch() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D834A4))(this);
        }

        template <typename T = std::uintptr_t>
        T findmeleeattacktarget(float _rangefactor) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D835A0))(
                this, _rangefactor);
        }

        template <typename T = void> T updategrenadeattacktarget() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D837FC))(this);
        }

        template <typename T = void>
        T updateanimationcull(std::uintptr_t _mode) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D838C4))(this, _mode);
        }

        template <typename T = void> T playreviveanim() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D83A14))(this);
        }

        template <typename T = float> T playrotationanim() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D83DA8))(this);
        }

        template <typename T = float> T stoprotationanim() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D84074))(this);
        }

        template <typename T = void> T recovercrosshair() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D841B0))(this);
        }

        template <typename T = void> T pronelocktips() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D84370))(this);
        }

        template <typename T = float>
        T playpickupanim(std::int32_t _pickitemid, bool _isweapon,
                         bool _isplayforward) {
            return ((T(*)(pawn *, std::int32_t, bool, bool))(
                il2cpp::il2cpp_base() + 0x1D84610))(this, _pickitemid,
                                                    _isweapon, _isplayforward);
        }

        template <typename T = void>
        T sethorizontalrotationlimit(float _yrotationlimitmin,
                                     float _yrotationlimitmax) {
            return ((T(*)(pawn *, float, float))(
                il2cpp::il2cpp_base() + 0x1D84BB8))(this, _yrotationlimitmin,
                                                    _yrotationlimitmax);
        }

        template <typename T = void>
        T setverticalrotationlimit(float _xrotationlimitmin,
                                   float _xrotationlimitmax) {
            return ((T(*)(pawn *, float, float))(
                il2cpp::il2cpp_base() + 0x1D84CC4))(this, _xrotationlimitmin,
                                                    _xrotationlimitmax);
        }

        template <typename T = bool> T bornshowonradarforenemy() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D84DD0))(this);
        }

        template <typename T = bool> T canshowonradarforenemy() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D84EA0))(this);
        }

        template <typename T = bool> T get_needshowonmap() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D84FB0))(this);
        }

        template <typename T = void> T set_needshowonmap(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D84FB8))(
                this, _value);
        }

        template <typename T = il2cpp_string *>
        T tacticalradarmyselfsprite(std::uintptr_t _etacticalpawnstate) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D84FC0))(this, _etacticalpawnstate);
        }

        template <typename T = bool> T ispawnspeaking() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D851C4))(this);
        }

        template <typename T = bool> T isgoliath() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4D11C))(this);
        }

        template <typename T = void> T closegoliathhud() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8538C))(this);
        }

        template <typename T = il2cpp_string *>
        T tacticalradarviewteammatesprite(std::uintptr_t _etacticalpawnstate) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D8579C))(this, _etacticalpawnstate);
        }

        template <typename T = il2cpp_string *>
        T tacticalradarviewenemysprite() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D85988))(this);
        }

        template <typename T = bool> T needtoshowenemyspriteonradar() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D85A98))(this);
        }

        template <typename T = std::int32_t>
        T tacticalradarviewspritedepth(std::uintptr_t _spritetype) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D85B68))(this, _spritetype);
        }

        template <typename T = bool> T canbedamagedby(pawn* _pawn) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D85C50))(this, _pawn);
        }

        template <typename T = bool> T isonnonedrivecar() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D85E48))(this);
        }

        template <typename T = bool> T issamecamp(std::uintptr_t _pawn) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D86010))(this, _pawn);
        }

        template <typename T = std::uintptr_t> T get_pawncategorytype() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D863C4))(this);
        }

        template <typename T = void>
        T seteyeheightchange(float _eyechangeheight) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D863CC))(
                this, _eyechangeheight);
        }

        template <typename T = void>
        T seteyeheight(float _neweyeheight, float _inlerptime) {
            return ((T(*)(pawn *, float, float))(
                il2cpp::il2cpp_base() + 0x1D73854))(this, _neweyeheight,
                                                    _inlerptime);
        }

        template <typename T = void> T eyeheightlerptick() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D86588))(this);
        }

        template <typename T = void> T playvibrate() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D868FC))(this);
        }

        template <typename T = bool> T shouldupdatefireblockpos() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D869C4))(this);
        }

        template <typename T = bool> T isaipawn() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D86C44))(this);
        }

        template <typename T = std::uintptr_t> T getmotiondirection() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D86D14))(this);
        }

        template <typename T = void>
        T beginrootmotion(il2cpp_string *_animname, il2cpp_vec3 _destpos,
                          float _blendtime, float _fixedtime, float _speed) {
            return ((T(*)(pawn *, il2cpp_string *, il2cpp_vec3, float, float,
                          float))(il2cpp::il2cpp_base() + 0x1D8703C))(
                this, _animname, _destpos, _blendtime, _fixedtime, _speed);
        }

        template <typename T = void>
        T beginrootmotion_1(il2cpp_string *_animname, il2cpp_vec3 _destpos,
                            float _blendtime, float _fixedtime) {
            return ((T(*)(pawn *, il2cpp_string *, il2cpp_vec3, float, float))(
                il2cpp::il2cpp_base() + 0x1D87210))(this, _animname, _destpos,
                                                    _blendtime, _fixedtime);
        }

        template <typename T = bool> T isrootmotionruning() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D87370))(this);
        }

        template <typename T = bool> T isrootmotionrotation() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D874CC))(this);
        }

        template <typename T = void> T onrootmotionend(bool _interrupt) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D87628))(
                this, _interrupt);
        }

        template <typename T = void> T onrootmotioncrossfade() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D876F8))(this);
        }

        template <typename T = void>
        T onrootmotionstop(bool _isclimboverlandsky) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D877C0))(
                this, _isclimboverlandsky);
        }

        template <typename T = void> T onsimulatestartsprint() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D87890))(this);
        }

        template <typename T = void> T onsimulatestopsprint() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8799C))(this);
        }

        template <typename T = float> T get_swimverticalspeed() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D87AA8))(this);
        }

        template <typename T = bool> T isunderwater() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D87AB0))(this);
        }

        template <typename T = bool> T isunderwatersurface(float _distance) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D87B80))(
                this, _distance);
        }

        template <typename T = void> T onoperatorfiremodechanged() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D87C5C))(this);
        }

        template <typename T = bool> T get_ishighthrowfire() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D87DA0))(this);
        }

        template <typename T = void> T set_ishighthrowfire(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D87DA8))(
                this, _value);
        }

        template <typename T = void> T onthrowtypechanged(bool _ishighthrow) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D87DB0))(
                this, _ishighthrow);
        }

        template <typename T = void>
        T onweaponpartchanged(std::uintptr_t _weapon,
                              std::int32_t _weaponpartcategory, bool _isopen) {
            return ((T(*)(pawn *, std::uintptr_t, std::int32_t, bool))(
                il2cpp::il2cpp_base() + 0x1D87F4C))(
                this, _weapon, _weaponpartcategory, _isopen);
        }

        template <typename T = bool> T get_isusingbrult() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D88120))(this);
        }

        template <typename T = void> T set_isusingbrult(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D88128))(
                this, _value);
        }

        template <typename T = bool> T canuseultskill() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D88364))(this);
        }

        template <typename T = bool> T canusestreak() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8869C))(this);
        }

        template <typename T = il2cpp_vec3> T get_turnaroundtargetposition() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D88838))(this);
        }

        template <typename T = void>
        T set_turnaroundtargetposition(il2cpp_vec3 _value) {
            return ((T(*)(pawn *, il2cpp_vec3))(il2cpp::il2cpp_base() +
                                                0x1D88854))(this, _value);
        }

        template <typename T = float> T get_turnaroundradius() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D88864))(this);
        }

        template <typename T = void> T set_turnaroundradius(float _value) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D8886C))(
                this, _value);
        }

        template <typename T = float> T get_lastrotatearoundaxiseulery() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D88874))(this);
        }

        template <typename T = void>
        T set_lastrotatearoundaxiseulery(float _value) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D8887C))(
                this, _value);
        }

        template <typename T = bool> T shouldresetfirstpersonmovespeedmul() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D88884))(this);
        }

        template <typename T = void> T processpassagerreachout() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D88954))(this);
        }

        template <typename T = bool> T canpassagerreachout() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D88A1C))(this);
        }

        template <typename T = bool> T shouldstoprotationaim() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D88AEC))(this);
        }

        template <typename T = void> T initcomponentconfig() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D88C00))(this);
        }

        template <typename T = bool> T get_islean() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D88E4C))(this);
        }

        template <typename T = void> T set_inslidetackle(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D88E54))(
                this, _value);
        }

        template <typename T = bool> T get_inslidetackle() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D88E5C))(this);
        }

        template <typename T = void> T set_useslidetacklespeed(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D88E64))(
                this, _value);
        }

        template <typename T = bool> T get_useslidetacklespeed() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D88EA8))(this);
        }

        template <typename T = void> T set_inroll(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D88EB0))(
                this, _value);
        }

        template <typename T = bool> T get_inroll() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D88EB8))(this);
        }

        template <typename T = void> T set_userollspeed(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D88EC0))(
                this, _value);
        }

        template <typename T = bool> T get_userollspeed() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D88F04))(this);
        }

        template <typename T = bool> T checkslidetackle(bool _isinput) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D88F0C))(
                this, _isinput);
        }

        template <typename T = bool> T checkroll(bool _isinput) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D89294))(
                this, _isinput);
        }

        template <typename T = bool> T shouldstopik() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D894DC))(this);
        }

        template <typename T = void> T resetikweaponholdpoint() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D89604))(this);
        }

        template <typename T = void>
        T pauseik(float _time, bool _isoverride, bool _forcestop) {
            return ((T(*)(pawn *, float, bool, bool))(
                il2cpp::il2cpp_base() + 0x1D89704))(this, _time, _isoverride,
                                                    _forcestop);
        }

        template <typename T = void> T stopiktransitiontopause() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D89818))(this);
        }

        template <typename T = void> T forceresetik() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D898FC))(this);
        }

        template <typename T = void> T preresetgetweaponanimparameter() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D899FC))(this);
        }

        template <typename T = void> T preresetputweaponanimparameter() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D89AC4))(this);
        }

        template <typename T = void>
        T preplayunequipweaponanim(std::int32_t _actorid, std::int32_t _itemid,
                                   float _unequiptime, float _speed) {
            return ((T(*)(pawn *, std::int32_t, std::int32_t, float, float))(
                il2cpp::il2cpp_base() + 0x1D89B8C))(this, _actorid, _itemid,
                                                    _unequiptime, _speed);
        }

        template <typename T = void> T syncgetweapon(bool _realequip) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D89C84))(
                this, _realequip);
        }

        template <typename T = void> T syncunequipweapon(bool _realunequip) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D89ECC))(
                this, _realunequip);
        }

        template <typename T = void> T syncunequipsubweapon(bool _realunequip) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D8A190))(
                this, _realunequip);
        }

        template <typename T = bool> T get_enableswimming() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8A3E0))(this);
        }

        template <typename T = bool> T get_canswimming() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8A3E8))(this);
        }

        template <typename T = void> T onstartladder() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8A3F0))(this);
        }

        template <typename T = void> T resetladder() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8A4E8))(this);
        }

        template <typename T = void> T forceresetrotation() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8AA28))(this);
        }

        template <typename T = bool> T shouldcalboundary() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8AAF0))(this);
        }

        template <typename T = void> T stopanimationtransitionblend() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8ABC0))(this);
        }

        template <typename T = void>
        T onpreswitchanimatorcontroller(std::uintptr_t _animatorcontroller,
                                        bool _animatorcontrollerchanged) {
            return ((T(*)(pawn *, std::uintptr_t, bool))(
                il2cpp::il2cpp_base() + 0x1D8AC88))(this, _animatorcontroller,
                                                    _animatorcontrollerchanged);
        }

        template <typename T = void>
        T onpostswitchanimatorcontroller(std::uintptr_t _animatorcontroller,
                                         bool _ischanged) {
            return ((T(*)(pawn *, std::uintptr_t, bool))(
                il2cpp::il2cpp_base() + 0x1D8ADAC))(this, _animatorcontroller,
                                                    _ischanged);
        }

        template <typename T = bool> T canusekillstreakskill() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8B028))(this);
        }

        template <typename T = void>
        T dousekillstreakskill(std::int32_t _itemid) {
            return ((T(*)(pawn *, std::int32_t))(il2cpp::il2cpp_base() +
                                                 0x1D8B248))(this, _itemid);
        }

        template <typename T = void> T beginbuild(std::uintptr_t _info) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D8B674))(this, _info);
        }

        template <typename T = void> T endbuild() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8B780))(this);
        }

        template <typename T = void> T quckbuild(std::uintptr_t _info) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D8B848))(this, _info);
        }

        template <typename T = void> T cancelbuild() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8B954))(this);
        }

        template <typename T = bool> T isbuilding() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8BA1C))(this);
        }

        template <typename T = bool> T isplayingbuildanim() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8BAEC))(this);
        }

        template <typename T = bool> T checkresetweaponanimatorcontroller() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8BBBC))(this);
        }

        template <typename T = std::uintptr_t> T gettpanimatorcontroller() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8BE00))(this);
        }

        template <typename T = void> T forceresettpanimatorcontroller() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8C0F4))(this);
        }

        template <typename T = void> T forceresetdefaultanimatorcontroller() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8C328))(this);
        }

        template <typename T = void>
        T gathertpavatarrenderer(std::uintptr_t _list) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D8C5A8))(this, _list);
        }

        template <typename T = void> T switchcache3pavatarto1p() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8C694))(this);
        }

        template <typename T = void>
        T playanimatonincache3pavatar(std::uintptr_t _animatorcontroller,
                                      il2cpp_string *_animationname) {
            return ((T(*)(pawn *, std::uintptr_t, il2cpp_string *))(
                il2cpp::il2cpp_base() + 0x1D8C774))(this, _animatorcontroller,
                                                    _animationname);
        }

        template <typename T = void> T hidecache3pavatar() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8C880))(this);
        }

        template <typename T = void> T hidecache1pavatar() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8C960))(this);
        }

        template <typename T = il2cpp_string *> T getdumpstring() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8CA40))(this);
        }

        template <typename T = void> T setupbodyanimationlayer(bool _isopen) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D8D0FC))(
                this, _isopen);
        }

        template <typename T = bool>
        T getitem(std::uint64_t _initemid, bool _personalitem) {
            return ((T(*)(pawn *, std::uint64_t, bool))(
                il2cpp::il2cpp_base() + 0x1D8D284))(this, _initemid,
                                                    _personalitem);
        }

        template <typename T = void>
        T useitem(std::uint64_t _itemid, std::int32_t _useitemtype,
                  float _extendtime) {
            return ((T(*)(pawn *, std::uint64_t, std::int32_t, float))(
                il2cpp::il2cpp_base() + 0x1D8D378))(this, _itemid, _useitemtype,
                                                    _extendtime);
        }

        template <typename T = bool> T canuseitem(std::uint64_t _initemid) {
            return ((T(*)(pawn *, std::uint64_t))(il2cpp::il2cpp_base() +
                                                  0x1D8D500))(this, _initemid);
        }

        template <typename T = void>
        T onremoteuseitem(std::uint64_t _itemid, std::int32_t _useitemtype,
                          float _extendtime) {
            return ((T(*)(pawn *, std::uint64_t, std::int32_t, float))(
                il2cpp::il2cpp_base() + 0x1D8D5F0))(this, _itemid, _useitemtype,
                                                    _extendtime);
        }

        template <typename T = void>
        T remoteuseitem(std::uint64_t _itemid, std::int32_t _useitemtype,
                        float _extendtime) {
            return ((T(*)(pawn *, std::uint64_t, std::int32_t, float))(
                il2cpp::il2cpp_base() + 0x1D8D734))(this, _itemid, _useitemtype,
                                                    _extendtime);
        }

        template <typename T = void>
        T localuseitem(std::uint64_t _itemid, std::int32_t _useitemtype,
                       float _extendtime) {
            return ((T(*)(pawn *, std::uint64_t, std::int32_t, float))(
                il2cpp::il2cpp_base() + 0x1D8D848))(this, _itemid, _useitemtype,
                                                    _extendtime);
        }

        template <typename T = void>
        T serveruseindividuationitem(std::uint32_t _itemid, il2cpp_vec3 _pos,
                                     il2cpp_vec3 _rot) {
            return ((T(*)(pawn *, std::uint32_t, il2cpp_vec3, il2cpp_vec3))(
                il2cpp::il2cpp_base() + 0x1D8D93C))(this, _itemid, _pos, _rot);
        }

        template <typename T = void> T onusespecialweaponstopindividualtion() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8DE74))(this);
        }

        template <typename T = std::int32_t> static T get_floorlayermask() {
            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x1D8E38C))(0);
        }

        template <typename T = bool>
        T getfloorinfo(std::uintptr_t *_floorinfo) {
            return ((T(*)(pawn *, std::uintptr_t *))(
                il2cpp::il2cpp_base() + 0x1D8E528))(this, _floorinfo);
        }

        template <typename T = std::uintptr_t> T get_subweaponattachment() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8E71C))(this);
        }

        template <typename T = void>
        T subweaponattachmentchange(std::int32_t _weaponitemid,
                                    std::int32_t _actorid,
                                    std::uint32_t _skinid) {
            return ((T(*)(pawn *, std::int32_t, std::int32_t, std::uint32_t))(
                il2cpp::il2cpp_base() + 0x1D8E724))(this, _weaponitemid,
                                                    _actorid, _skinid);
        }

        template <typename T = void>
        T weaponattachmentchange(std::uintptr_t _info) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D8EBC0))(this, _info);
        }

        template <typename T = void>
        T weaponattachmentchange_1(std::int32_t _weaponitemid,
                                   il2cpp_list<std::uintptr_t> *_partinfolist,
                                   std::uint32_t _skinid, std::int32_t _actorid,
                                   std::int32_t _slotid,
                                   std::uint32_t _crosshairid,
                                   il2cpp_list<std::uint32_t> *_stickers) {
            return ((T(*)(pawn *, std::int32_t, il2cpp_list<std::uintptr_t> *,
                          std::uint32_t, std::int32_t, std::int32_t,
                          std::uint32_t, il2cpp_list<std::uint32_t> *))(
                il2cpp::il2cpp_base() + 0x1D8F3C4))(
                this, _weaponitemid, _partinfolist, _skinid, _actorid, _slotid,
                _crosshairid, _stickers);
        }

        template <typename T = bool>
        T ispartlistdifferent(il2cpp_list<std::uintptr_t> *_list_a,
                              il2cpp_list<std::uintptr_t> *_list_b) {
            return ((T(*)(pawn *, il2cpp_list<std::uintptr_t> *,
                          il2cpp_list<std::uintptr_t> *))(
                il2cpp::il2cpp_base() + 0x1D8F1BC))(this, _list_a, _list_b);
        }

        template <typename T = void> T resetforreconnect() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8F8E0))(this);
        }

        template <typename T = void>
        T onkillenemy(bool _isheadshotkill, std::int32_t _weaponid) {
            return ((T(*)(pawn *, bool, std::int32_t))(
                il2cpp::il2cpp_base() + 0x1D8FA28))(this, _isheadshotkill,
                                                    _weaponid);
        }

        template <typename T = void>
        T setaudiosystemrtpc(il2cpp_string *_temp, float _value) {
            return ((T(*)(pawn *, il2cpp_string *, float))(
                il2cpp::il2cpp_base() + 0x1D78984))(this, _temp, _value);
        }

        template <typename T = void> T onkillenemycountchanged() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D8FEA0))(this);
        }

        template <typename T = bool> T get_istakinglightingdamage() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D90070))(this);
        }

        template <typename T = void> T set_istakinglightingdamage(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D791F4))(
                this, _value);
        }

        template <typename T = bool> T needsimulatedplaycrouchanim() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D90078))(this);
        }

        template <typename T = bool>
        T checkinsidevehicle(il2cpp_vec3 _starttrace, il2cpp_vec3 _direction,
                             float _distance, std::uintptr_t _impactinfo) {
            return ((T(*)(pawn *, il2cpp_vec3, il2cpp_vec3, float,
                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x1D90148))(
                this, _starttrace, _direction, _distance, _impactinfo);
        }

        template <typename T = void> T physfightoff(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D9072C))(
                this, _deltatime);
        }

        template <typename T = void> T physzipline(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D907FC))(
                this, _deltatime);
        }

        template <typename T = void> T beginfightoff(il2cpp_vec3 _impluse) {
            return ((T(*)(pawn *, il2cpp_vec3))(il2cpp::il2cpp_base() +
                                                0x1D908CC))(this, _impluse);
        }

        template <typename T = void>
        T syncfpaniamtion(il2cpp_array<std::uintptr_t> *_cachedtrans) {
            return ((T(*)(pawn *, il2cpp_array<std::uintptr_t> *))(
                il2cpp::il2cpp_base() + 0x1D90A68))(this, _cachedtrans);
        }

        template <typename T = void>
        T onactivitefpanimationsync(bool _isactivate) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D90BB8))(
                this, _isactivate);
        }

        template <typename T = void> T equipsubweapon() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D90D08))(this);
        }

        template <typename T = void> T checkstartsubweaponfire() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D90DD0))(this);
        }

        template <typename T = void> T checkuselefthand() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D90E98))(this);
        }

        template <typename T = void> T resetmovespeed() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D90F60))(this);
        }

        template <typename T = void>
        T rawresetmovespeed(il2cpp_string *_statename, float _speed) {
            return ((T(*)(pawn *, il2cpp_string *, float))(
                il2cpp::il2cpp_base() + 0x1D91974))(this, _statename, _speed);
        }

        template <typename T = float>
        T getstatespeed(il2cpp_string *_statename, float _animcliptime) {
            return ((T(*)(pawn *, il2cpp_string *, float))(
                il2cpp::il2cpp_base() + 0x1D91B8C))(this, _statename,
                                                    _animcliptime);
        }

        template <typename T = void>
        T resetmovespeed_1(il2cpp_string *_statename, float _animcliptime) {
            return ((T(*)(pawn *, il2cpp_string *, float))(
                il2cpp::il2cpp_base() + 0x1D91840))(this, _statename,
                                                    _animcliptime);
        }

        template <typename T = bool> T isusingspecialweapon() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D91D60))(this);
        }

        template <typename T = il2cpp_vec3> T getthrowweaponstartposition() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D91F9C))(this);
        }

        template <typename T = il2cpp_quaternion>
        T getprojectilestartpositionoffsetrot() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D9212C))(this);
        }

        template <typename T = bool> T canopendoor() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D92448))(this);
        }

        template <typename T = bool> T switchweaponattach(bool _ishand) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D926F0))(
                this, _ishand);
        }

        template <typename T = bool> T checkclimb() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D927CC))(this);
        }

        template <typename T = void> T testdeadragdoll() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D9289C))(this);
        }

        template <typename T = void> T testragdollrevive() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D93C78))(this);
        }

        template <typename T = void> T setserverrelevant(bool _relevant) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D93DEC))(
                this, _relevant);
        }

        template <typename T = bool> T isleftweapon(std::int32_t _actorid) {
            return ((T(*)(pawn *, std::int32_t))(il2cpp::il2cpp_base() +
                                                 0x1D94370))(this, _actorid);
        }

        template <typename T = bool> T get_ischangingfiremodetransition() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D94448))(this);
        }

        template <typename T = bool>
        T shouldignorewhenequip(std::int32_t _actorid, std::int32_t _weaponid,
                                std::int32_t _slot) {
            return ((T(*)(pawn *, std::int32_t, std::int32_t, std::int32_t))(
                il2cpp::il2cpp_base() + 0x1D94450))(this, _actorid, _weaponid,
                                                    _slot);
        }

        template <typename T = void>
        T addignoreweaponwhenequip(std::int32_t _actorid,
                                   std::int32_t _weaponid, std::int32_t _slot) {
            return ((T(*)(pawn *, std::int32_t, std::int32_t, std::int32_t))(
                il2cpp::il2cpp_base() + 0x1D946A8))(this, _actorid, _weaponid,
                                                    _slot);
        }

        template <typename T = bool> T localplayercanusecurskill() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D94A0C))(this);
        }

        template <typename T = bool> T localplayercancancelcurskill() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D94DEC))(this);
        }

        template <typename T = bool> T get_isusingweaponskill() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D7E3C8))(this);
        }

        template <typename T = void> T set_isusingweaponskill(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D94EC4))(
                this, _value);
        }

        template <typename T = void>
        T onpretouchdoor(bool _isopen, float _inrotatetime) {
            return ((T(*)(pawn *, bool, float))(il2cpp::il2cpp_base() +
                                                0x1D950E0))(this, _isopen,
                                                            _inrotatetime);
        }

        template <typename T = bool> T get_isopendoor() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D95434))(this);
        }

        template <typename T = void> T set_ischangingfiremode(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D95484))(
                this, _value);
        }

        template <typename T = bool> T get_ischangingfiremode() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D9549C))(this);
        }

        template <typename T = bool>
        T checksetserverposition(il2cpp_vec3 _serverpostion) {
            return ((T(*)(pawn *, il2cpp_vec3))(
                il2cpp::il2cpp_base() + 0x1D954A4))(this, _serverpostion);
        }

        template <typename T = bool> T ininpickupitem(std::int32_t _itemid) {
            return ((T(*)(pawn *, std::int32_t))(il2cpp::il2cpp_base() +
                                                 0x1D9559C))(this, _itemid);
        }

        template <typename T = bool> T get_inpickup() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D95674))(this);
        }

        template <typename T = void> T onstartaircraft() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D9567C))(this);
        }

        template <typename T = bool> T get_enableanimatorlod() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D95788))(this);
        }

        template <typename T = bool> T get_iscanbequickknife() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D957D8))(this);
        }

        template <typename T = bool> T get_shouldcheckproneinwater() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D957E0))(this);
        }

        template <typename T = void> T resetrootmotion() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D957E8))(this);
        }

        template <typename T = void>
        T brsoundswitchgroupname(std::uint32_t _teamseatid) {
            return ((T(*)(pawn *, std::uint32_t))(
                il2cpp::il2cpp_base() + 0x1D51E40))(this, _teamseatid);
        }

        template <typename T = bool> T get_iscuringbymedicalstation() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D78ABC))(this);
        }

        template <typename T = void>
        T set_iscuringbymedicalstation(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D9594C))(
                this, _value);
        }

        template <typename T = void> T showmedicalstationcuringeffect() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D95954))(this);
        }

        template <typename T = void> T hidemedicalstationcuringeffect() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D78AC4))(this);
        }

        template <typename T = void> T playulteffect(std::uintptr_t _config) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D95BE4))(this, _config);
        }

        template <typename T = void> T stopulteffect() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D96630))(this);
        }

        template <typename T = void>
        T updatesprintlean(bool _islean, float _leanvalue) {
            return ((T(*)(pawn *, bool, float))(
                il2cpp::il2cpp_base() + 0x1D96990))(this, _islean, _leanvalue);
        }

        template <typename T = void> T set_showvest(std::uintptr_t _value) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D96AA0))(this, _value);
        }

        template <typename T = bool> T get_havevest() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D96AA4))(this);
        }

        template <typename T = void> T set_havevest(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D96AAC))(
                this, _value);
        }

        template <typename T = void> T resetrespawnphysicalstate() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D96AB4))(this);
        }

        template <typename T = void> T onrespawnplayer() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D96C9C))(this);
        }

        template <typename T = void> T ongodflagchange(bool _newflag) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D97014))(
                this, _newflag);
        }

        template <typename T = void> T cancelsave() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D970E4))(this);
        }

        template <typename T = bool> T iscancheckautochangeclip() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D971AC))(this);
        }

        template <typename T = il2cpp_vec3> T geteyeheight() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D972AC))(this);
        }

        template <typename T = bool> T isnearlyobstacle(float _length) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D976BC))(
                this, _length);
        }

        template <typename T = bool> T isneedresolveweaponjitter() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D97960))(this);
        }

        template <typename T = void> T onpreparation() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D97A30))(this);
        }

        template <typename T = float>
        T getdistancetopawn(std::uintptr_t _targetpos) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D97BC0))(this, _targetpos);
        }

        template <typename T = void> T pawnstandongroundwhenspawn() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D97EB0))(this);
        }

        template <typename T = bool> T gethasmultythrowweapon() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D97FE4))(this);
        }

        template <typename T = void> T refreshhasmultythrowweapon() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D96E9C))(this);
        }

        template <typename T = bool> T iscanbestick() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D980BC))(this);
        }

        template <typename T = void> T cancelpreparing() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D9818C))(this);
        }

        template <typename T = bool> T checkcaninteractivelevelobject() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D98340))(this);
        }

        template <typename T = bool> T ignoreradaredge() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D98438))(this);
        }

        template <typename T = il2cpp_vec3> T get_initpositionforradar() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D98508))(this);
        }

        template <typename T = void>
        T set_initpositionforradar(il2cpp_vec3 _value) {
            return ((T(*)(pawn *, il2cpp_vec3))(il2cpp::il2cpp_base() +
                                                0x1D98524))(this, _value);
        }

        template <typename T = il2cpp_quaternion> T get_initrotationforradar() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D98534))(this);
        }

        template <typename T = void>
        T set_initrotationforradar(il2cpp_quaternion _value) {
            return ((T(*)(pawn *, il2cpp_quaternion))(il2cpp::il2cpp_base() +
                                                      0x1D98548))(this, _value);
        }

        template <typename T = bool> T ignorefhjcheck() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D98560))(this);
        }

        template <typename T = std::uintptr_t> T get_modelcollider() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D98630))(this);
        }

        template <typename T = void>
        T setpawncolliderdata(std::uintptr_t _colliderdata) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D5290C))(this, _colliderdata);
        }

        template <typename T = void> T setcolliderenabled(bool _enabled) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D51CB8))(
                this, _enabled);
        }

        template <typename T = bool> T checkcolliderenabled() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D51AD4))(this);
        }

        template <typename T = float> T get_stepoffset() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D987E0))(this);
        }

        template <typename T = float> T get_radius() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D9881C))(this);
        }

        template <typename T = float> T get_height() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D98860))(this);
        }

        template <typename T = il2cpp_vec3> T get_centeroffset() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D988A4))(this);
        }

        template <typename T = void> T initcharactercontroller() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D5137C))(this);
        }

        template <typename T = bool> T get_hascharactercontroller() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D464BC))(this);
        }

        template <typename T = void> T initpawncharactercontroller() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D98944))(this);
        }

        template <typename T = std::uintptr_t> T get_cachedcharcontroller() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D464C4))(this);
        }

        template <typename T = bool> T get_hasbodycharactercontroller() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D98C14))(this);
        }

        template <typename T = std::uintptr_t> T get_bodycharactercontroller() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D98C1C))(this);
        }

        template <typename T = bool> T get_haslegcharactercontroller() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D99010))(this);
        }

        template <typename T = std::uintptr_t> T get_legcharactercontroller() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D99018))(this);
        }

        template <typename T = float> T get_standcharcontrollerheight() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D99484))(this);
        }

        template <typename T = float> T get_standcharcontrollerradius() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D9948C))(this);
        }

        template <typename T = float> T get_crouchcharcontrollerhight() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D99498))(this);
        }

        template <typename T = float> T get_slidecharcontrollerhight() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D994A0))(this);
        }

        template <typename T = float> T get_pronecharcontrollerhight() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D994A8))(this);
        }

        template <typename T = float> T get_pronecharcontrollerradius() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D994B0))(this);
        }

        template <typename T = float> T get_swimcharcontrollerhight() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D994BC))(this);
        }

        template <typename T = float> T get_graprushcharcontrollerhight() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D994C4))(this);
        }

        template <typename T = float> T get_goliathstandcharcontrollerheight() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D994CC))(this);
        }

        template <typename T = float> T get_goliathstandcharcontrollerradius() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D994D4))(this);
        }

        template <typename T = void>
        T setcharactercolliderheight(float _newheight) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D52B94))(
                this, _newheight);
        }

        template <typename T = void>
        T setcharactercolliderradius(float _radius) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D52D44))(
                this, _radius);
        }

        template <typename T = void> T resetcharactercolliderdata() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D994DC))(this);
        }

        template <typename T = float> T get_peripheralvision() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D996B0))(this);
        }

        template <typename T = void> T set_peripheralvision(float _value) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D996B8))(
                this, _value);
        }

        template <typename T = float> T get_sightradius() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D996C0))(this);
        }

        template <typename T = void> T set_sightradius(float _value) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D996C8))(
                this, _value);
        }

        template <typename T = float> T get_pronevalidcheckdistance() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D996D0))(this);
        }

        template <typename T = float> T get_ladderenterfromtoptime() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D996D8))(this);
        }

        template <typename T = float> T get_ladderclimbfromtoptime() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D996E0))(this);
        }

        template <typename T = bool> T get_allowdowntoladder() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D996E8))(this);
        }

        template <typename T = float> T get_ladderclimbtoptime() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D996F0))(this);
        }

        template <typename T = float> T get_pronevalidxangle() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D996F8))(this);
        }

        template <typename T = float> T get_pronevalidbodylength() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D99700))(this);
        }

        template <typename T = float> T get_pronevalidphysicscastradius() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D99708))(this);
        }

        template <typename T = float> T get_jumpmeleeminheight() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D99710))(this);
        }

        template <typename T = float> T get_gravity() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D99718))(this);
        }

        template <typename T = float> T get_jumplandheight() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D99720))(this);
        }

        template <typename T = float> T get_swimputweapontime() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D99728))(this);
        }

        template <typename T = float> T get_swimgetweapontime() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D99730))(this);
        }

        template <typename T = float> T get_swimlefthandlimitupwardangle() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D99738))(this);
        }

        template <typename T = float> T get_maxclimbclientforcemovedistance() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D99740))(this);
        }

        template <typename T = float> T get_crouchmovetostandtransitiontime() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D99748))(this);
        }

        template <typename T = float> T get_standmovetocrouchtransitiontime() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D99750))(this);
        }

        template <typename T = float> T get_prone1pmidstoptime() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D99758))(this);
        }

        template <typename T = float> T get_pronecrouchtranstiontime() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D99760))(this);
        }

        template <typename T = float> T get_standpronetranstiontime() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D99780))(this);
        }

        template <typename T = float> T get_recoverrotationspeed() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D99788))(this);
        }

        template <typename T = float> T get_recovermoverotationspeed() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D99790))(this);
        }

        template <typename T = float> T get_maxangleyleftdelta() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D99798))(this);
        }

        template <typename T = float> T get_maxangleyrightdelta() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D997A0))(this);
        }

        template <typename T = float> T get_maxanglepessnagerturndelta() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D997A8))(this);
        }

        template <typename T = float> T get_maxanglemoveturndelta() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D997B0))(this);
        }

        template <typename T = float> T get_crouchingeyeheight() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D73E74))(this);
        }

        template <typename T = float> T get_proneingeyeheight() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D73E6C))(this);
        }

        template <typename T = float> T get_landhardstandtime() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D997B8))(this);
        }

        template <typename T = float> T get_fallinglandtime() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D997C0))(this);
        }

        template <typename T = float> T get_dropdowntime() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D997C8))(this);
        }

        template <typename T = float> T get_ladderspeed() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D997D0))(this);
        }

        template <typename T = float> T get_verticalroationlimitmin() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D997D8))(this);
        }

        template <typename T = float> T get_verticalroationlimitmax() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D997E0))(this);
        }

        template <typename T = float> T get_reachtargettime() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D997E8))(this);
        }

        template <typename T = float> T getmaxforcesimulatedistance() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D997F0))(this);
        }

        template <typename T = float>
        T getmaxforcesimulatedistance_1(std::uintptr_t _serverstate) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D998DC))(this, _serverstate);
        }

        template <typename T = void> T initanim() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D999F8))(this);
        }

        template <typename T = void> T postinitanim() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D99BE4))(this);
        }

        template <typename T = bool> T get_useslowwalk() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D99EBC))(this);
        }

        template <typename T = void> T set_useslowwalk(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D99EC4))(
                this, _value);
        }

        template <typename T = bool> T get_iscurrentanimationactive() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D99ECC))(this);
        }

        template <typename T = void> T setanimationactive(bool _isactive) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D7939C))(
                this, _isactive);
        }

        template <typename T = void> T toggleanimationactive() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D9A384))(this);
        }

        template <typename T = void>
        T playanimationstatewithoffset(il2cpp_string *_statename,
                                       float _offsettime) {
            return ((T(*)(pawn *, il2cpp_string *, float))(
                il2cpp::il2cpp_base() + 0x1D9A468))(this, _statename,
                                                    _offsettime);
        }

        template <typename T = void>
        T fadetoanimstate(il2cpp_string *_statename, float _fadetime) {
            return ((T(*)(pawn *, il2cpp_string *, float))(
                il2cpp::il2cpp_base() + 0x1D9A5D8))(this, _statename,
                                                    _fadetime);
        }

        template <typename T = void>
        T fadetoanimstate_1(std::int32_t _paramid, float _fadetime) {
            return ((T(*)(pawn *, std::int32_t, float))(
                il2cpp::il2cpp_base() + 0x1D9A758))(this, _paramid, _fadetime);
        }

        template <typename T = void>
        T fadetoanimstate_2(std::int32_t _statenamehash, float _fadetime,
                            std::int32_t _layer, float _fixedtime) {
            return ((T(*)(pawn *, std::int32_t, float, std::int32_t, float))(
                il2cpp::il2cpp_base() + 0x1D9A8C8))(
                this, _statenamehash, _fadetime, _layer, _fixedtime);
        }

        template <typename T = bool>
        T isanimationintransition(std::int32_t _layerindex) {
            return ((T(*)(pawn *, std::int32_t))(il2cpp::il2cpp_base() +
                                                 0x1D9AA54))(this, _layerindex);
        }

        template <typename T = void>
        T resetanimatortrigger(std::int32_t _paramid) {
            return ((T(*)(pawn *, std::int32_t))(il2cpp::il2cpp_base() +
                                                 0x1D9ABB0))(this, _paramid);
        }

        template <typename T = void> T resetalltrigger() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D9AD00))(this);
        }

        template <typename T = void>
        T playanimation(il2cpp_string *_animname, float _speed,
                        bool _clearidle) {
            return ((T(*)(pawn *, il2cpp_string *, float, bool))(
                il2cpp::il2cpp_base() + 0x1D9AE44))(this, _animname, _speed,
                                                    _clearidle);
        }

        template <typename T = void>
        T playanimation_1(std::int32_t _animid, float _speed, bool _clearidle) {
            return ((T(*)(pawn *, std::int32_t, float, bool))(
                il2cpp::il2cpp_base() + 0x1D9B004))(this, _animid, _speed,
                                                    _clearidle);
        }

        template <typename T = void>
        T playsyncanimation(std::int32_t _animid, float _speed,
                            bool _clearidle) {
            return ((T(*)(pawn *, std::int32_t, float, bool))(
                il2cpp::il2cpp_base() + 0x1D9B1AC))(this, _animid, _speed,
                                                    _clearidle);
        }

        template <typename T = void>
        T playanimationresettrigger(std::int32_t _animid, float _speed,
                                    std::int32_t _resetid) {
            return ((T(*)(pawn *, std::int32_t, float, std::int32_t))(
                il2cpp::il2cpp_base() + 0x1D9B424))(this, _animid, _speed,
                                                    _resetid);
        }

        template <typename T = void>
        T playanimationresettriggerinner(il2cpp_string *_animname, float _speed,
                                         il2cpp_string *_resetname) {
            return ((T(*)(pawn *, il2cpp_string *, float, il2cpp_string *))(
                il2cpp::il2cpp_base() + 0x1D9B69C))(this, _animname, _speed,
                                                    _resetname);
        }

        template <typename T = void>
        T playanimationresettriggerinner_1(std::int32_t _animid, float _speed,
                                           std::int32_t _resetid) {
            return ((T(*)(pawn *, std::int32_t, float, std::int32_t))(
                il2cpp::il2cpp_base() + 0x1D9B868))(this, _animid, _speed,
                                                    _resetid);
        }

        template <typename T = void>
        T setanimationvalue(std::int32_t _paramid, float _inputvalue) {
            return ((T(*)(pawn *, std::int32_t, float))(
                il2cpp::il2cpp_base() + 0x1D9BA34))(this, _paramid,
                                                    _inputvalue);
        }

        template <typename T = void>
        T setanimationvalue_1(std::int32_t _paramid, bool _inputvalue) {
            return ((T(*)(pawn *, std::int32_t, bool))(
                il2cpp::il2cpp_base() + 0x1D83EE4))(this, _paramid,
                                                    _inputvalue);
        }

        template <typename T = void>
        T setsyncanimationvalue(std::int32_t _paramid, bool _inputvalue) {
            return ((T(*)(pawn *, std::int32_t, bool))(
                il2cpp::il2cpp_base() + 0x1D9BBC4))(this, _paramid,
                                                    _inputvalue);
        }

        template <typename T = void>
        T setanimationvalue_2(std::int32_t _paramid) {
            return ((T(*)(pawn *, std::int32_t))(il2cpp::il2cpp_base() +
                                                 0x1D9BDC0))(this, _paramid);
        }

        template <typename T = void>
        T setanimationvalue_3(std::int32_t _paramid, std::int32_t _inputvalue) {
            return ((T(*)(pawn *, std::int32_t, std::int32_t))(
                il2cpp::il2cpp_base() + 0x1D9BF30))(this, _paramid,
                                                    _inputvalue);
        }

        template <typename T = bool>
        T animationparamexist(il2cpp_string *_paramname) {
            return ((T(*)(pawn *, il2cpp_string *))(
                il2cpp::il2cpp_base() + 0x1D9C0C0))(this, _paramname);
        }

        template <typename T = void> T setbodystate(float _value) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D9C21C))(
                this, _value);
        }

        template <typename T = bool>
        T shouldswitchanimatorcontroller(std::uintptr_t _currentcomponent,
                                         std::uintptr_t _controller) {
            return ((T(*)(pawn *, std::uintptr_t, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D9C4E0))(this, _currentcomponent,
                                                    _controller);
        }

        template <typename T = bool>
        T shouldswitchanimatorcontroller_1(std::uintptr_t _controller,
                                           bool _firstpersonanimator) {
            return ((T(*)(pawn *, std::uintptr_t, bool))(
                il2cpp::il2cpp_base() + 0x1D9C63C))(this, _controller,
                                                    _firstpersonanimator);
        }

        template <typename T = void>
        T switchvehiclecontroller(std::uintptr_t _controller,
                                  bool _firstpersonanimator) {
            return ((T(*)(pawn *, std::uintptr_t, bool))(
                il2cpp::il2cpp_base() + 0x1D9C8B4))(this, _controller,
                                                    _firstpersonanimator);
        }

        template <typename T = il2cpp_string *> T getdefaultstatename() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D9C9D8))(this);
        }

        template <typename T = void>
        T rawswitchanimatorcontroller(std::uintptr_t _controller) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D9CB08))(this, _controller);
        }

        template <typename T = void>
        T switchanimatorcontroller(std::uintptr_t _controller,
                                   bool _firstpersonanimator) {
            return ((T(*)(pawn *, std::uintptr_t, bool))(
                il2cpp::il2cpp_base() + 0x1D9CE04))(this, _controller,
                                                    _firstpersonanimator);
        }

        template <typename T = void>
        T onswitchanimatorcontroller(bool _ischanged) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D9D308))(
                this, _ischanged);
        }

        template <typename T = void> T onreplaydeadanim() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D9D8F8))(this);
        }

        template <typename T = void> T onresetswimminganimatorstate() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D9D9C0))(this);
        }

        template <typename T = bool> T indistancetomaincamera(float _distance) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D9DA88))(
                this, _distance);
        }

        template <typename T = void>
        T playhitanim(std::uintptr_t _hitmotiondir,
                      std::uintptr_t _damagetype) {
            return ((T(*)(pawn *, std::uintptr_t, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D9DC88))(this, _hitmotiondir,
                                                    _damagetype);
        }

        template <typename T = bool> T hascloth() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D9E264))(this);
        }

        template <typename T = void> T initusecloth() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D51494))(this);
        }

        template <typename T = bool> T isusecloth() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D9E33C))(this);
        }

        template <typename T = void> T initcloth(std::uintptr_t _mesh) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D5D9F8))(this, _mesh);
        }

        template <typename T = void> T onrevelentsetcloth(bool _isrevelent) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D5FCDC))(
                this, _isrevelent);
        }

        template <typename T = void> T onclearcloth() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D58024))(this);
        }

        template <typename T = bool> T istpsfiremode() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D9E414))(this);
        }

        template <typename T = bool> T ishiddenbydieeffect() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D9E558))(this);
        }

        template <typename T = void> T sethiddenbydieeffect(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D9E628))(
                this, _value);
        }

        template <typename T = void> T addshadowbladeeffectself() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D9E6F8))(this);
        }

        template <typename T = void> T addshadowbladeeffectfriend() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D9E854))(this);
        }

        template <typename T = void> T addshadowbladeeffectenemy() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D9E9B0))(this);
        }

        template <typename T = void> T removeshadowbladeeffect() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D9EB0C))(this);
        }

        template <typename T = std::uintptr_t> T get_zerosocketroot() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D64FA8))(this);
        }

        template <typename T = void> T initzerosocketroot() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D9EC04))(this);
        }

        template <typename T = void> T setzerosocketrootenable(bool _benable) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D9F184))(
                this, _benable);
        }

        template <typename T = void> T clearzerosocketroot() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D576B4))(this);
        }

        template <typename T = void>
        T onopenaimsolvejitter(std::uintptr_t _currentweapon) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D9F514))(this, _currentweapon);
        }

        template <typename T = void> T stopsolvejitter() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D9F948))(this);
        }

        template <typename T = void>
        T oncloseaimsolvejitter(std::uintptr_t _currentweapon) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1D9FB34))(this, _currentweapon);
        }

        template <typename T = il2cpp_vec3> T getweaponoffset() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D9FE5C))(this);
        }

        template <typename T = float>
        static T getzeroweaponpendenthandlerybias() {
            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x1DA0078))(0);
        }

        template <typename T = std::uintptr_t>
        T get_currentzeroweaponpendenthandler() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DA0188))(this);
        }

        template <typename T = void>
        T addweaponpendent(std::uintptr_t _forcemove) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DA04FC))(this, _forcemove);
        }

        template <typename T = void> T resetweaponpendent() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DA0648))(this);
        }

        template <typename T = void> T updatezeroweaponpendenthandler() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D65068))(this);
        }

        template <typename T = void> T clearzeroweaponpendenthandler() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D57844))(this);
        }

        template <typename T = std::uintptr_t> T get_curclimbtype() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DA0794))(this);
        }

        template <typename T = void> T set_curclimbtype(std::uintptr_t _value) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1DA079C))(this, _value);
        }

        template <typename T = void> T set_climbupheight(float _value) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DA07A4))(
                this, _value);
        }

        template <typename T = float> T get_climbupheight() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DA07AC))(this);
        }

        template <typename T = void> T clearisclimbwall() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DA07B4))(this);
        }

        template <typename T = bool> T get_isclimbwall() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DA0888))(this);
        }

        template <typename T = void> T set_climbmantlewidth(float _value) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DA0890))(
                this, _value);
        }

        template <typename T = void> T physclimb(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DA08B8))(
                this, _deltatime);
        }

        template <typename T = void> T doclimbup() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DA0988))(this);
        }

        template <typename T = void> T initclimbover() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DA0FA8))(this);
        }

        template <typename T = bool> T candoclimbover(std::uintptr_t _destpos) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1DA12B8))(this, _destpos);
        }

        template <typename T = void> T doclimbover() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DA16E8))(this);
        }

        template <typename T = void> T playclimbupanimation(bool _issprinting) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1DA1E68))(
                this, _issprinting);
        }

        template <typename T = void>
        T playclimboveranimation(bool _issprinting) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1DA21B0))(
                this, _issprinting);
        }

        template <typename T = void> T endclimbanimation() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DA24F8))(this);
        }

        template <typename T = void> T playclimbanimation(bool _isspinting) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1DA25E4))(
                this, _isspinting);
        }

        template <typename T = void> T doclimb() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DA2908))(this);
        }

        template <typename T = bool> T canclimb() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DA2DE0))(this);
        }

        template <typename T = void> T resetclimbtrigger() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DA2FF4))(this);
        }

        template <typename T = void> T limitsimulatedclimbverticalspeed() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DA32F8))(this);
        }

        template <typename T = void>
        T limitsimualteclimbovereyeheight(float _deltay) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DA35FC))(
                this, _deltay);
        }

        template <typename T = void> T dophysclimbover(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DA3774))(
                this, _deltatime);
        }

        template <typename T = bool> T isendclimbover(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DA3F5C))(
                this, _deltatime);
        }

        template <typename T = void> T doendclimbover() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DA429C))(this);
        }

        template <typename T = void>
        T dophysclimbover_rootmotion(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DA46CC))(
                this, _deltatime);
        }

        template <typename T = void> T physclimbover(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DA49EC))(
                this, _deltatime);
        }

        template <typename T = void> T doendclimbup() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DA4B64))(this);
        }

        template <typename T = void> T physclimbup(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DA4C44))(
                this, _deltatime);
        }

        template <typename T = float> T get_currentfallingverticalspeed() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DA4DF4))(this);
        }

        template <typename T = float> T get_reachjumpingtoptime() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DA4DFC))(this);
        }

        template <typename T = bool> T get_isjumpingup() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DA4E04))(this);
        }

        template <typename T = bool> T get_reachjumpingtop() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DA4E0C))(this);
        }

        template <typename T = bool> T checkjumpfacewall() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DA4E14))(this);
        }

        template <typename T = bool> T checkstandinpawn() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DA52F0))(this);
        }

        template <typename T = bool> T checkjumpinclimb() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DA5410))(this);
        }

        template <typename T = bool> T canjump() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DA54EC))(this);
        }

        template <typename T = void> T limitjump() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DA5BA4))(this);
        }

        template <typename T = void> T limitjumphornzontalspeed() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DA5D6C))(this);
        }

        template <typename T = void> T dojump() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DA5F14))(this);
        }

        template <typename T = void>
        T dofalling(float _horspeed, float _verspeed) {
            return ((T(*)(pawn *, float, float))(
                il2cpp::il2cpp_base() + 0x1DA6274))(this, _horspeed, _verspeed);
        }

        template <typename T = void> T clearhorizontalvelocity() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DA641C))(this);
        }

        template <typename T = il2cpp_vec3>
        T newfallvelocity(il2cpp_vec3 _oldvelocity,
                          il2cpp_vec3 _oldacceleration, float _deltatime) {
            return ((T(*)(pawn *, il2cpp_vec3, il2cpp_vec3, float))(
                il2cpp::il2cpp_base() + 0x1DA64F4))(
                this, _oldvelocity, _oldacceleration, _deltatime);
        }

        template <typename T = void> T processairsteering(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DA6648))(
                this, _deltatime);
        }

        template <typename T = void> T physfallingreachtotop() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DA6B64))(this);
        }

        template <typename T = void> T physfalling(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DA6C44))(
                this, _deltatime);
        }

        template <typename T = void>
        T checkskyfly(bool _checkvalidfall, float _disttofloor) {
            return (
                (T(*)(pawn *, bool, float))(il2cpp::il2cpp_base() + 0x1DA7804))(
                this, _checkvalidfall, _disttofloor);
        }

        template <typename T = void> T checkfallingdown(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DA78E8))(
                this, _deltatime);
        }

        template <typename T = void> T fallingground(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DA7A18))(
                this, _deltatime);
        }

        template <typename T = void>
        T processfallinganimationparameter(float _deltatime, float _deltamove) {
            return ((T(*)(pawn *, float, float))(il2cpp::il2cpp_base() +
                                                 0x1DA7CE0))(this, _deltatime,
                                                             _deltamove);
        }

        template <typename T = void>
        T pushmovecharcontroller(il2cpp_vec3 _deltamove) {
            return ((T(*)(pawn *, il2cpp_vec3))(il2cpp::il2cpp_base() +
                                                0x1DA8328))(this, _deltamove);
        }

        template <typename T = void>
        T walkingcharcontrollermove(std::uintptr_t _deltamove) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DA8478))(this, _deltamove);
        }

        template <typename T = void> T physwalking(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DA8584))(
                this, _deltatime);
        }

        template <typename T = void>
        T checkstuckincollide(std::uintptr_t _deltamove) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DA9D38))(this, _deltamove);
        }

        template <typename T = void>
        T checkpositionnan(il2cpp_vec3 _deltamove, float _deltatime) {
            return ((T(*)(pawn *, il2cpp_vec3, float))(
                il2cpp::il2cpp_base() + 0x1DAA5CC))(this, _deltamove,
                                                    _deltatime);
        }

        template <typename T = float> T caclrampratio() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DAAD18))(this);
        }

        template <typename T = float> T calcmaxmovespeedscale() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DAB0A8))(this);
        }

        template <typename T = float> T calcphyswalkingmaxmovespeed() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DAB2EC))(this);
        }

        template <typename T = float>
        T calcphyswalkingmaxspeed(float _deltatime, il2cpp_vec3 _oldvelocity) {
            return ((T(*)(pawn *, float, il2cpp_vec3))(
                il2cpp::il2cpp_base() + 0x1DAB580))(this, _deltatime,
                                                    _oldvelocity);
        }

        template <typename T = float> T getmaxslopeverticalvelocity() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DAB79C))(this);
        }

        template <typename T = void>
        T calcslopeverticalvelocity(float _deltatime, float _currentspeed) {
            return ((T(*)(pawn *, float, float))(il2cpp::il2cpp_base() +
                                                 0x1DAB86C))(this, _deltatime,
                                                             _currentspeed);
        }

        template <typename T = void>
        T calcphyswalkingvelocity(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DABAD0))(
                this, _deltatime);
        }

        template <typename T = void>
        T checkvelocityforcesyncmove(il2cpp_vec3 _oldvelocity) {
            return ((T(*)(pawn *, il2cpp_vec3))(il2cpp::il2cpp_base() +
                                                0x1DAC220))(this, _oldvelocity);
        }

        template <typename T = il2cpp_vec3>
        T caclphyswalkingdeltamove(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DA8BC8))(
                this, _deltatime);
        }

        template <typename T = void>
        T processfacewallshaking(float _delattime, std::uintptr_t _deltamove) {
            return ((T(*)(pawn *, float, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DAC3F4))(this, _delattime,
                                                    _deltamove);
        }

        template <typename T = void>
        T processwalkingslidemovevertical(std::uintptr_t _deltamove) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DAC4D8))(this, _deltamove);
        }

        template <typename T = void>
        T calcstanduponpawnslidevec(float _deltatime, std::uintptr_t _deltamove,
                                    std::uintptr_t _slidevec) {
            return ((T(*)(pawn *, float, std::uintptr_t, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DAC5A8))(this, _deltatime,
                                                    _deltamove, _slidevec);
        }

        template <typename T = void>
        T processwalkingfacewallmove(float _deltatime,
                                     std::uintptr_t _deltamove) {
            return ((T(*)(pawn *, float, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DAC89C))(this, _deltatime,
                                                    _deltamove);
        }

        template <typename T = void>
        T processwalkingslidemove(float _deltatime, std::uintptr_t _deltamove) {
            return ((T(*)(pawn *, float, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DACC78))(this, _deltatime,
                                                    _deltamove);
        }

        template <typename T = void>
        T calcwalkingonslope(std::uintptr_t _slidevec,
                             std::uintptr_t _deltamove) {
            return ((T(*)(pawn *, std::uintptr_t, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DAD0C4))(this, _slidevec,
                                                    _deltamove);
        }

        template <typename T = bool> T checkpronevalidrotation(float _angley) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DAD728))(
                this, _angley);
        }

        template <typename T = void>
        T pronebackmovedeltamove(float _deltatime, std::uintptr_t _deltamove,
                                 std::uintptr_t _isblock) {
            return ((T(*)(pawn *, float, std::uintptr_t, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DAE110))(this, _deltatime,
                                                    _deltamove, _isblock);
        }

        template <typename T = void>
        T processphyswalkingdeltamove(float _deltatime,
                                      std::uintptr_t _deltamove) {
            return ((T(*)(pawn *, float, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DAE900))(this, _deltatime,
                                                    _deltamove);
        }

        template <typename T = void>
        T trysliplowwall(float _deltatime, il2cpp_vec3 _prelocation) {
            return ((T(*)(pawn *, float, il2cpp_vec3))(
                il2cpp::il2cpp_base() + 0x1DA98A8))(this, _deltatime,
                                                    _prelocation);
        }

        template <typename T = void>
        T physwalkingfacewalloptimize(float _deltatime,
                                      il2cpp_vec3 _prelocation) {
            return ((T(*)(pawn *, float, il2cpp_vec3))(
                il2cpp::il2cpp_base() + 0x1DA8EB0))(this, _deltatime,
                                                    _prelocation);
        }

        template <typename T = void>
        T processmoveanimationparameter(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DAEBB0))(
                this, _deltatime);
        }

        template <typename T = bool> T processfalling(il2cpp_vec3 _oldpos) {
            return ((T(*)(pawn *, il2cpp_vec3))(il2cpp::il2cpp_base() +
                                                0x1DAF3DC))(this, _oldpos);
        }

        template <typename T = bool> T isfixcontinuestandonpawn() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DAF588))(this);
        }

        template <typename T = void> T processstandonpawn(il2cpp_vec3 _oldpos) {
            return ((T(*)(pawn *, il2cpp_vec3))(il2cpp::il2cpp_base() +
                                                0x1DAF658))(this, _oldpos);
        }

        template <typename T = void>
        T processground(il2cpp_vec3 _oldpos, float _deltatime) {
            return ((T(*)(pawn *, il2cpp_vec3, float))(
                il2cpp::il2cpp_base() + 0x1DAFB44))(this, _oldpos, _deltatime);
        }

        template <typename T = float> T getdeltamoveheight(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DAFC88))(
                this, _deltatime);
        }

        template <typename T = void> T dowalkingtofalling(il2cpp_vec3 _oldpos) {
            return ((T(*)(pawn *, il2cpp_vec3))(il2cpp::il2cpp_base() +
                                                0x1DAFD64))(this, _oldpos);
        }

        template <typename T = void> T initlocalplayerrecoveroverlap() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D98AAC))(this);
        }

        template <typename T = bool> T enableoptimizetransform() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DAFED4))(this);
        }

        template <typename T = bool> T instaticidle() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DAFFE4))(this);
        }

        template <typename T = il2cpp_vec3> T get_lastcchitnormal() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DB01EC))(this);
        }

        template <typename T = il2cpp_vec3> T get_lastcchitpoint() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DB0204))(this);
        }

        template <typename T = il2cpp_vec3> T get_lastcchitwallpoint() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DB0220))(this);
        }

        template <typename T = bool> T get_isstanduponpawn() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DA53E0))(this);
        }

        template <typename T = bool> T get_lastcchitceil() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DB023C))(this);
        }

        template <typename T = il2cpp_vec3> T get_lastceilcchitnormal() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DB0244))(this);
        }

        template <typename T = il2cpp_vec3> T get_lastceilcchitpoint() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DB0260))(this);
        }

        template <typename T = bool> T isgrounded() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D69A40))(this);
        }

        template <typename T = bool> T issided() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4536C))(this);
        }

        template <typename T = bool> T isceiled() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D69B1C))(this);
        }

        template <typename T = bool> T ishitpawn() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DB027C))(this);
        }

        template <typename T = bool> T ishitstaticactor() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DB0394))(this);
        }

        template <typename T = bool> T checkstandonpawn(std::uintptr_t _hit) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1DB04AC))(this, _hit);
        }

        template <typename T = void>
        T oncontrollercolliderhit(std::uintptr_t _hit) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1DB0730))(this, _hit);
        }

        template <typename T = void>
        T checkpassthroughwall(il2cpp_vec3 _prelocation) {
            return ((T(*)(pawn *, il2cpp_vec3))(il2cpp::il2cpp_base() +
                                                0x1DB1330))(this, _prelocation);
        }

        template <typename T = void>
        T checkfallingpassthroughwall(il2cpp_vec3 _prelocation) {
            return ((T(*)(pawn *, il2cpp_vec3))(il2cpp::il2cpp_base() +
                                                0x1DB1614))(this, _prelocation);
        }

        template <typename T = bool> T checkcliff(il2cpp_vec3 _inhitnormal) {
            return ((T(*)(pawn *, il2cpp_vec3))(il2cpp::il2cpp_base() +
                                                0x1DA5128))(this, _inhitnormal);
        }

        template <typename T = void> T onstateend() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DB1748))(this);
        }

        template <typename T = void>
        T onphysicsstatechanged(std::uintptr_t _prestate,
                                std::uintptr_t _curstate) {
            return ((T(*)(pawn *, std::uintptr_t, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DB1810))(this, _prestate, _curstate);
        }

        template <typename T = void>
        T onphyswalkingchangedprocessbodystate(std::uintptr_t _prestate,
                                               std::uintptr_t _curstate) {
            return ((T(*)(pawn *, std::uintptr_t, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DB1D08))(this, _prestate, _curstate);
        }

        template <typename T = void>
        T onphyswalkingchanged(std::uintptr_t _prestate,
                               std::uintptr_t _curstate) {
            return ((T(*)(pawn *, std::uintptr_t, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DB1E1C))(this, _prestate, _curstate);
        }

        template <typename T = void>
        T onphysfightoffchanged(std::uintptr_t _prestate,
                                std::uintptr_t _curstate) {
            return ((T(*)(pawn *, std::uintptr_t, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DB2028))(this, _prestate, _curstate);
        }

        template <typename T = void>
        T onphysfallingchanged(std::uintptr_t _prestate,
                               std::uintptr_t _curstate) {
            return ((T(*)(pawn *, std::uintptr_t, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DB2380))(this, _prestate, _curstate);
        }

        template <typename T = void>
        T onphysgravityspikeschanged(std::uintptr_t _prestate,
                                     std::uintptr_t _curstate) {
            return ((T(*)(pawn *, std::uintptr_t, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DB2544))(this, _prestate, _curstate);
        }

        template <typename T = void>
        T onphysslidetacklechanged(std::uintptr_t _prestate,
                                   std::uintptr_t _curstate) {
            return ((T(*)(pawn *, std::uintptr_t, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DB2704))(this, _prestate, _curstate);
        }

        template <typename T = void>
        T onphysclimbchagned(std::uintptr_t _prestate,
                             std::uintptr_t _curstate) {
            return ((T(*)(pawn *, std::uintptr_t, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DB2808))(this, _prestate, _curstate);
        }

        template <typename T = void>
        T onphysclimboverchagned(std::uintptr_t _prestate,
                                 std::uintptr_t _curstate) {
            return ((T(*)(pawn *, std::uintptr_t, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DB2970))(this, _prestate, _curstate);
        }

        template <typename T = void>
        T onphysclimbupchagned(std::uintptr_t _prestate,
                               std::uintptr_t _curstate) {
            return ((T(*)(pawn *, std::uintptr_t, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DB2B30))(this, _prestate, _curstate);
        }

        template <typename T = void>
        T onphysladderchagned(std::uintptr_t _prestate,
                              std::uintptr_t _curstate) {
            return ((T(*)(pawn *, std::uintptr_t, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DB2CFC))(this, _prestate, _curstate);
        }

        template <typename T = void>
        T onphysgraprushchagned(std::uintptr_t _prestate,
                                std::uintptr_t _curstate) {
            return ((T(*)(pawn *, std::uintptr_t, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DB3308))(this, _prestate, _curstate);
        }

        template <typename T = void>
        T onphysupwardlaunchchagned(std::uintptr_t _prestate,
                                    std::uintptr_t _curstate) {
            return ((T(*)(pawn *, std::uintptr_t, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DB3428))(this, _prestate, _curstate);
        }

        template <typename T = void>
        T onphyssprintchanged(std::uintptr_t _prestate,
                              std::uintptr_t _curstate) {
            return ((T(*)(pawn *, std::uintptr_t, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DB354C))(this, _prestate, _curstate);
        }

        template <typename T = void>
        T onphysrollchanged(std::uintptr_t _prestate,
                            std::uintptr_t _curstate) {
            return ((T(*)(pawn *, std::uintptr_t, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DB3658))(this, _prestate, _curstate);
        }

        template <typename T = void> T physdriving(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DB375C))(
                this, _deltatime);
        }

        template <typename T = void>
        T physplateformvehiclemoving(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DB385C))(
                this, _deltatime);
        }

        template <typename T = void> T physboarding(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DB3F18))(
                this, _deltatime);
        }

        template <typename T = void> T physnavmeshmoving(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DB3FE8))(
                this, _deltatime);
        }

        template <typename T = void> T physskydiving(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DB40B8))(
                this, _deltatime);
        }

        template <typename T = void> T physswimming(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DB4188))(
                this, _deltatime);
        }

        template <typename T = void> T physroll(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DB4258))(
                this, _deltatime);
        }

        template <typename T = void> T physsprint(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DB4E4C))(
                this, _deltatime);
        }

        template <typename T = void>
        T endphysicsprint(float _deltatime, bool _attack) {
            return ((T(*)(pawn *, float, bool))(
                il2cpp::il2cpp_base() + 0x1DB53AC))(this, _deltatime, _attack);
        }

        template <typename T = void> T physfollowpath(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DB54E0))(
                this, _deltatime);
        }

        template <typename T = void> T physrotatearoundaxis(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DB56A0))(
                this, _deltatime);
        }

        template <typename T = void> T startphysrotatearoundaxis() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DB6060))(this);
        }

        template <typename T = void> T stopphysrotatearoundaxis() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DB616C))(this);
        }

        template <typename T = void> T startremotecontrol() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DB6244))(this);
        }

        template <typename T = bool> T endremotecontrol() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DB631C))(this);
        }

        template <typename T = bool> T inremotecontrol() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DB6414))(this);
        }

        template <typename T = void> T physremotecontrol(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DB64F0))(
                this, _deltatime);
        }

        template <typename T = void> T physgraprush(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DB65C0))(
                this, _deltatime);
        }

        template <typename T = void> T physupwardlaunch(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DB66AC))(
                this, _deltatime);
        }

        template <typename T = void> T physladder(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DB6798))(
                this, _deltatime);
        }

        template <typename T = void> T physslidetackle(float _deltatime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DB68B0))(
                this, _deltatime);
        }

        template <typename T = void>
        T charcontrollermove(il2cpp_vec3 _deltamove) {
            return ((T(*)(pawn *, il2cpp_vec3))(il2cpp::il2cpp_base() +
                                                0x1DB7608))(this, _deltamove);
        }

        template <typename T = void> T requestchangemovestate() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DB7758))(this);
        }

        template <typename T = void> T standup(bool _immediately, bool _force) {
            return ((T(*)(pawn *, bool, bool))(
                il2cpp::il2cpp_base() + 0x1D59604))(this, _immediately, _force);
        }

        template <typename T = void> T crouchforcestoptransition() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DB7820))(this);
        }

        template <typename T = bool> T cancrouch() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DB7900))(this);
        }

        template <typename T = void>
        T startcrouch(bool _immediately, bool _needplayanim, bool _force,
                      bool _componentforce) {
            return ((T(*)(pawn *, bool, bool, bool, bool))(
                il2cpp::il2cpp_base() + 0x1DB7C24))(
                this, _immediately, _needplayanim, _force, _componentforce);
        }

        template <typename T = bool> T canuncrouch() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D757D8))(this);
        }

        template <typename T = void>
        T endcrouch(bool _immediately, bool _seteyeheightinimmediately,
                    bool _force) {
            return ((T(*)(pawn *, bool, bool, bool))(il2cpp::il2cpp_base() +
                                                     0x1DB7FE4))(
                this, _immediately, _seteyeheightinimmediately, _force);
        }

        template <typename T = void> T serverstartcrouch() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DB82AC))(this);
        }

        template <typename T = void> T setpronestateandrquest(bool _isprone) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1DB83D8))(
                this, _isprone);
        }

        template <typename T = void> T proneforcestoptransition() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DB84F4))(this);
        }

        template <typename T = void> T changelocalaabb(std::uintptr_t _aabb) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1DB85D4))(this, _aabb);
        }

        template <typename T = void> T startprone(bool _immediately) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1DB8A3C))(
                this, _immediately);
        }

        template <typename T = bool> T canunprone() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DA5AB8))(this);
        }

        template <typename T = void>
        T endprone(bool _immediately, bool _seteyeheightinimmediately,
                   bool _needplayanim) {
            return ((T(*)(pawn *, bool, bool, bool))(il2cpp::il2cpp_base() +
                                                     0x1DB8E10))(
                this, _immediately, _seteyeheightinimmediately, _needplayanim);
        }

        template <typename T = bool> T isincrouchpronetransition() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DB90B0))(this);
        }

        template <typename T = bool> T canprone() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DB91CC))(this);
        }

        template <typename T = void> T serverforcestartprone() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DB92E4))(this);
        }

        template <typename T = void> T serverforceendprone() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DB93F4))(this);
        }

        template <typename T = void> T serverforcestartcrouch() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DB951C))(this);
        }

        template <typename T = void> T serverforceendcrouch() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DB963C))(this);
        }

        template <typename T = void>
        T syncdirection(il2cpp_vec3 _simulatedirection, bool _bforcesync) {
            return ((T(*)(pawn *, il2cpp_vec3, bool))(
                il2cpp::il2cpp_base() + 0x1DB9754))(this, _simulatedirection,
                                                    _bforcesync);
        }

        template <typename T = unsigned char> T getsyncextrabyte() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DB9844))(this);
        }

        template <typename T = std::int32_t> T getleftmovecount() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DB9B80))(this);
        }

        template <typename T = std::uintptr_t> T get_avatarcomposer() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DB9C50))(this);
        }

        template <typename T = il2cpp_list<std::uintptr_t> *>
        T getrenderers(std::uintptr_t _type) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1DB892C))(this, _type);
        }

        template <typename T = il2cpp_list<std::uintptr_t> *>
        T getrenderers_1(il2cpp_array<std::uintptr_t> *_types) {
            return ((T(*)(pawn *, il2cpp_array<std::uintptr_t> *))(
                il2cpp::il2cpp_base() + 0x1DB9C68))(this, _types);
        }

        template <typename T = void>
        T pushinterimrenderer(il2cpp_array<std::uintptr_t> *_inrenderer) {
            return ((T(*)(pawn *, il2cpp_array<std::uintptr_t> *))(
                il2cpp::il2cpp_base() + 0x1DB9E04))(this, _inrenderer);
        }

        template <typename T = void>
        T removerenderer(il2cpp_array<std::uintptr_t> *_inrenderer) {
            return ((T(*)(pawn *, il2cpp_array<std::uintptr_t> *))(
                il2cpp::il2cpp_base() + 0x1DBA914))(this, _inrenderer);
        }

        template <typename T = void> T refreshallrenderer() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DBA33C))(this);
        }

        template <typename T = void> T refreshpawnrenderer() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DBAC68))(this);
        }

        template <typename T = void>
        T refreshindividuationrenderers(il2cpp_list<std::uintptr_t> *_list) {
            return ((T(*)(pawn *, il2cpp_list<std::uintptr_t> *))(
                il2cpp::il2cpp_base() + 0x1DBB104))(this, _list);
        }

        template <typename T = void> T refreshbagrenderer() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DBB220))(this);
        }

        template <typename T = void> T refreshvestrenderer() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DBB424))(this);
        }

        template <typename T = void> T refreshweaponrenderer() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DBB5D0))(this);
        }

        template <typename T = void> T refreshbagweaponrenderer() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DBB888))(this);
        }

        template <typename T = void> T refreshskydivingpendantrenderer() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DBBA44))(this);
        }

        template <typename T = void>
        T refreshrenderer(std::uintptr_t _type,
                          il2cpp_list<std::uintptr_t> *_renderers) {
            return ((
                T(*)(pawn *, std::uintptr_t, il2cpp_list<std::uintptr_t> *))(
                il2cpp::il2cpp_base() + 0x1DBBB18))(this, _type, _renderers);
        }

        template <typename T = void> T onrendererchange() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DBBC54))(this);
        }

        template <typename T = void> T setpawndefaultstate(bool _enable) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1D44560))(
                this, _enable);
        }

        template <typename T = void>
        T clearpawndefaultstate(std::uintptr_t _mesh) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D74BBC))(this, _mesh);
        }

        template <typename T = bool> T enablegpuskin() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DBBD4C))(this);
        }

        template <typename T = void>
        T setpartvisible(il2cpp_string *_partname, bool _visible) {
            return ((T(*)(pawn *, il2cpp_string *, bool))(
                il2cpp::il2cpp_base() + 0x1DBBE1C))(this, _partname, _visible);
        }

        template <typename T = void>
        T changepartmaterial(il2cpp_array<std::uintptr_t> *_partnames,
                             std::int32_t _matassetid) {
            return ((T(*)(pawn *, il2cpp_array<std::uintptr_t> *,
                          std::int32_t))(il2cpp::il2cpp_base() + 0x1DBC050))(
                this, _partnames, _matassetid);
        }

        template <typename T = void>
        T changetemppartmaterial(il2cpp_array<std::uintptr_t> *_partnames,
                                 std::int32_t _matassetid) {
            return ((T(*)(pawn *, il2cpp_array<std::uintptr_t> *,
                          std::int32_t))(il2cpp::il2cpp_base() + 0x1DBC248))(
                this, _partnames, _matassetid);
        }

        template <typename T = void> T onweaponattachmentloadcomplete() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DBC440))(this);
        }

        template <typename T = bool> T getweaponhiddenstate() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DBC53C))(this);
        }

        template <typename T = void> T clearcurrentweaponattachment() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DBC6B4))(this);
        }

        template <typename T = void> T clearcurrentsubweaponattachment() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DBCA94))(this);
        }

        template <typename T = void>
        T createweaponattachment(std::uintptr_t _info) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1DBCCD4))(this, _info);
        }

        template <typename T = void>
        T createsubweaponattachment(std::uintptr_t _info) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1DBD038))(this, _info);
        }

        template <typename T = il2cpp_array<std::uintptr_t> *>
        T getbagweapon() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DBD2F0))(this);
        }

        template <typename T = il2cpp_array<std::uintptr_t> *>
        T getbagweaponrenderers() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DBD3C0))(this);
        }

        template <typename T = void> T setbackweaponhidden(bool _ishidden) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1DBD490))(
                this, _ishidden);
        }

        template <typename T = void> T refreshweaponvisible() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D5FA14))(this);
        }

        template <typename T = void> T setweaponhidden(bool _ishidden) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1DBD560))(
                this, _ishidden);
        }

        template <typename T = void>
        T onsubweapondeactivate(std::uintptr_t _weapon) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1DBD7A8))(this, _weapon);
        }

        template <typename T = void> T deactivatesubweapon() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DBD878))(this);
        }

        template <typename T = void> T deactivatesubweaponattachment() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D4A754))(this);
        }

        template <typename T = bool> T isactivesubweaponattachment() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DBD958))(this);
        }

        template <typename T = bool> T hasweapontoswitch(std::uintptr_t _type) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1DBDB3C))(this, _type);
        }

        template <typename T = bool>
        T hasweapontoswitch_1(std::int32_t _itemid, unsigned char _slot,
                              std::int32_t _actorid) {
            return ((T(*)(pawn *, std::int32_t, unsigned char, std::int32_t))(
                il2cpp::il2cpp_base() + 0x1DBDCF4))(this, _itemid, _slot,
                                                    _actorid);
        }

        template <typename T = bool>
        T checkputdownthrowsubweapon(std::int32_t _itemid) {
            return ((T(*)(pawn *, std::int32_t))(il2cpp::il2cpp_base() +
                                                 0x1DBDF64))(this, _itemid);
        }

        template <typename T = void> T tryswitchweapon(std::uintptr_t _type) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1DBE1D4))(this, _type);
        }

        template <typename T = std::uintptr_t>
        T getswitchweapon(std::int32_t _itemid, unsigned char _slot,
                          std::int32_t _actorid, std::int32_t _itemlevel,
                          std::uint32_t _skinid) {
            return ((T(*)(pawn *, std::int32_t, unsigned char, std::int32_t,
                          std::int32_t,
                          std::uint32_t))(il2cpp::il2cpp_base() + 0x1DBEAF0))(
                this, _itemid, _slot, _actorid, _itemlevel, _skinid);
        }

        template <typename T = void>
        T forceswitchweapondirectly(std::int32_t _itemid, unsigned char _slot,
                                    std::int32_t _actorid,
                                    std::int32_t _itemlevel,
                                    std::uint32_t _skinid) {
            return ((T(*)(pawn *, std::int32_t, unsigned char, std::int32_t,
                          std::int32_t,
                          std::uint32_t))(il2cpp::il2cpp_base() + 0x1DBEE34))(
                this, _itemid, _slot, _actorid, _itemlevel, _skinid);
        }

        template <typename T = void>
        T tryswitchweapon_1(std::int32_t _itemid, unsigned char _slot,
                            std::int32_t _actorid, std::int32_t _itemlevel,
                            std::uint32_t _skinid, bool _isserverdata) {
            return ((T(*)(pawn *, std::int32_t, unsigned char, std::int32_t,
                          std::int32_t, std::uint32_t, bool))(
                il2cpp::il2cpp_base() + 0x1DBF96C))(this, _itemid, _slot,
                                                    _actorid, _itemlevel,
                                                    _skinid, _isserverdata);
        }

        template <typename T = bool> T get_isweaponswitching() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DB92DC))(this);
        }

        template <typename T = void> T set_isweaponswitching(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1DBFB44))(
                this, _value);
        }

        template <typename T = bool> T canchangeweapon() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DBFB4C))(this);
        }

        template <typename T = bool> T canchangethrowweapon() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DBFDC4))(this);
        }

        template <typename T = void> T onpretryswitchweapon() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DBF2F0))(this);
        }

        template <typename T = void>
        T tryswitchweapon_2(std::uintptr_t _weapon, bool _isserverntfweapon) {
            return ((T(*)(pawn *, std::uintptr_t, bool))(
                il2cpp::il2cpp_base() + 0x1DBE5D8))(this, _weapon,
                                                    _isserverntfweapon);
        }

        template <typename T = bool>
        T checkswitchweapon(bool _isserverntfweapon) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1DC06F0))(
                this, _isserverntfweapon);
        }

        template <typename T = bool>
        T ultweaponusingcheck(std::uintptr_t _toweapon) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1DC039C))(this, _toweapon);
        }

        template <typename T = bool> T doswitchweapon() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DBF43C))(this);
        }

        template <typename T = void> T clearpendingaction() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6FDC0))(this);
        }

        template <typename T = bool> T cancelswitchweapon() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC0C70))(this);
        }

        template <typename T = bool> T pulloutweapon() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC0E64))(this);
        }

        template <typename T = void> T checkgiveweaponattachmentinrespawn() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC0F4C))(this);
        }

        template <typename T = void> T giveweaponattachment() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D75900))(this);
        }

        template <typename T = bool>
        T needcreateweaponattachment(std::int32_t _wantweaponid) {
            return ((T(*)(pawn *, std::int32_t))(
                il2cpp::il2cpp_base() + 0x1D8EFDC))(this, _wantweaponid);
        }

        template <typename T = bool>
        T needcreatesubweaponattachment(std::int32_t _wantweaponid) {
            return ((T(*)(pawn *, std::int32_t))(
                il2cpp::il2cpp_base() + 0x1D8E9E0))(this, _wantweaponid);
        }

        template <typename T = void> T giveweapon_2() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC10BC))(this);
        }

        template <typename T = void> T onweaponchanged() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC1184))(this);
        }

        template <typename T = void> T onsubweaponchanged() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC1B20))(this);
        }

        template <typename T = void>
        T setdiscarditeminfo(std::uintptr_t _data) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1DC1DEC))(this, _data);
        }

        template <typename T = void> T activediscarditem() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC169C))(this);
        }

        template <typename T = void>
        T addactiveweaponnextstatebyitemid(std::int32_t _weaponitemid,
                                           std::uintptr_t _defaultstate) {
            return ((T(*)(pawn *, std::int32_t, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DC1F24))(this, _weaponitemid,
                                                    _defaultstate);
        }

        template <typename T = void>
        T onpreweaponactive(std::uintptr_t _activeweapon) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DC208C))(this, _activeweapon);
        }

        template <typename T = void>
        T onweaponassetloadcomplete(std::int32_t _actorid, std::int32_t _itemid,
                                    std::int32_t _meshid, bool _ismeshid3p) {
            return ((T(*)(pawn *, std::int32_t, std::int32_t, std::int32_t,
                          bool))(il2cpp::il2cpp_base() + 0x1DC23D8))(
                this, _actorid, _itemid, _meshid, _ismeshid3p);
        }

        template <typename T = void>
        T onweaponattachmentdeactive(std::uintptr_t _mesh) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1DC24C8))(this, _mesh);
        }

        template <typename T = void> T onweaponattachmentactive() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC2598))(this);
        }

        template <typename T = void> T onsubweaponattachmentactive() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC2794))(this);
        }

        template <typename T = void>
        T onweapondestroy(std::int32_t _actorid, std::int32_t _itemid,
                          unsigned char _slot) {
            return ((T(*)(pawn *, std::int32_t, std::int32_t, unsigned char))(
                il2cpp::il2cpp_base() + 0x1DC2868))(this, _actorid, _itemid,
                                                    _slot);
        }

        template <typename T = void> T onweaponactivate() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC2954))(this);
        }

        template <typename T = void> T onweapondeactive(std::uintptr_t _mesh) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1DC2C5C))(this, _mesh);
        }

        template <typename T = void>
        T onweaponbeginstate(std::uintptr_t _statetype) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DC2D2C))(this, _statetype);
        }

        template <typename T = void>
        T onweaponendstate(std::uintptr_t _statetype) {
            return ((T(*)(pawn *, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DC2E94))(this, _statetype);
        }

        template <typename T = void> T endbagweaponprocessing() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC2FE4))(this);
        }

        template <typename T = void> T addhighalertpanwid(std::uint32_t _id) {
            return ((T(*)(pawn *, std::uint32_t))(il2cpp::il2cpp_base() +
                                                  0x1DC30AC))(this, _id);
        }

        template <typename T = void>
        T removehighalertpanwid(std::uint32_t _id) {
            return ((T(*)(pawn *, std::uint32_t))(il2cpp::il2cpp_base() +
                                                  0x1DC31F4))(this, _id);
        }

        template <typename T = void> T removeallhighalertpanwid() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC333C))(this);
        }

        template <typename T = bool> T get_needdelaytriggerads() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC3440))(this);
        }

        template <typename T = void> T set_needdelaytriggerads(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1DC3448))(
                this, _value);
        }

        template <typename T = bool> T get_resetaiminput() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC3450))(this);
        }

        template <typename T = void> T set_resetaiminput(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1DC3458))(
                this, _value);
        }

        template <typename T = bool> T get_resetadsinput() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC3554))(this);
        }

        template <typename T = void> T set_resetadsinput(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1DC355C))(
                this, _value);
        }

        template <typename T = bool> T get_resetfireinput() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC3574))(this);
        }

        template <typename T = void> T set_resetfireinput(bool _value) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1DC357C))(
                this, _value);
        }

        template <typename T = void> T resetinput(bool _flag) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1DA45CC))(
                this, _flag);
        }

        template <typename T = void> T startfire() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC368C))(this);
        }

        template <typename T = void> T stopfire() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC3824))(this);
        }

        template <typename T = void> T subweaponstopfire() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC3A6C))(this);
        }

        template <typename T = bool> T canfire() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC3C00))(this);
        }

        template <typename T = void> T startsecondaryfire() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC44A4))(this);
        }

        template <typename T = void> T stopsecondaryfire() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC4674))(this);
        }

        template <typename T = void>
        T thirdpersonstartfire(std::int32_t _infirecompindex, bool _isaiming,
                               bool _issingleshot, std::int32_t _aommocount,
                               bool _blefthandweapon) {
            return ((T(*)(pawn *, std::int32_t, bool, bool, std::int32_t,
                          bool))(il2cpp::il2cpp_base() + 0x1DC479C))(
                this, _infirecompindex, _isaiming, _issingleshot, _aommocount,
                _blefthandweapon);
        }

        template <typename T = void> T switchfiremode() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC4934))(this);
        }

        template <typename T = bool> T isaiming() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D59804))(this);
        }

        template <typename T = bool> T isplayaiming() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1D6F5C4))(this);
        }

        template <typename T = void> T stopallstatewhenstartaim() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC4A44))(this);
        }

        template <typename T = void> T startaim() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC4BD0))(this);
        }

        template <typename T = void> T stopaim() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC4D18))(this);
        }

        template <typename T = void> T closeaim() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC4E74))(this);
        }

        template <typename T = void> T closeaimandresetdata() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC5008))(this);
        }

        template <typename T = bool> T canopenaim() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC5184))(this);
        }

        template <typename T = bool> T isneedshowcancelaim() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC562C))(this);
        }

        template <typename T = bool> T issimulateaimming() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC5778))(this);
        }

        template <typename T = bool> T isinchangeclip() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DA2C34))(this);
        }

        template <typename T = void> T trychangeclip(bool _auto_) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1DC5848))(
                this, _auto_);
        }

        template <typename T = void> T dochangeclip() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC5A4C))(this);
        }

        template <typename T = bool> T isshouldendchangeclip() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC5D2C))(this);
        }

        template <typename T = void> T checkweaponaimingstatefirereset() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC5F70))(this);
        }

        template <typename T = void> T dealwithelectric(bool _isbuttondown) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1DC6174))(
                this, _isbuttondown);
        }

        template <typename T = void> T firebuttondown() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC62D0))(this);
        }

        template <typename T = void> T firebuttonup() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC658C))(this);
        }

        template <typename T = bool> T isneedentermovehipfire() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC6664))(this);
        }

        template <typename T = bool> T getadsstate() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC68A0))(this);
        }

        template <typename T = bool> T iscanaimassit() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC6A2C))(this);
        }

        template <typename T = void>
        T lockcontrolandsetresetfireinput(float _locktime) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1D95240))(
                this, _locktime);
        }

        template <typename T = void>
        T lockcheck(std::uintptr_t _statetype, float _locktime) {
            return ((T(*)(pawn *, std::uintptr_t, float))(
                il2cpp::il2cpp_base() + 0x1D5212C))(this, _statetype,
                                                    _locktime);
        }

        template <typename T = void>
        T setpawnswtichstate(std::uintptr_t _state, bool _isactive) {
            return ((T(*)(pawn *, std::uintptr_t, bool))(
                il2cpp::il2cpp_base() + 0x1DC6CE0))(this, _state, _isactive);
        }

        template <typename T = void>
        T setlockpawnstate(std::uintptr_t _state, bool _islock) {
            return ((T(*)(pawn *, std::uintptr_t, bool))(
                il2cpp::il2cpp_base() + 0x1DC6E34))(this, _state, _islock);
        }

        template <typename T = void>
        T setlockpawnstateexcept(std::uintptr_t _state, bool _islock) {
            return ((T(*)(pawn *, std::uintptr_t, bool))(
                il2cpp::il2cpp_base() + 0x1DC6F88))(this, _state, _islock);
        }

        template <typename T = void> T lockallpawnstate(bool _islock) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1DC70DC))(
                this, _islock);
        }

        template <typename T = void>
        T lockprone_jump_crouch_fire(bool _islock) {
            return ((T(*)(pawn *, bool))(il2cpp::il2cpp_base() + 0x1DC7208))(
                this, _islock);
        }

        template <typename T = bool> T islockstate(std::uintptr_t _state) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1DC734C))(this, _state);
        }

        template <typename T = void>
        T set_item(std::uintptr_t _type, std::uintptr_t _value) {
            return ((T(*)(pawn *, std::uintptr_t, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DC749C))(this, _type, _value);
        }

        template <typename T = void> T dooncallback(std::uintptr_t _type) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1D54A64))(this, _type);
        }

        template <typename T = void>
        T removecallback(std::uintptr_t _type, std::uintptr_t _invalue) {
            return ((T(*)(pawn *, std::uintptr_t, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DC7868))(this, _type, _invalue);
        }

        template <typename T = bool>
        static T getlogicalcomponent_1m__0(std::uintptr_t _e) {
            return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x0))(0, _e);
        }

        template <typename T = void>
        T showmedicalstationcuringeffectm__1(std::uintptr_t _effect) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1DC7DDC))(this, _effect);
        }

        template <typename T = std::uintptr_t> T xluabaseproxy_infotype() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC7F88))(this);
        }

        template <typename T = void>
        T xluabaseproxy_setattackableinfo(std::uintptr_t _p0) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1DC7F90))(this, _p0);
        }

        template <typename T = il2cpp_vec3>
        T xluabaseproxy_getrealpawnheadposition() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC7F98))(this);
        }

        template <typename T = void> T xluabaseproxy_awake() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC7FAC))(this);
        }

        template <typename T = void> T xluabaseproxy_preinit() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC7FB4))(this);
        }

        template <typename T = void> T xluabaseproxy_destroycomponent() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC7FBC))(this);
        }

        template <typename T = void> T xluabaseproxy_tick(float _p0) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DC7FC4))(
                this, _p0);
        }

        template <typename T = void> T xluabaseproxy_reset() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC7FCC))(this);
        }

        template <typename T = void>
        T xluabaseproxy_takedamage(std::uintptr_t _p0) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1DC7FD4))(this, _p0);
        }

        template <typename T = void>
        T xluabaseproxy_setongoingdamage(float _p0, std::uintptr_t _p1,
                                         std::int32_t _p2) {
            return ((T(*)(pawn *, float, std::uintptr_t, std::int32_t))(
                il2cpp::il2cpp_base() + 0x1DC7FDC))(this, _p0, _p1, _p2);
        }

        template <typename T = void>
        T xluabaseproxy_playtakedamageeffect(std::uintptr_t _p0) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1DC7FFC))(this, _p0);
        }

        template <typename T = void>
        T xluabaseproxy_adjustdamage(std::uintptr_t _p0) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1DC8004))(this, _p0);
        }

        template <typename T = void>
        T xluabaseproxy_simulatetakedamage(std::uintptr_t _p0) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1DC800C))(this, _p0);
        }

        template <typename T = void> T xluabaseproxy_ondestroy() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC8014))(this);
        }

        template <typename T = void>
        T xluabaseproxy_beginconcussioneffect(float _p0, bool _p1, float _p2) {
            return ((T(*)(pawn *, float, bool, float))(
                il2cpp::il2cpp_base() + 0x1DC801C))(this, _p0, _p1, _p2);
        }

        template <typename T = void> T xluabaseproxy_endconcussioneffect() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC803C))(this);
        }

        template <typename T = void>
        T xluabaseproxy_beginflasheffect(float _p0) {
            return ((T(*)(pawn *, float))(il2cpp::il2cpp_base() + 0x1DC8044))(
                this, _p0);
        }

        template <typename T = void> T xluabaseproxy_endflasheffect() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC804C))(this);
        }

        template <typename T = void>
        T xluabaseproxy_beginempeffect(float _p0, std::uintptr_t _p1) {
            return ((T(*)(pawn *, float, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x1DC8054))(this, _p0, _p1);
        }

        template <typename T = void> T xluabaseproxy_endempeffect() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC8080))(this);
        }

        template <typename T = bool>
        T xluabaseproxy_canbedamagedby(std::uintptr_t _p0) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1DC8088))(this, _p0);
        }

        template <typename T = bool>
        T xluabaseproxy_issamecamp(std::uintptr_t _p0) {
            return ((T(*)(pawn *, std::uintptr_t))(il2cpp::il2cpp_base() +
                                                   0x1DC8090))(this, _p0);
        }

        template <typename T = bool> T xluabaseproxy_iscanbestick() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC8098))(this);
        }

        template <typename T = bool> T xluabaseproxy_enableoptimizetransform() {
            return ((T(*)(pawn *))(il2cpp::il2cpp_base() + 0x1DC80A0))(this);
        }
    };

} // namespace gamebase