TmpMenu/src/natives.hpp

/**
 * @file natives.hpp
 * @brief Native definitions file.
 * To update this file generate natives.hpp file from [natives.json](https://github.com/alloc8or/gta5-nativedb-data).
 * For better documentation and generation of natives.hpp go to a website like https://nativedb.spyral.dev.
 */

#pragma once
#include "common.hpp"
#include "gta/natives.hpp"
#include "invoker.hpp"

template<typename Ret, typename... Args>
FORCEINLINE Ret invoke(rage::scrNativeHash hash, Args&&... args)
{
	using namespace big;

	g_native_invoker.begin_call();
	(g_native_invoker.push_arg(std::forward<Args>(args)), ...);
	g_native_invoker.end_call(hash);

	if constexpr (!std::is_same_v<Ret, void>)
	{
		return g_native_invoker.get_return_value<Ret>();
	}
}

// clang-format off

// Generated on 7/2/2023, 2:30:56 PM
// https://nativedb.spyral.dev

namespace SYSTEM
{
	void WAIT(int ms);
	int START_NEW_SCRIPT(const char* scriptName, int stackSize);
	int START_NEW_SCRIPT_WITH_ARGS(const char* scriptName, Any* args, int argCount, int stackSize);
	int START_NEW_SCRIPT_WITH_NAME_HASH(Hash scriptHash, int stackSize);
	int START_NEW_SCRIPT_WITH_NAME_HASH_AND_ARGS(Hash scriptHash, Any* args, int argCount, int stackSize);
	int TIMERA();
	int TIMERB();
	void SETTIMERA(int value);
	void SETTIMERB(int value);
	float TIMESTEP();
	float SIN(float value);
	float COS(float value);
	float SQRT(float value);
	float POW(float base, float exponent);
	float LOG10(float value);
	float VMAG(float x, float y, float z);
	float VMAG2(float x, float y, float z);
	float VDIST(float x1, float y1, float z1, float x2, float y2, float z2);
	float VDIST2(float x1, float y1, float z1, float x2, float y2, float z2);
	int SHIFT_LEFT(int value, int bitShift);
	int SHIFT_RIGHT(int value, int bitShift);
	int FLOOR(float value);
	int CEIL(float value);
	int ROUND(float value);
	float TO_FLOAT(int value);
	void SET_THIS_THREAD_PRIORITY(int priority);
}

namespace APP
{
	BOOL APP_DATA_VALID();
	int APP_GET_INT(const char* property);
	float APP_GET_FLOAT(const char* property);
	const char* APP_GET_STRING(const char* property);
	void APP_SET_INT(const char* property, int value);
	void APP_SET_FLOAT(const char* property, float value);
	void APP_SET_STRING(const char* property, const char* value);
	void APP_SET_APP(const char* appName);
	void APP_SET_BLOCK(const char* blockName);
	void APP_CLEAR_BLOCK();
	void APP_CLOSE_APP();
	void APP_CLOSE_BLOCK();
	BOOL APP_HAS_LINKED_SOCIAL_CLUB_ACCOUNT();
	BOOL APP_HAS_SYNCED_DATA(const char* appName);
	void APP_SAVE_DATA();
	int APP_GET_DELETED_FILE_STATUS();
	BOOL APP_DELETE_APP_DATA(const char* appName);
}

namespace AUDIO
{
	void PLAY_PED_RINGTONE(const char* ringtoneName, Ped ped, BOOL p2);
	BOOL IS_PED_RINGTONE_PLAYING(Ped ped);
	void STOP_PED_RINGTONE(Ped ped);
	BOOL IS_MOBILE_PHONE_CALL_ONGOING();
	BOOL IS_MOBILE_INTERFERENCE_ACTIVE();
	void CREATE_NEW_SCRIPTED_CONVERSATION();
	void ADD_LINE_TO_CONVERSATION(int index, const char* p1, const char* p2, int p3, int p4, BOOL p5, BOOL p6, BOOL p7, BOOL p8, int p9, BOOL p10, BOOL p11, BOOL p12);
	void ADD_PED_TO_CONVERSATION(int index, Ped ped, const char* p2);
	void SET_POSITION_FOR_NULL_CONV_PED(Any p0, float p1, float p2, float p3);
	void SET_ENTITY_FOR_NULL_CONV_PED(int p0, Entity entity);
	void SET_MICROPHONE_POSITION(BOOL toggle, float x1, float y1, float z1, float x2, float y2, float z2, float x3, float y3, float z3);
	void SET_CONVERSATION_AUDIO_CONTROLLED_BY_ANIM(BOOL p0);
	void SET_CONVERSATION_AUDIO_PLACEHOLDER(BOOL p0);
	void START_SCRIPT_PHONE_CONVERSATION(BOOL p0, BOOL p1);
	void PRELOAD_SCRIPT_PHONE_CONVERSATION(BOOL p0, BOOL p1);
	void START_SCRIPT_CONVERSATION(BOOL p0, BOOL p1, BOOL p2, BOOL p3);
	void PRELOAD_SCRIPT_CONVERSATION(BOOL p0, BOOL p1, BOOL p2, BOOL p3);
	void START_PRELOADED_CONVERSATION();
	BOOL GET_IS_PRELOADED_CONVERSATION_READY();
	BOOL IS_SCRIPTED_CONVERSATION_ONGOING();
	BOOL IS_SCRIPTED_CONVERSATION_LOADED();
	int GET_CURRENT_SCRIPTED_CONVERSATION_LINE();
	void PAUSE_SCRIPTED_CONVERSATION(BOOL p0);
	void RESTART_SCRIPTED_CONVERSATION();
	int STOP_SCRIPTED_CONVERSATION(BOOL p0);
	void SKIP_TO_NEXT_SCRIPTED_CONVERSATION_LINE();
	void INTERRUPT_CONVERSATION(Ped ped, const char* voiceline, const char* speaker);
	void INTERRUPT_CONVERSATION_AND_PAUSE(Ped ped, const char* p1, const char* speaker);
	int GET_VARIATION_CHOSEN_FOR_SCRIPTED_LINE(Any* p0);
	void SET_NO_DUCKING_FOR_CONVERSATION(BOOL p0);
	void REGISTER_SCRIPT_WITH_AUDIO(int p0);
	void UNREGISTER_SCRIPT_WITH_AUDIO();
	BOOL REQUEST_MISSION_AUDIO_BANK(const char* audioBank, BOOL p1, Any p2);
	BOOL REQUEST_AMBIENT_AUDIO_BANK(const char* audioBank, BOOL p1, Any p2);
	BOOL REQUEST_SCRIPT_AUDIO_BANK(const char* audioBank, BOOL p1, Any p2);
	BOOL HINT_MISSION_AUDIO_BANK(const char* audioBank, BOOL p1, Any p2);
	BOOL HINT_AMBIENT_AUDIO_BANK(const char* audioBank, BOOL p1, Any p2);
	BOOL HINT_SCRIPT_AUDIO_BANK(const char* audioBank, BOOL p1, Any p2);
	void RELEASE_MISSION_AUDIO_BANK();
	void RELEASE_AMBIENT_AUDIO_BANK();
	void RELEASE_NAMED_SCRIPT_AUDIO_BANK(const char* audioBank);
	void RELEASE_SCRIPT_AUDIO_BANK();
	void UNHINT_AMBIENT_AUDIO_BANK();
	void UNHINT_SCRIPT_AUDIO_BANK();
	void UNHINT_NAMED_SCRIPT_AUDIO_BANK(const char* audioBank);
	int GET_SOUND_ID();
	void RELEASE_SOUND_ID(int soundId);
	void PLAY_SOUND(int soundId, const char* audioName, const char* audioRef, BOOL p3, Any p4, BOOL p5);
	void PLAY_SOUND_FRONTEND(int soundId, const char* audioName, const char* audioRef, BOOL p3);
	void PLAY_DEFERRED_SOUND_FRONTEND(const char* soundName, const char* soundsetName);
	void PLAY_SOUND_FROM_ENTITY(int soundId, const char* audioName, Entity entity, const char* audioRef, BOOL isNetwork, Any p5);
	void PLAY_SOUND_FROM_ENTITY_HASH(int soundId, Hash model, Entity entity, Hash soundSetHash, Any p4, Any p5);
	void PLAY_SOUND_FROM_COORD(int soundId, const char* audioName, float x, float y, float z, const char* audioRef, BOOL isNetwork, int range, BOOL p8);
	void UPDATE_SOUND_COORD(int soundId, float x, float y, float z);
	void STOP_SOUND(int soundId);
	int GET_NETWORK_ID_FROM_SOUND_ID(int soundId);
	int GET_SOUND_ID_FROM_NETWORK_ID(int netId);
	void SET_VARIABLE_ON_SOUND(int soundId, const char* variable, float p2);
	void SET_VARIABLE_ON_STREAM(const char* variable, float p1);
	void OVERRIDE_UNDERWATER_STREAM(const char* p0, BOOL p1);
	void SET_VARIABLE_ON_UNDER_WATER_STREAM(const char* variableName, float value);
	BOOL HAS_SOUND_FINISHED(int soundId);
	void PLAY_PED_AMBIENT_SPEECH_NATIVE(Ped ped, const char* speechName, const char* speechParam, Any p3);
	void PLAY_PED_AMBIENT_SPEECH_AND_CLONE_NATIVE(Ped ped, const char* speechName, const char* speechParam, Any p3);
	void PLAY_PED_AMBIENT_SPEECH_WITH_VOICE_NATIVE(Ped ped, const char* speechName, const char* voiceName, const char* speechParam, BOOL p4);
	void PLAY_AMBIENT_SPEECH_FROM_POSITION_NATIVE(const char* speechName, const char* voiceName, float x, float y, float z, const char* speechParam);
	void OVERRIDE_TREVOR_RAGE(const char* voiceEffect);
	void RESET_TREVOR_RAGE();
	void SET_PLAYER_ANGRY(Ped ped, BOOL toggle);
	void PLAY_PAIN(Ped ped, int painID, int p1, Any p3);
	void RELEASE_WEAPON_AUDIO();
	void ACTIVATE_AUDIO_SLOWMO_MODE(const char* mode);
	void DEACTIVATE_AUDIO_SLOWMO_MODE(const char* mode);
	void SET_AMBIENT_VOICE_NAME(Ped ped, const char* name);
	void SET_AMBIENT_VOICE_NAME_HASH(Ped ped, Hash hash);
	Hash GET_AMBIENT_VOICE_NAME_HASH(Ped ped);
	void SET_PED_VOICE_FULL(Ped ped);
	void SET_PED_RACE_AND_VOICE_GROUP(Ped ped, int p1, Hash voiceGroup);
	void SET_PED_VOICE_GROUP(Ped ped, Hash voiceGroupHash);
	void SET_PED_VOICE_GROUP_FROM_RACE_TO_PVG(Ped ped, Hash voiceGroupHash);
	void SET_PED_GENDER(Ped ped, BOOL p1);
	void STOP_CURRENT_PLAYING_SPEECH(Ped ped);
	void STOP_CURRENT_PLAYING_AMBIENT_SPEECH(Ped ped);
	BOOL IS_AMBIENT_SPEECH_PLAYING(Ped ped);
	BOOL IS_SCRIPTED_SPEECH_PLAYING(Ped p0);
	BOOL IS_ANY_SPEECH_PLAYING(Ped ped);
	BOOL IS_ANY_POSITIONAL_SPEECH_PLAYING();
	BOOL DOES_CONTEXT_EXIST_FOR_THIS_PED(Ped ped, const char* speechName, BOOL p2);
	BOOL IS_PED_IN_CURRENT_CONVERSATION(Ped ped);
	void SET_PED_IS_DRUNK(Ped ped, BOOL toggle);
	void PLAY_ANIMAL_VOCALIZATION(Ped pedHandle, int p1, const char* speechName);
	BOOL IS_ANIMAL_VOCALIZATION_PLAYING(Ped pedHandle);
	void SET_ANIMAL_MOOD(Ped animal, int mood);
	BOOL IS_MOBILE_PHONE_RADIO_ACTIVE();
	void SET_MOBILE_PHONE_RADIO_STATE(BOOL state);
	int GET_PLAYER_RADIO_STATION_INDEX();
	const char* GET_PLAYER_RADIO_STATION_NAME();
	const char* GET_RADIO_STATION_NAME(int radioStation);
	int GET_PLAYER_RADIO_STATION_GENRE();
	BOOL IS_RADIO_RETUNING();
	BOOL IS_RADIO_FADED_OUT();
	void SET_RADIO_RETUNE_UP();
	void SET_RADIO_RETUNE_DOWN();
	void SET_RADIO_TO_STATION_NAME(const char* stationName);
	void SET_VEH_RADIO_STATION(Vehicle vehicle, const char* radioStation);
	void SET_VEH_HAS_NORMAL_RADIO(Vehicle vehicle);
	BOOL IS_VEHICLE_RADIO_ON(Vehicle vehicle);
	void SET_VEH_FORCED_RADIO_THIS_FRAME(Vehicle vehicle);
	void SET_EMITTER_RADIO_STATION(const char* emitterName, const char* radioStation, Any p2);
	void SET_STATIC_EMITTER_ENABLED(const char* emitterName, BOOL toggle);
	void LINK_STATIC_EMITTER_TO_ENTITY(const char* emitterName, Entity entity);
	void SET_RADIO_TO_STATION_INDEX(int radioStation);
	void SET_FRONTEND_RADIO_ACTIVE(BOOL active);
	void UNLOCK_MISSION_NEWS_STORY(int newsStory);
	BOOL IS_MISSION_NEWS_STORY_UNLOCKED(int newsStory);
	int GET_AUDIBLE_MUSIC_TRACK_TEXT_ID();
	void PLAY_END_CREDITS_MUSIC(BOOL play);
	void SKIP_RADIO_FORWARD();
	void FREEZE_RADIO_STATION(const char* radioStation);
	void UNFREEZE_RADIO_STATION(const char* radioStation);
	void SET_RADIO_AUTO_UNFREEZE(BOOL toggle);
	void SET_INITIAL_PLAYER_STATION(const char* radioStation);
	void SET_USER_RADIO_CONTROL_ENABLED(BOOL toggle);
	void SET_RADIO_TRACK(const char* radioStation, const char* radioTrack);
	void SET_RADIO_TRACK_WITH_START_OFFSET(const char* radioStationName, const char* mixName, int p2);
	void SET_NEXT_RADIO_TRACK(const char* radioName, const char* radioTrack, const char* p2, const char* p3);
	void SET_VEHICLE_RADIO_LOUD(Vehicle vehicle, BOOL toggle);
	BOOL CAN_VEHICLE_RECEIVE_CB_RADIO(Vehicle vehicle);
	void SET_MOBILE_RADIO_ENABLED_DURING_GAMEPLAY(BOOL toggle);
	BOOL DOES_PLAYER_VEH_HAVE_RADIO();
	BOOL IS_PLAYER_VEH_RADIO_ENABLE();
	void SET_VEHICLE_RADIO_ENABLED(Vehicle vehicle, BOOL toggle);
	void SET_POSITIONED_PLAYER_VEHICLE_RADIO_EMITTER_ENABLED(Any p0);
	void SET_CUSTOM_RADIO_TRACK_LIST(const char* radioStation, const char* trackListName, BOOL p2);
	void CLEAR_CUSTOM_RADIO_TRACK_LIST(const char* radioStation);
	int GET_NUM_UNLOCKED_RADIO_STATIONS();
	int FIND_RADIO_STATION_INDEX(Hash stationNameHash);
	void SET_RADIO_STATION_MUSIC_ONLY(const char* radioStation, BOOL toggle);
	void SET_RADIO_FRONTEND_FADE_TIME(float fadeTime);
	void UNLOCK_RADIO_STATION_TRACK_LIST(const char* radioStation, const char* trackListName);
	void LOCK_RADIO_STATION_TRACK_LIST(const char* radioStation, const char* trackListName);
	void UPDATE_UNLOCKABLE_DJ_RADIO_TRACKS(BOOL enableMixes);
	void LOCK_RADIO_STATION(const char* radioStationName, BOOL toggle);
	void SET_RADIO_STATION_AS_FAVOURITE(const char* radioStation, BOOL toggle);
	BOOL IS_RADIO_STATION_FAVOURITED(const char* radioStation);
	BOOL GET_NEXT_AUDIBLE_BEAT(float* out1, float* out2, int* out3);
	void FORCE_MUSIC_TRACK_LIST(const char* radioStation, const char* trackListName, int milliseconds);
	int GET_CURRENT_TRACK_PLAY_TIME(const char* radioStationName);
	Hash GET_CURRENT_TRACK_SOUND_NAME(const char* radioStationName);
	void SET_VEHICLE_MISSILE_WARNING_ENABLED(Vehicle vehicle, BOOL toggle);
	void SET_AMBIENT_ZONE_STATE(const char* zoneName, BOOL p1, BOOL p2);
	void CLEAR_AMBIENT_ZONE_STATE(const char* zoneName, BOOL p1);
	void SET_AMBIENT_ZONE_LIST_STATE(const char* ambientZone, BOOL p1, BOOL p2);
	void CLEAR_AMBIENT_ZONE_LIST_STATE(const char* ambientZone, BOOL p1);
	void SET_AMBIENT_ZONE_STATE_PERSISTENT(const char* ambientZone, BOOL p1, BOOL p2);
	void SET_AMBIENT_ZONE_LIST_STATE_PERSISTENT(const char* ambientZone, BOOL p1, BOOL p2);
	BOOL IS_AMBIENT_ZONE_ENABLED(const char* ambientZone);
	void REFRESH_CLOSEST_OCEAN_SHORELINE();
	void SET_CUTSCENE_AUDIO_OVERRIDE(const char* name);
	void SET_VARIABLE_ON_SYNCH_SCENE_AUDIO(const char* variableName, float value);
	int PLAY_POLICE_REPORT(const char* name, float p1);
	void CANCEL_ALL_POLICE_REPORTS();
	void BLIP_SIREN(Vehicle vehicle);
	void OVERRIDE_VEH_HORN(Vehicle vehicle, BOOL override, int hornHash);
	BOOL IS_HORN_ACTIVE(Vehicle vehicle);
	void SET_AGGRESSIVE_HORNS(BOOL toggle);
	void SET_RADIO_POSITION_AUDIO_MUTE(BOOL p0);
	void SET_VEHICLE_CONVERSATIONS_PERSIST(BOOL p0, BOOL p1);
	void SET_VEHICLE_CONVERSATIONS_PERSIST_NEW(BOOL p0, BOOL p1, BOOL p2);
	BOOL IS_STREAM_PLAYING();
	int GET_STREAM_PLAY_TIME();
	BOOL LOAD_STREAM(const char* streamName, const char* soundSet);
	BOOL LOAD_STREAM_WITH_START_OFFSET(const char* streamName, int startOffset, const char* soundSet);
	void PLAY_STREAM_FROM_PED(Ped ped);
	void PLAY_STREAM_FROM_VEHICLE(Vehicle vehicle);
	void PLAY_STREAM_FROM_OBJECT(Object object);
	void PLAY_STREAM_FRONTEND();
	void PLAY_STREAM_FROM_POSITION(float x, float y, float z);
	void STOP_STREAM();
	void STOP_PED_SPEAKING(Ped ped, BOOL shaking);
	void BLOCK_ALL_SPEECH_FROM_PED(Ped ped, BOOL p1, BOOL p2);
	void STOP_PED_SPEAKING_SYNCED(Ped ped, BOOL p1);
	void DISABLE_PED_PAIN_AUDIO(Ped ped, BOOL toggle);
	BOOL IS_AMBIENT_SPEECH_DISABLED(Ped ped);
	void BLOCK_SPEECH_CONTEXT_GROUP(const char* p0, int p1);
	void UNBLOCK_SPEECH_CONTEXT_GROUP(const char* p0);
	void SET_SIREN_WITH_NO_DRIVER(Vehicle vehicle, BOOL toggle);
	void SET_SIREN_BYPASS_MP_DRIVER_CHECK(Vehicle vehicle, BOOL toggle);
	void TRIGGER_SIREN_AUDIO(Vehicle vehicle);
	void SET_HORN_PERMANENTLY_ON(Vehicle vehicle);
	void SET_HORN_ENABLED(Vehicle vehicle, BOOL toggle);
	void SET_AUDIO_VEHICLE_PRIORITY(Vehicle vehicle, Any p1);
	void SET_HORN_PERMANENTLY_ON_TIME(Vehicle vehicle, float time);
	void USE_SIREN_AS_HORN(Vehicle vehicle, BOOL toggle);
	void FORCE_USE_AUDIO_GAME_OBJECT(Vehicle vehicle, const char* audioName);
	void PRELOAD_VEHICLE_AUDIO_BANK(Hash vehicleModel);
	void SET_VEHICLE_STARTUP_REV_SOUND(Vehicle vehicle, const char* p1, const char* p2);
	void RESET_VEHICLE_STARTUP_REV_SOUND(Vehicle vehicle);
	void SET_VEHICLE_FORCE_REVERSE_WARNING(Any p0, Any p1);
	BOOL IS_VEHICLE_AUDIBLY_DAMAGED(Vehicle vehicle);
	void SET_VEHICLE_AUDIO_ENGINE_DAMAGE_FACTOR(Vehicle vehicle, float damageFactor);
	void SET_VEHICLE_AUDIO_BODY_DAMAGE_FACTOR(Vehicle vehicle, float intensity);
	void ENABLE_VEHICLE_FANBELT_DAMAGE(Vehicle vehicle, BOOL toggle);
	void ENABLE_VEHICLE_EXHAUST_POPS(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_BOOST_ACTIVE(Vehicle vehicle, BOOL toggle);
	void SET_PLAYER_VEHICLE_ALARM_AUDIO_ACTIVE(Vehicle vehicle, BOOL toggle);
	void SET_SCRIPT_UPDATE_DOOR_AUDIO(Hash doorHash, BOOL toggle);
	void PLAY_VEHICLE_DOOR_OPEN_SOUND(Vehicle vehicle, int doorId);
	void PLAY_VEHICLE_DOOR_CLOSE_SOUND(Vehicle vehicle, int doorId);
	void ENABLE_STALL_WARNING_SOUNDS(Vehicle vehicle, BOOL toggle);
	BOOL IS_GAME_IN_CONTROL_OF_MUSIC();
	void SET_GPS_ACTIVE(BOOL active);
	void PLAY_MISSION_COMPLETE_AUDIO(const char* audioName);
	BOOL IS_MISSION_COMPLETE_PLAYING();
	BOOL IS_MISSION_COMPLETE_READY_FOR_UI();
	void BLOCK_DEATH_JINGLE(BOOL toggle);
	BOOL START_AUDIO_SCENE(const char* scene);
	void STOP_AUDIO_SCENE(const char* scene);
	void STOP_AUDIO_SCENES();
	BOOL IS_AUDIO_SCENE_ACTIVE(const char* scene);
	void SET_AUDIO_SCENE_VARIABLE(const char* scene, const char* variable, float value);
	void SET_AUDIO_SCRIPT_CLEANUP_TIME(int time);
	void ADD_ENTITY_TO_AUDIO_MIX_GROUP(Entity entity, const char* groupName, float p2);
	void REMOVE_ENTITY_FROM_AUDIO_MIX_GROUP(Entity entity, float p1);
	BOOL AUDIO_IS_MUSIC_PLAYING();
	BOOL AUDIO_IS_SCRIPTED_MUSIC_PLAYING();
	BOOL PREPARE_MUSIC_EVENT(const char* eventName);
	BOOL CANCEL_MUSIC_EVENT(const char* eventName);
	BOOL TRIGGER_MUSIC_EVENT(const char* eventName);
	BOOL IS_MUSIC_ONESHOT_PLAYING();
	int GET_MUSIC_PLAYTIME();
	void SET_GLOBAL_RADIO_SIGNAL_LEVEL(Any p0);
	void RECORD_BROKEN_GLASS(float x, float y, float z, float radius);
	void CLEAR_ALL_BROKEN_GLASS();
	void SCRIPT_OVERRIDES_WIND_ELEVATION(BOOL p0, Any p1);
	void SET_PED_WALLA_DENSITY(float p0, float p1);
	void SET_PED_INTERIOR_WALLA_DENSITY(float p0, float p1);
	void FORCE_PED_PANIC_WALLA();
	BOOL PREPARE_ALARM(const char* alarmName);
	void START_ALARM(const char* alarmName, BOOL p2);
	void STOP_ALARM(const char* alarmName, BOOL toggle);
	void STOP_ALL_ALARMS(BOOL stop);
	BOOL IS_ALARM_PLAYING(const char* alarmName);
	Hash GET_VEHICLE_DEFAULT_HORN(Vehicle vehicle);
	Hash GET_VEHICLE_DEFAULT_HORN_IGNORE_MODS(Vehicle vehicle);
	void RESET_PED_AUDIO_FLAGS(Ped ped);
	void SET_PED_FOOTSTEPS_EVENTS_ENABLED(Ped ped, BOOL toggle);
	void SET_PED_CLOTH_EVENTS_ENABLED(Ped ped, BOOL toggle);
	void OVERRIDE_PLAYER_GROUND_MATERIAL(Hash hash, BOOL toggle);
	void USE_FOOTSTEP_SCRIPT_SWEETENERS(Ped ped, BOOL p1, Hash hash);
	void OVERRIDE_MICROPHONE_SETTINGS(Hash hash, BOOL toggle);
	void FREEZE_MICROPHONE();
	void DISTANT_COP_CAR_SIRENS(BOOL value);
	void SET_SIREN_CAN_BE_CONTROLLED_BY_AUDIO(Vehicle vehicle, BOOL p1);
	void ENABLE_STUNT_JUMP_AUDIO();
	void SET_AUDIO_FLAG(const char* flagName, BOOL toggle);
	BOOL PREPARE_SYNCHRONIZED_AUDIO_EVENT(const char* audioEvent, Any p1);
	BOOL PREPARE_SYNCHRONIZED_AUDIO_EVENT_FOR_SCENE(int sceneID, const char* audioEvent);
	BOOL PLAY_SYNCHRONIZED_AUDIO_EVENT(int sceneID);
	BOOL STOP_SYNCHRONIZED_AUDIO_EVENT(int sceneID);
	void INIT_SYNCH_SCENE_AUDIO_WITH_POSITION(const char* audioEvent, float x, float y, float z);
	void INIT_SYNCH_SCENE_AUDIO_WITH_ENTITY(const char* audioEvent, Entity entity);
	void SET_AUDIO_SPECIAL_EFFECT_MODE(int mode);
	void SET_PORTAL_SETTINGS_OVERRIDE(const char* p0, const char* p1);
	void REMOVE_PORTAL_SETTINGS_OVERRIDE(const char* p0);
	void STOP_SMOKE_GRENADE_EXPLOSION_SOUNDS();
	int GET_MUSIC_VOL_SLIDER();
	void REQUEST_TENNIS_BANKS(Ped ped);
	void UNREQUEST_TENNIS_BANKS();
	void SET_SKIP_MINIGUN_SPIN_UP_AUDIO(BOOL p0);
	void STOP_CUTSCENE_AUDIO();
	BOOL HAS_LOADED_MP_DATA_SET();
	BOOL HAS_LOADED_SP_DATA_SET();
	int GET_VEHICLE_HORN_SOUND_INDEX(Vehicle vehicle);
	void SET_VEHICLE_HORN_SOUND_INDEX(Vehicle vehicle, int value);
}

namespace BRAIN
{
	void ADD_SCRIPT_TO_RANDOM_PED(const char* name, Hash model, float p2, float p3);
	void REGISTER_OBJECT_SCRIPT_BRAIN(const char* scriptName, Hash modelHash, int p2, float activationRange, int p4, int p5);
	BOOL IS_OBJECT_WITHIN_BRAIN_ACTIVATION_RANGE(Object object);
	void REGISTER_WORLD_POINT_SCRIPT_BRAIN(const char* scriptName, float activationRange, int p2);
	BOOL IS_WORLD_POINT_WITHIN_BRAIN_ACTIVATION_RANGE();
	void ENABLE_SCRIPT_BRAIN_SET(int brainSet);
	void DISABLE_SCRIPT_BRAIN_SET(int brainSet);
	void REACTIVATE_ALL_WORLD_BRAINS_THAT_ARE_WAITING_TILL_OUT_OF_RANGE();
	void REACTIVATE_ALL_OBJECT_BRAINS_THAT_ARE_WAITING_TILL_OUT_OF_RANGE();
	void REACTIVATE_NAMED_WORLD_BRAINS_WAITING_TILL_OUT_OF_RANGE(const char* scriptName);
	void REACTIVATE_NAMED_OBJECT_BRAINS_WAITING_TILL_OUT_OF_RANGE(const char* scriptName);
}

namespace CAM
{
	void RENDER_SCRIPT_CAMS(BOOL render, BOOL ease, int easeTime, BOOL p3, BOOL p4, Any p5);
	void STOP_RENDERING_SCRIPT_CAMS_USING_CATCH_UP(BOOL render, float p1, int p2, Any p3);
	Cam CREATE_CAM(const char* camName, BOOL p1);
	Cam CREATE_CAM_WITH_PARAMS(const char* camName, float posX, float posY, float posZ, float rotX, float rotY, float rotZ, float fov, BOOL p8, int p9);
	Cam CREATE_CAMERA(Hash camHash, BOOL p1);
	Cam CREATE_CAMERA_WITH_PARAMS(Hash camHash, float posX, float posY, float posZ, float rotX, float rotY, float rotZ, float fov, BOOL p8, Any p9);
	void DESTROY_CAM(Cam cam, BOOL bScriptHostCam);
	void DESTROY_ALL_CAMS(BOOL bScriptHostCam);
	BOOL DOES_CAM_EXIST(Cam cam);
	void SET_CAM_ACTIVE(Cam cam, BOOL active);
	BOOL IS_CAM_ACTIVE(Cam cam);
	BOOL IS_CAM_RENDERING(Cam cam);
	Cam GET_RENDERING_CAM();
	Vector3 GET_CAM_COORD(Cam cam);
	Vector3 GET_CAM_ROT(Cam cam, int rotationOrder);
	float GET_CAM_FOV(Cam cam);
	float GET_CAM_NEAR_CLIP(Cam cam);
	float GET_CAM_FAR_CLIP(Cam cam);
	float GET_CAM_NEAR_DOF(Cam cam);
	float GET_CAM_FAR_DOF(Cam cam);
	float GET_CAM_DOF_STRENGTH(Cam cam);
	void SET_CAM_PARAMS(Cam cam, float posX, float posY, float posZ, float rotX, float rotY, float rotZ, float fieldOfView, Any p8, int p9, int p10, int p11);
	void SET_CAM_COORD(Cam cam, float posX, float posY, float posZ);
	void SET_CAM_ROT(Cam cam, float rotX, float rotY, float rotZ, int rotationOrder);
	void SET_CAM_FOV(Cam cam, float fieldOfView);
	void SET_CAM_NEAR_CLIP(Cam cam, float nearClip);
	void SET_CAM_FAR_CLIP(Cam cam, float farClip);
	void FORCE_CAM_FAR_CLIP(Cam cam, float p1);
	void SET_CAM_MOTION_BLUR_STRENGTH(Cam cam, float strength);
	void SET_CAM_NEAR_DOF(Cam cam, float nearDOF);
	void SET_CAM_FAR_DOF(Cam cam, float farDOF);
	void SET_CAM_DOF_STRENGTH(Cam cam, float dofStrength);
	void SET_CAM_DOF_PLANES(Cam cam, float p1, float p2, float p3, float p4);
	void SET_CAM_USE_SHALLOW_DOF_MODE(Cam cam, BOOL toggle);
	void SET_USE_HI_DOF();
	void SET_USE_HI_DOF_ON_SYNCED_SCENE_THIS_UPDATE();
	void SET_CAM_DOF_OVERRIDDEN_FOCUS_DISTANCE(Cam camera, float p1);
	void SET_CAM_DOF_OVERRIDDEN_FOCUS_DISTANCE_BLEND_LEVEL(Any p0, float p1);
	void SET_CAM_DOF_FNUMBER_OF_LENS(Cam camera, float p1);
	void SET_CAM_DOF_FOCAL_LENGTH_MULTIPLIER(Cam camera, float multiplier);
	void SET_CAM_DOF_FOCUS_DISTANCE_BIAS(Cam camera, float p1);
	void SET_CAM_DOF_MAX_NEAR_IN_FOCUS_DISTANCE(Cam camera, float p1);
	void SET_CAM_DOF_MAX_NEAR_IN_FOCUS_DISTANCE_BLEND_LEVEL(Cam camera, float p1);
	void SET_CAM_DOF_SHOULD_KEEP_LOOK_AT_TARGET_IN_FOCUS(Cam camera, BOOL state);
	void ATTACH_CAM_TO_ENTITY(Cam cam, Entity entity, float xOffset, float yOffset, float zOffset, BOOL isRelative);
	void ATTACH_CAM_TO_PED_BONE(Cam cam, Ped ped, int boneIndex, float x, float y, float z, BOOL heading);
	void HARD_ATTACH_CAM_TO_PED_BONE(Cam cam, Ped ped, int boneIndex, float p3, float p4, float p5, float p6, float p7, float p8, BOOL p9);
	void HARD_ATTACH_CAM_TO_ENTITY(Cam cam, Entity entity, float xRot, float yRot, float zRot, float xOffset, float yOffset, float zOffset, BOOL isRelative);
	void ATTACH_CAM_TO_VEHICLE_BONE(Cam cam, Vehicle vehicle, int boneIndex, BOOL relativeRotation, float rotX, float rotY, float rotZ, float offsetX, float offsetY, float offsetZ, BOOL fixedDirection);
	void DETACH_CAM(Cam cam);
	void SET_CAM_INHERIT_ROLL_VEHICLE(Cam cam, BOOL p1);
	void POINT_CAM_AT_COORD(Cam cam, float x, float y, float z);
	void POINT_CAM_AT_ENTITY(Cam cam, Entity entity, float p2, float p3, float p4, BOOL p5);
	void POINT_CAM_AT_PED_BONE(Cam cam, Ped ped, int boneIndex, float x, float y, float z, BOOL p6);
	void STOP_CAM_POINTING(Cam cam);
	void SET_CAM_AFFECTS_AIMING(Cam cam, BOOL toggle);
	void SET_CAM_CONTROLS_MINI_MAP_HEADING(Cam cam, BOOL toggle);
	void SET_CAM_IS_INSIDE_VEHICLE(Cam cam, BOOL toggle);
	void ALLOW_MOTION_BLUR_DECAY(Any p0, BOOL p1);
	void SET_CAM_DEBUG_NAME(Cam camera, const char* name);
	Cam GET_DEBUG_CAM();
	void ADD_CAM_SPLINE_NODE(Cam camera, float x, float y, float z, float xRot, float yRot, float zRot, int length, int smoothingStyle, int rotationOrder);
	void ADD_CAM_SPLINE_NODE_USING_CAMERA_FRAME(Cam cam, Cam cam2, int length, int p3);
	void ADD_CAM_SPLINE_NODE_USING_CAMERA(Cam cam, Cam cam2, int length, int p3);
	void ADD_CAM_SPLINE_NODE_USING_GAMEPLAY_FRAME(Cam cam, int length, int p2);
	void SET_CAM_SPLINE_PHASE(Cam cam, float p1);
	float GET_CAM_SPLINE_PHASE(Cam cam);
	float GET_CAM_SPLINE_NODE_PHASE(Cam cam);
	void SET_CAM_SPLINE_DURATION(Cam cam, int timeDuration);
	void SET_CAM_SPLINE_SMOOTHING_STYLE(Cam cam, int smoothingStyle);
	int GET_CAM_SPLINE_NODE_INDEX(Cam cam);
	void SET_CAM_SPLINE_NODE_EASE(Cam cam, int easingFunction, int p2, float p3);
	void SET_CAM_SPLINE_NODE_VELOCITY_SCALE(Cam cam, int p1, float scale);
	void OVERRIDE_CAM_SPLINE_VELOCITY(Cam cam, int p1, float p2, float p3);
	void OVERRIDE_CAM_SPLINE_MOTION_BLUR(Cam cam, int p1, float p2, float p3);
	void SET_CAM_SPLINE_NODE_EXTRA_FLAGS(Cam cam, int p1, int flags);
	BOOL IS_CAM_SPLINE_PAUSED(Cam cam);
	void SET_CAM_ACTIVE_WITH_INTERP(Cam camTo, Cam camFrom, int duration, int easeLocation, int easeRotation);
	BOOL IS_CAM_INTERPOLATING(Cam cam);
	void SHAKE_CAM(Cam cam, const char* type, float amplitude);
	void ANIMATED_SHAKE_CAM(Cam cam, const char* p1, const char* p2, const char* p3, float amplitude);
	BOOL IS_CAM_SHAKING(Cam cam);
	void SET_CAM_SHAKE_AMPLITUDE(Cam cam, float amplitude);
	void STOP_CAM_SHAKING(Cam cam, BOOL p1);
	void SHAKE_SCRIPT_GLOBAL(const char* p0, float p1);
	void ANIMATED_SHAKE_SCRIPT_GLOBAL(const char* p0, const char* p1, const char* p2, float p3);
	BOOL IS_SCRIPT_GLOBAL_SHAKING();
	void STOP_SCRIPT_GLOBAL_SHAKING(BOOL p0);
	void TRIGGER_VEHICLE_PART_BROKEN_CAMERA_SHAKE(Vehicle vehicle, int p1, float p2);
	BOOL PLAY_CAM_ANIM(Cam cam, const char* animName, const char* animDictionary, float x, float y, float z, float xRot, float yRot, float zRot, BOOL p9, int p10);
	BOOL IS_CAM_PLAYING_ANIM(Cam cam, const char* animName, const char* animDictionary);
	void SET_CAM_ANIM_CURRENT_PHASE(Cam cam, float phase);
	float GET_CAM_ANIM_CURRENT_PHASE(Cam cam);
	BOOL PLAY_SYNCHRONIZED_CAM_ANIM(Any p0, Any p1, const char* animName, const char* animDictionary);
	void SET_FLY_CAM_HORIZONTAL_RESPONSE(Cam cam, float p1, float p2, float p3);
	void SET_FLY_CAM_VERTICAL_RESPONSE(Cam cam, float p1, float p2, float p3);
	void SET_FLY_CAM_MAX_HEIGHT(Cam cam, float height);
	void SET_FLY_CAM_COORD_AND_CONSTRAIN(Cam cam, float x, float y, float z);
	void SET_FLY_CAM_VERTICAL_CONTROLS_THIS_UPDATE(Cam cam);
	BOOL WAS_FLY_CAM_CONSTRAINED_ON_PREVIOUS_UDPATE(Cam cam);
	BOOL IS_SCREEN_FADED_OUT();
	BOOL IS_SCREEN_FADED_IN();
	BOOL IS_SCREEN_FADING_OUT();
	BOOL IS_SCREEN_FADING_IN();
	void DO_SCREEN_FADE_IN(int duration);
	void DO_SCREEN_FADE_OUT(int duration);
	void SET_WIDESCREEN_BORDERS(BOOL p0, int p1);
	BOOL ARE_WIDESCREEN_BORDERS_ACTIVE();
	Vector3 GET_GAMEPLAY_CAM_COORD();
	Vector3 GET_GAMEPLAY_CAM_ROT(int rotationOrder);
	float GET_GAMEPLAY_CAM_FOV();
	void SET_GAMEPLAY_CAM_MOTION_BLUR_SCALING_THIS_UPDATE(float p0);
	void SET_GAMEPLAY_CAM_MAX_MOTION_BLUR_STRENGTH_THIS_UPDATE(float p0);
	float GET_GAMEPLAY_CAM_RELATIVE_HEADING();
	void SET_GAMEPLAY_CAM_RELATIVE_HEADING(float heading);
	float GET_GAMEPLAY_CAM_RELATIVE_PITCH();
	void SET_GAMEPLAY_CAM_RELATIVE_PITCH(float angle, float scalingFactor);
	void RESET_GAMEPLAY_CAM_FULL_ATTACH_PARENT_TRANSFORM_TIMER();
	void FORCE_CAMERA_RELATIVE_HEADING_AND_PITCH(float roll, float pitch, float yaw);
	void FORCE_BONNET_CAMERA_RELATIVE_HEADING_AND_PITCH(float p0, float p1);
	void SET_FIRST_PERSON_SHOOTER_CAMERA_HEADING(float yaw);
	void SET_FIRST_PERSON_SHOOTER_CAMERA_PITCH(float pitch);
	void SET_SCRIPTED_CAMERA_IS_FIRST_PERSON_THIS_FRAME(BOOL p0);
	void SHAKE_GAMEPLAY_CAM(const char* shakeName, float intensity);
	BOOL IS_GAMEPLAY_CAM_SHAKING();
	void SET_GAMEPLAY_CAM_SHAKE_AMPLITUDE(float amplitude);
	void STOP_GAMEPLAY_CAM_SHAKING(BOOL p0);
	void SET_GAMEPLAY_CAM_FOLLOW_PED_THIS_UPDATE(Ped ped);
	BOOL IS_GAMEPLAY_CAM_RENDERING();
	BOOL IS_INTERPOLATING_FROM_SCRIPT_CAMS();
	BOOL IS_INTERPOLATING_TO_SCRIPT_CAMS();
	void SET_GAMEPLAY_CAM_ALTITUDE_FOV_SCALING_STATE(BOOL p0);
	void DISABLE_GAMEPLAY_CAM_ALTITUDE_FOV_SCALING_THIS_UPDATE();
	BOOL IS_GAMEPLAY_CAM_LOOKING_BEHIND();
	void SET_GAMEPLAY_CAM_IGNORE_ENTITY_COLLISION_THIS_UPDATE(Entity entity);
	void DISABLE_CAM_COLLISION_FOR_OBJECT(Entity entity);
	void BYPASS_CAMERA_COLLISION_BUOYANCY_TEST_THIS_UPDATE();
	void SET_GAMEPLAY_CAM_ENTITY_TO_LIMIT_FOCUS_OVER_BOUNDING_SPHERE_THIS_UPDATE(Entity entity);
	void DISABLE_FIRST_PERSON_CAMERA_WATER_CLIPPING_TEST_THIS_UPDATE();
	void SET_FOLLOW_CAM_IGNORE_ATTACH_PARENT_MOVEMENT_THIS_UPDATE();
	BOOL IS_SPHERE_VISIBLE(float x, float y, float z, float radius);
	BOOL IS_FOLLOW_PED_CAM_ACTIVE();
	BOOL SET_FOLLOW_PED_CAM_THIS_UPDATE(const char* camName, int p1);
	void USE_SCRIPT_CAM_FOR_AMBIENT_POPULATION_ORIGIN_THIS_FRAME(BOOL p0, BOOL p1);
	void SET_FOLLOW_PED_CAM_LADDER_ALIGN_THIS_UPDATE();
	void SET_THIRD_PERSON_CAM_RELATIVE_HEADING_LIMITS_THIS_UPDATE(float minimum, float maximum);
	void SET_THIRD_PERSON_CAM_RELATIVE_PITCH_LIMITS_THIS_UPDATE(float minimum, float maximum);
	void SET_THIRD_PERSON_CAM_ORBIT_DISTANCE_LIMITS_THIS_UPDATE(float p0, float distance);
	void SET_IN_VEHICLE_CAM_STATE_THIS_UPDATE(Vehicle p0, int p1);
	void DISABLE_ON_FOOT_FIRST_PERSON_VIEW_THIS_UPDATE();
	void DISABLE_FIRST_PERSON_FLASH_EFFECT_THIS_UPDATE();
	void BLOCK_FIRST_PERSON_ORIENTATION_RESET_THIS_UPDATE();
	int GET_FOLLOW_PED_CAM_ZOOM_LEVEL();
	int GET_FOLLOW_PED_CAM_VIEW_MODE();
	void SET_FOLLOW_PED_CAM_VIEW_MODE(int viewMode);
	BOOL IS_FOLLOW_VEHICLE_CAM_ACTIVE();
	void SET_FOLLOW_VEHICLE_CAM_HIGH_ANGLE_MODE_THIS_UPDATE(BOOL p0);
	void SET_FOLLOW_VEHICLE_CAM_HIGH_ANGLE_MODE_EVERY_UPDATE(BOOL p0, BOOL p1);
	BOOL SET_TABLE_GAMES_CAMERA_THIS_UPDATE(Hash hash);
	int GET_FOLLOW_VEHICLE_CAM_ZOOM_LEVEL();
	void SET_FOLLOW_VEHICLE_CAM_ZOOM_LEVEL(int zoomLevel);
	int GET_FOLLOW_VEHICLE_CAM_VIEW_MODE();
	void SET_FOLLOW_VEHICLE_CAM_VIEW_MODE(int viewMode);
	int GET_CAM_VIEW_MODE_FOR_CONTEXT(int context);
	void SET_CAM_VIEW_MODE_FOR_CONTEXT(int context, int viewMode);
	int GET_CAM_ACTIVE_VIEW_MODE_CONTEXT();
	void USE_VEHICLE_CAM_STUNT_SETTINGS_THIS_UPDATE();
	void USE_DEDICATED_STUNT_CAMERA_THIS_UPDATE(const char* camName);
	void FORCE_VEHICLE_CAM_STUNT_SETTINGS_THIS_UPDATE();
	void SET_FOLLOW_VEHICLE_CAM_SEAT_THIS_UPDATE(int seatIndex);
	BOOL IS_AIM_CAM_ACTIVE();
	BOOL IS_AIM_CAM_ACTIVE_IN_ACCURATE_MODE();
	BOOL IS_FIRST_PERSON_AIM_CAM_ACTIVE();
	void DISABLE_AIM_CAM_THIS_UPDATE();
	float GET_FIRST_PERSON_AIM_CAM_ZOOM_FACTOR();
	void SET_FIRST_PERSON_AIM_CAM_ZOOM_FACTOR(float zoomFactor);
	void SET_FIRST_PERSON_AIM_CAM_ZOOM_FACTOR_LIMITS_THIS_UPDATE(float p0, float p1);
	void SET_FIRST_PERSON_AIM_CAM_RELATIVE_HEADING_LIMITS_THIS_UPDATE(float p0, float p1);
	void SET_FIRST_PERSON_AIM_CAM_RELATIVE_PITCH_LIMITS_THIS_UPDATE(float p0, float p1);
	void SET_FIRST_PERSON_AIM_CAM_NEAR_CLIP_THIS_UPDATE(float p0);
	void SET_THIRD_PERSON_AIM_CAM_NEAR_CLIP_THIS_UPDATE(float p0);
	void SET_ALLOW_CUSTOM_VEHICLE_DRIVE_BY_CAM_THIS_UPDATE(BOOL p0);
	void FORCE_TIGHTSPACE_CUSTOM_FRAMING_THIS_UPDATE();
	Vector3 GET_FINAL_RENDERED_CAM_COORD();
	Vector3 GET_FINAL_RENDERED_CAM_ROT(int rotationOrder);
	Vector3 GET_FINAL_RENDERED_REMOTE_PLAYER_CAM_ROT(Player player, int rotationOrder);
	float GET_FINAL_RENDERED_CAM_FOV();
	float GET_FINAL_RENDERED_REMOTE_PLAYER_CAM_FOV(Player player);
	float GET_FINAL_RENDERED_CAM_NEAR_CLIP();
	float GET_FINAL_RENDERED_CAM_FAR_CLIP();
	float GET_FINAL_RENDERED_CAM_NEAR_DOF();
	float GET_FINAL_RENDERED_CAM_FAR_DOF();
	float GET_FINAL_RENDERED_CAM_MOTION_BLUR_STRENGTH();
	void SET_GAMEPLAY_COORD_HINT(float x, float y, float z, int duration, int blendOutDuration, int blendInDuration, int p6);
	void SET_GAMEPLAY_PED_HINT(Ped ped, float x1, float y1, float z1, BOOL p4, int duration, int blendOutDuration, int blendInDuration);
	void SET_GAMEPLAY_VEHICLE_HINT(Vehicle vehicle, float offsetX, float offsetY, float offsetZ, BOOL p4, int time, int easeInTime, int easeOutTime);
	void SET_GAMEPLAY_OBJECT_HINT(Object object, float xOffset, float yOffset, float zOffset, BOOL p4, int time, int easeInTime, int easeOutTime);
	void SET_GAMEPLAY_ENTITY_HINT(Entity entity, float xOffset, float yOffset, float zOffset, BOOL p4, int time, int easeInTime, int easeOutTime, int p8);
	BOOL IS_GAMEPLAY_HINT_ACTIVE();
	void STOP_GAMEPLAY_HINT(BOOL p0);
	void STOP_GAMEPLAY_HINT_BEING_CANCELLED_THIS_UPDATE(BOOL p0);
	void STOP_CODE_GAMEPLAY_HINT(BOOL p0);
	BOOL IS_CODE_GAMEPLAY_HINT_ACTIVE();
	void SET_GAMEPLAY_HINT_FOV(float FOV);
	void SET_GAMEPLAY_HINT_FOLLOW_DISTANCE_SCALAR(float value);
	void SET_GAMEPLAY_HINT_BASE_ORBIT_PITCH_OFFSET(float value);
	void SET_GAMEPLAY_HINT_CAMERA_RELATIVE_SIDE_OFFSET(float xOffset);
	void SET_GAMEPLAY_HINT_CAMERA_RELATIVE_VERTICAL_OFFSET(float yOffset);
	void SET_GAMEPLAY_HINT_CAMERA_BLEND_TO_FOLLOW_PED_MEDIUM_VIEW_MODE(BOOL toggle);
	void SET_CINEMATIC_BUTTON_ACTIVE(BOOL p0);
	BOOL IS_CINEMATIC_CAM_RENDERING();
	void SHAKE_CINEMATIC_CAM(const char* shakeType, float amount);
	BOOL IS_CINEMATIC_CAM_SHAKING();
	void SET_CINEMATIC_CAM_SHAKE_AMPLITUDE(float p0);
	void STOP_CINEMATIC_CAM_SHAKING(BOOL p0);
	void DISABLE_CINEMATIC_BONNET_CAMERA_THIS_UPDATE();
	void DISABLE_CINEMATIC_VEHICLE_IDLE_MODE_THIS_UPDATE();
	void INVALIDATE_CINEMATIC_VEHICLE_IDLE_MODE();
	void INVALIDATE_IDLE_CAM();
	BOOL IS_CINEMATIC_IDLE_CAM_RENDERING();
	BOOL IS_CINEMATIC_FIRST_PERSON_VEHICLE_INTERIOR_CAM_RENDERING();
	void CREATE_CINEMATIC_SHOT(Hash p0, int time, BOOL p2, Entity entity);
	BOOL IS_CINEMATIC_SHOT_ACTIVE(Hash p0);
	void STOP_CINEMATIC_SHOT(Hash p0);
	void FORCE_CINEMATIC_RENDERING_THIS_UPDATE(BOOL toggle);
	void SET_CINEMATIC_NEWS_CHANNEL_ACTIVE_THIS_UPDATE();
	void SET_CINEMATIC_MODE_ACTIVE(BOOL toggle);
	BOOL IS_IN_VEHICLE_MOBILE_PHONE_CAMERA_RENDERING();
	BOOL DISABLE_CINEMATIC_SLOW_MO_THIS_UPDATE();
	BOOL IS_BONNET_CINEMATIC_CAM_RENDERING();
	BOOL IS_CINEMATIC_CAM_INPUT_ACTIVE();
	void IGNORE_MENU_PREFERENCE_FOR_BONNET_CAMERA_THIS_UPDATE();
	void BYPASS_CUTSCENE_CAM_RENDERING_THIS_UPDATE();
	void STOP_CUTSCENE_CAM_SHAKING(Any p0);
	void SET_CUTSCENE_CAM_FAR_CLIP_THIS_UPDATE(float p0);
	Ped GET_FOCUS_PED_ON_SCREEN(float p0, int p1, float p2, float p3, float p4, float p5, float p6, int p7, int p8);
	void DISABLE_NEAR_CLIP_SCAN_THIS_UPDATE();
	void SET_CAM_DEATH_FAIL_EFFECT_STATE(int p0);
	void SET_FIRST_PERSON_FLASH_EFFECT_TYPE(Any p0);
	void SET_FIRST_PERSON_FLASH_EFFECT_VEHICLE_MODEL_NAME(const char* vehicleName);
	void SET_FIRST_PERSON_FLASH_EFFECT_VEHICLE_MODEL_HASH(Hash vehicleModel);
	BOOL IS_ALLOWED_INDEPENDENT_CAMERA_MODES();
	void CAMERA_PREVENT_COLLISION_SETTINGS_FOR_TRIPLEHEAD_IN_INTERIORS_THIS_UPDATE();
	float REPLAY_GET_MAX_DISTANCE_ALLOWED_FROM_PLAYER();
}

namespace CLOCK
{
	void SET_CLOCK_TIME(int hour, int minute, int second);
	void PAUSE_CLOCK(BOOL toggle);
	void ADVANCE_CLOCK_TIME_TO(int hour, int minute, int second);
	void ADD_TO_CLOCK_TIME(int hours, int minutes, int seconds);
	int GET_CLOCK_HOURS();
	int GET_CLOCK_MINUTES();
	int GET_CLOCK_SECONDS();
	void SET_CLOCK_DATE(int day, int month, int year);
	int GET_CLOCK_DAY_OF_WEEK();
	int GET_CLOCK_DAY_OF_MONTH();
	int GET_CLOCK_MONTH();
	int GET_CLOCK_YEAR();
	int GET_MILLISECONDS_PER_GAME_MINUTE();
	void GET_POSIX_TIME(int* year, int* month, int* day, int* hour, int* minute, int* second);
	void GET_UTC_TIME(int* year, int* month, int* day, int* hour, int* minute, int* second);
	void GET_LOCAL_TIME(int* year, int* month, int* day, int* hour, int* minute, int* second);
}

namespace CUTSCENE
{
	void REQUEST_CUTSCENE(const char* cutsceneName, int flags);
	void REQUEST_CUTSCENE_WITH_PLAYBACK_LIST(const char* cutsceneName, int playbackFlags, int flags);
	void REMOVE_CUTSCENE();
	BOOL HAS_CUTSCENE_LOADED();
	BOOL HAS_THIS_CUTSCENE_LOADED(const char* cutsceneName);
	void SET_SCRIPT_CAN_START_CUTSCENE(int threadId);
	BOOL CAN_REQUEST_ASSETS_FOR_CUTSCENE_ENTITY();
	BOOL IS_CUTSCENE_PLAYBACK_FLAG_SET(int flag);
	void SET_CUTSCENE_ENTITY_STREAMING_FLAGS(const char* cutsceneEntName, int p1, int p2);
	void REQUEST_CUT_FILE(const char* cutsceneName);
	BOOL HAS_CUT_FILE_LOADED(const char* cutsceneName);
	void REMOVE_CUT_FILE(const char* cutsceneName);
	int GET_CUT_FILE_CONCAT_COUNT(const char* cutsceneName);
	void START_CUTSCENE(int flags);
	void START_CUTSCENE_AT_COORDS(float x, float y, float z, int flags);
	void STOP_CUTSCENE(BOOL p0);
	void STOP_CUTSCENE_IMMEDIATELY();
	void SET_CUTSCENE_ORIGIN(float x, float y, float z, float p3, int p4);
	void SET_CUTSCENE_ORIGIN_AND_ORIENTATION(float x1, float y1, float z1, float x2, float y2, float z2, int p6);
	int GET_CUTSCENE_TIME();
	int GET_CUTSCENE_TOTAL_DURATION();
	int GET_CUTSCENE_END_TIME();
	int GET_CUTSCENE_PLAY_DURATION();
	BOOL WAS_CUTSCENE_SKIPPED();
	BOOL HAS_CUTSCENE_FINISHED();
	BOOL IS_CUTSCENE_ACTIVE();
	BOOL IS_CUTSCENE_PLAYING();
	int GET_CUTSCENE_SECTION_PLAYING();
	Entity GET_ENTITY_INDEX_OF_CUTSCENE_ENTITY(const char* cutsceneEntName, Hash modelHash);
	int GET_CUTSCENE_CONCAT_SECTION_PLAYING();
	BOOL IS_CUTSCENE_AUTHORIZED(const char* cutsceneName);
	int DOES_CUTSCENE_HANDLE_EXIST(int cutsceneHandle);
	void REGISTER_ENTITY_FOR_CUTSCENE(Ped cutscenePed, const char* cutsceneEntName, int p2, Hash modelHash, int p4);
	Entity GET_ENTITY_INDEX_OF_REGISTERED_ENTITY(const char* cutsceneEntName, Hash modelHash);
	void SET_VEHICLE_MODEL_PLAYER_WILL_EXIT_SCENE(Hash modelHash);
	void SET_CUTSCENE_TRIGGER_AREA(float x1, float y1, float z1, float x2, float y2, float z2);
	BOOL CAN_SET_ENTER_STATE_FOR_REGISTERED_ENTITY(const char* cutsceneEntName, Hash modelHash);
	BOOL CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY(const char* cutsceneEntName, Hash modelHash);
	BOOL CAN_SET_EXIT_STATE_FOR_CAMERA(BOOL p0);
	void SET_PAD_CAN_SHAKE_DURING_CUTSCENE(BOOL toggle);
	void SET_CUTSCENE_FADE_VALUES(BOOL p0, BOOL p1, BOOL p2, BOOL p3);
	void SET_CUTSCENE_MULTIHEAD_FADE(BOOL p0, BOOL p1, BOOL p2, BOOL p3);
	void SET_CUTSCENE_MULTIHEAD_FADE_MANUAL(BOOL p0);
	BOOL IS_MULTIHEAD_FADE_UP();
	void NETWORK_SET_MOCAP_CUTSCENE_CAN_BE_SKIPPED(BOOL p0);
	void SET_CAR_GENERATORS_CAN_UPDATE_DURING_CUTSCENE(BOOL p0);
	BOOL CAN_USE_MOBILE_PHONE_DURING_CUTSCENE();
	void SET_CUTSCENE_CAN_BE_SKIPPED(BOOL p0);
	void SET_CAN_DISPLAY_MINIMAP_DURING_CUTSCENE_THIS_UPDATE();
	void SET_CUTSCENE_PED_COMPONENT_VARIATION(const char* cutsceneEntName, int componentId, int drawableId, int textureId, Hash modelHash);
	void SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED(const char* cutsceneEntName, Ped ped, Hash modelHash);
	BOOL DOES_CUTSCENE_ENTITY_EXIST(const char* cutsceneEntName, Hash modelHash);
	void SET_CUTSCENE_PED_PROP_VARIATION(const char* cutsceneEntName, int componentId, int drawableId, int textureId, Hash modelHash);
	BOOL HAS_CUTSCENE_CUT_THIS_FRAME();
}

namespace DATAFILE
{
	void DATAFILE_WATCH_REQUEST_ID(int requestId);
	void DATAFILE_CLEAR_WATCH_LIST();
	BOOL DATAFILE_IS_VALID_REQUEST_ID(int index);
	BOOL DATAFILE_HAS_LOADED_FILE_DATA(int requestId);
	BOOL DATAFILE_HAS_VALID_FILE_DATA(int requestId);
	BOOL DATAFILE_SELECT_ACTIVE_FILE(int requestId, Any p1);
	BOOL DATAFILE_DELETE_REQUESTED_FILE(int requestId);
	BOOL UGC_CREATE_CONTENT(Any* data, int dataCount, const char* contentName, const char* description, const char* tagsCsv, const char* contentTypeName, BOOL publish, Any p7);
	BOOL UGC_CREATE_MISSION(const char* contentName, const char* description, const char* tagsCsv, const char* contentTypeName, BOOL publish, Any p5);
	BOOL UGC_UPDATE_CONTENT(const char* contentId, Any* data, int dataCount, const char* contentName, const char* description, const char* tagsCsv, const char* contentTypeName, Any p7);
	BOOL UGC_UPDATE_MISSION(const char* contentId, const char* contentName, const char* description, const char* tagsCsv, const char* contentTypeName, Any p5);
	BOOL UGC_SET_PLAYER_DATA(const char* contentId, float rating, const char* contentTypeName, Any p3);
	BOOL DATAFILE_SELECT_UGC_DATA(int p0, Any p1);
	BOOL DATAFILE_SELECT_UGC_STATS(int p0, BOOL p1, Any p2);
	BOOL DATAFILE_SELECT_UGC_PLAYER_DATA(int p0, Any p1);
	BOOL DATAFILE_SELECT_CREATOR_STATS(int p0, Any p1);
	BOOL DATAFILE_LOAD_OFFLINE_UGC(const char* filename, Any p1);
	void DATAFILE_CREATE(int p0);
	void DATAFILE_DELETE(int p0);
	void DATAFILE_STORE_MISSION_HEADER(int p0);
	void DATAFILE_FLUSH_MISSION_HEADER();
	Any* DATAFILE_GET_FILE_DICT(int p0);
	BOOL DATAFILE_START_SAVE_TO_CLOUD(const char* filename, Any p1);
	BOOL DATAFILE_UPDATE_SAVE_TO_CLOUD(BOOL* p0);
	BOOL DATAFILE_IS_SAVE_PENDING();
	BOOL DATAFILE_LOAD_OFFLINE_UGC_FOR_ADDITIONAL_DATA_FILE(Any p0, Any p1);
	void DATAFILE_DELETE_FOR_ADDITIONAL_DATA_FILE(Any p0);
	Any* DATAFILE_GET_FILE_DICT_FOR_ADDITIONAL_DATA_FILE(Any p0);
	void DATADICT_SET_BOOL(Any* objectData, const char* key, BOOL value);
	void DATADICT_SET_INT(Any* objectData, const char* key, int value);
	void DATADICT_SET_FLOAT(Any* objectData, const char* key, float value);
	void DATADICT_SET_STRING(Any* objectData, const char* key, const char* value);
	void DATADICT_SET_VECTOR(Any* objectData, const char* key, float valueX, float valueY, float valueZ);
	Any* DATADICT_CREATE_DICT(Any* objectData, const char* key);
	Any* DATADICT_CREATE_ARRAY(Any* objectData, const char* key);
	BOOL DATADICT_GET_BOOL(Any* objectData, const char* key);
	int DATADICT_GET_INT(Any* objectData, const char* key);
	float DATADICT_GET_FLOAT(Any* objectData, const char* key);
	const char* DATADICT_GET_STRING(Any* objectData, const char* key);
	Vector3 DATADICT_GET_VECTOR(Any* objectData, const char* key);
	Any* DATADICT_GET_DICT(Any* objectData, const char* key);
	Any* DATADICT_GET_ARRAY(Any* objectData, const char* key);
	int DATADICT_GET_TYPE(Any* objectData, const char* key);
	void DATAARRAY_ADD_BOOL(Any* arrayData, BOOL value);
	void DATAARRAY_ADD_INT(Any* arrayData, int value);
	void DATAARRAY_ADD_FLOAT(Any* arrayData, float value);
	void DATAARRAY_ADD_STRING(Any* arrayData, const char* value);
	void DATAARRAY_ADD_VECTOR(Any* arrayData, float valueX, float valueY, float valueZ);
	Any* DATAARRAY_ADD_DICT(Any* arrayData);
	BOOL DATAARRAY_GET_BOOL(Any* arrayData, int arrayIndex);
	int DATAARRAY_GET_INT(Any* arrayData, int arrayIndex);
	float DATAARRAY_GET_FLOAT(Any* arrayData, int arrayIndex);
	const char* DATAARRAY_GET_STRING(Any* arrayData, int arrayIndex);
	Vector3 DATAARRAY_GET_VECTOR(Any* arrayData, int arrayIndex);
	Any* DATAARRAY_GET_DICT(Any* arrayData, int arrayIndex);
	int DATAARRAY_GET_COUNT(Any* arrayData);
	int DATAARRAY_GET_TYPE(Any* arrayData, int arrayIndex);
}

namespace DECORATOR
{
	BOOL DECOR_SET_TIME(Entity entity, const char* propertyName, int timestamp);
	BOOL DECOR_SET_BOOL(Entity entity, const char* propertyName, BOOL value);
	BOOL DECOR_SET_FLOAT(Entity entity, const char* propertyName, float value);
	BOOL DECOR_SET_INT(Entity entity, const char* propertyName, int value);
	BOOL DECOR_GET_BOOL(Entity entity, const char* propertyName);
	float DECOR_GET_FLOAT(Entity entity, const char* propertyName);
	int DECOR_GET_INT(Entity entity, const char* propertyName);
	BOOL DECOR_EXIST_ON(Entity entity, const char* propertyName);
	BOOL DECOR_REMOVE(Entity entity, const char* propertyName);
	void DECOR_REGISTER(const char* propertyName, int type);
	BOOL DECOR_IS_REGISTERED_AS_TYPE(const char* propertyName, int type);
	void DECOR_REGISTER_LOCK();
}

namespace DLC
{
	BOOL ARE_ANY_CCS_PENDING();
	BOOL IS_DLC_PRESENT(Hash dlcHash);
	BOOL DLC_CHECK_CLOUD_DATA_CORRECT();
	int GET_EXTRACONTENT_CLOUD_RESULT();
	BOOL DLC_CHECK_COMPAT_PACK_CONFIGURATION();
	BOOL GET_EVER_HAD_BAD_PACK_ORDER();
	BOOL GET_IS_LOADING_SCREEN_ACTIVE();
	BOOL GET_IS_INITIAL_LOADING_SCREEN_ACTIVE();
	BOOL HAS_CLOUD_REQUESTS_FINISHED(BOOL* p0, int unused);
	void ON_ENTER_SP();
	void ON_ENTER_MP();
}

namespace ENTITY
{
	BOOL DOES_ENTITY_EXIST(Entity entity);
	BOOL DOES_ENTITY_BELONG_TO_THIS_SCRIPT(Entity entity, BOOL p1);
	BOOL DOES_ENTITY_HAVE_DRAWABLE(Entity entity);
	BOOL DOES_ENTITY_HAVE_PHYSICS(Entity entity);
	BOOL DOES_ENTITY_HAVE_SKELETON(Entity entity);
	BOOL DOES_ENTITY_HAVE_ANIM_DIRECTOR(Entity entity);
	BOOL HAS_ENTITY_ANIM_FINISHED(Entity entity, const char* animDict, const char* animName, int p3);
	BOOL HAS_ENTITY_BEEN_DAMAGED_BY_ANY_OBJECT(Entity entity);
	BOOL HAS_ENTITY_BEEN_DAMAGED_BY_ANY_PED(Entity entity);
	BOOL HAS_ENTITY_BEEN_DAMAGED_BY_ANY_VEHICLE(Entity entity);
	BOOL HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY(Entity entity1, Entity entity2, BOOL p2);
	BOOL HAS_ENTITY_CLEAR_LOS_TO_ENTITY(Entity entity1, Entity entity2, int traceType);
	BOOL HAS_ENTITY_CLEAR_LOS_TO_ENTITY_ADJUST_FOR_COVER(Entity entity1, Entity entity2, int traceType);
	BOOL HAS_ENTITY_CLEAR_LOS_TO_ENTITY_IN_FRONT(Entity entity1, Entity entity2);
	BOOL HAS_ENTITY_COLLIDED_WITH_ANYTHING(Entity entity);
	Entity GET_LAST_ENTITY_HIT_BY_ENTITY_(Entity entity);
	Hash GET_LAST_MATERIAL_HIT_BY_ENTITY(Entity entity);
	Vector3 GET_COLLISION_NORMAL_OF_LAST_HIT_FOR_ENTITY(Entity entity);
	void FORCE_ENTITY_AI_AND_ANIMATION_UPDATE(Entity entity);
	float GET_ENTITY_ANIM_CURRENT_TIME(Entity entity, const char* animDict, const char* animName);
	float GET_ENTITY_ANIM_TOTAL_TIME(Entity entity, const char* animDict, const char* animName);
	float GET_ANIM_DURATION(const char* animDict, const char* animName);
	Entity GET_ENTITY_ATTACHED_TO(Entity entity);
	Vector3 GET_ENTITY_COORDS(Entity entity, BOOL alive);
	Vector3 GET_ENTITY_FORWARD_VECTOR(Entity entity);
	float GET_ENTITY_FORWARD_X(Entity entity);
	float GET_ENTITY_FORWARD_Y(Entity entity);
	float GET_ENTITY_HEADING(Entity entity);
	float GET_ENTITY_HEADING_FROM_EULERS(Entity entity);
	int GET_ENTITY_HEALTH(Entity entity);
	int GET_ENTITY_MAX_HEALTH(Entity entity);
	void SET_ENTITY_MAX_HEALTH(Entity entity, int value);
	float GET_ENTITY_HEIGHT(Entity entity, float X, float Y, float Z, BOOL atTop, BOOL inWorldCoords);
	float GET_ENTITY_HEIGHT_ABOVE_GROUND(Entity entity);
	void GET_ENTITY_MATRIX(Entity entity, Vector3* forwardVector, Vector3* rightVector, Vector3* upVector, Vector3* position);
	Hash GET_ENTITY_MODEL(Entity entity);
	Vector3 GET_OFFSET_FROM_ENTITY_GIVEN_WORLD_COORDS(Entity entity, float posX, float posY, float posZ);
	Vector3 GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(Entity entity, float offsetX, float offsetY, float offsetZ);
	float GET_ENTITY_PITCH(Entity entity);
	void GET_ENTITY_QUATERNION(Entity entity, float* x, float* y, float* z, float* w);
	float GET_ENTITY_ROLL(Entity entity);
	Vector3 GET_ENTITY_ROTATION(Entity entity, int rotationOrder);
	Vector3 GET_ENTITY_ROTATION_VELOCITY(Entity entity);
	const char* GET_ENTITY_SCRIPT(Entity entity, ScrHandle* script);
	float GET_ENTITY_SPEED(Entity entity);
	Vector3 GET_ENTITY_SPEED_VECTOR(Entity entity, BOOL relative);
	float GET_ENTITY_UPRIGHT_VALUE(Entity entity);
	Vector3 GET_ENTITY_VELOCITY(Entity entity);
	Object GET_OBJECT_INDEX_FROM_ENTITY_INDEX(Entity entity);
	Ped GET_PED_INDEX_FROM_ENTITY_INDEX(Entity entity);
	Vehicle GET_VEHICLE_INDEX_FROM_ENTITY_INDEX(Entity entity);
	Vector3 GET_WORLD_POSITION_OF_ENTITY_BONE(Entity entity, int boneIndex);
	Player GET_NEAREST_PLAYER_TO_ENTITY(Entity entity);
	Player GET_NEAREST_PLAYER_TO_ENTITY_ON_TEAM(Entity entity, int team);
	int GET_NEAREST_PARTICIPANT_TO_ENTITY(Entity entity);
	int GET_ENTITY_TYPE(Entity entity);
	int GET_ENTITY_POPULATION_TYPE(Entity entity);
	BOOL IS_AN_ENTITY(ScrHandle handle);
	BOOL IS_ENTITY_A_PED(Entity entity);
	BOOL IS_ENTITY_A_MISSION_ENTITY(Entity entity);
	BOOL IS_ENTITY_A_VEHICLE(Entity entity);
	BOOL IS_ENTITY_AN_OBJECT(Entity entity);
	BOOL IS_ENTITY_AT_COORD(Entity entity, float xPos, float yPos, float zPos, float xSize, float ySize, float zSize, BOOL p7, BOOL p8, int p9);
	BOOL IS_ENTITY_AT_ENTITY(Entity entity1, Entity entity2, float xSize, float ySize, float zSize, BOOL p5, BOOL p6, int p7);
	BOOL IS_ENTITY_ATTACHED(Entity entity);
	BOOL IS_ENTITY_ATTACHED_TO_ANY_OBJECT(Entity entity);
	BOOL IS_ENTITY_ATTACHED_TO_ANY_PED(Entity entity);
	BOOL IS_ENTITY_ATTACHED_TO_ANY_VEHICLE(Entity entity);
	BOOL IS_ENTITY_ATTACHED_TO_ENTITY(Entity from, Entity to);
	BOOL IS_ENTITY_DEAD(Entity entity, BOOL p1);
	BOOL IS_ENTITY_IN_AIR(Entity entity);
	BOOL IS_ENTITY_IN_ANGLED_AREA(Entity entity, float x1, float y1, float z1, float x2, float y2, float z2, float width, BOOL debug, BOOL includeZ, Any p10);
	BOOL IS_ENTITY_IN_AREA(Entity entity, float x1, float y1, float z1, float x2, float y2, float z2, BOOL p7, BOOL p8, Any p9);
	BOOL IS_ENTITY_IN_ZONE(Entity entity, const char* zone);
	BOOL IS_ENTITY_IN_WATER(Entity entity);
	float GET_ENTITY_SUBMERGED_LEVEL(Entity entity);
	void SET_ENTITY_REQUIRES_MORE_EXPENSIVE_RIVER_CHECK(Entity entity, BOOL toggle);
	BOOL IS_ENTITY_ON_SCREEN(Entity entity);
	BOOL IS_ENTITY_PLAYING_ANIM(Entity entity, const char* animDict, const char* animName, int taskFlag);
	BOOL IS_ENTITY_STATIC(Entity entity);
	BOOL IS_ENTITY_TOUCHING_ENTITY(Entity entity, Entity targetEntity);
	BOOL IS_ENTITY_TOUCHING_MODEL(Entity entity, Hash modelHash);
	BOOL IS_ENTITY_UPRIGHT(Entity entity, float angle);
	BOOL IS_ENTITY_UPSIDEDOWN(Entity entity);
	BOOL IS_ENTITY_VISIBLE(Entity entity);
	BOOL IS_ENTITY_VISIBLE_TO_SCRIPT(Entity entity);
	BOOL IS_ENTITY_OCCLUDED(Entity entity);
	BOOL WOULD_ENTITY_BE_OCCLUDED(Hash entityModelHash, float x, float y, float z, BOOL p4);
	BOOL IS_ENTITY_WAITING_FOR_WORLD_COLLISION(Entity entity);
	void APPLY_FORCE_TO_ENTITY_CENTER_OF_MASS(Entity entity, int forceType, float x, float y, float z, BOOL p5, BOOL isDirectionRel, BOOL isForceRel, BOOL p8);
	void APPLY_FORCE_TO_ENTITY(Entity entity, int forceFlags, float x, float y, float z, float offX, float offY, float offZ, int boneIndex, BOOL isDirectionRel, BOOL ignoreUpVec, BOOL isForceRel, BOOL p12, BOOL p13);
	void ATTACH_ENTITY_TO_ENTITY(Entity entity1, Entity entity2, int boneIndex, float xPos, float yPos, float zPos, float xRot, float yRot, float zRot, BOOL p9, BOOL useSoftPinning, BOOL collision, BOOL isPed, int vertexIndex, BOOL fixedRot, Any p15);
	void ATTACH_ENTITY_BONE_TO_ENTITY_BONE(Entity entity1, Entity entity2, int boneIndex1, int boneIndex2, BOOL p4, BOOL p5);
	void ATTACH_ENTITY_BONE_TO_ENTITY_BONE_Y_FORWARD(Entity entity1, Entity entity2, int boneIndex1, int boneIndex2, BOOL p4, BOOL p5);
	void ATTACH_ENTITY_TO_ENTITY_PHYSICALLY(Entity entity1, Entity entity2, int boneIndex1, int boneIndex2, float xPos1, float yPos1, float zPos1, float xPos2, float yPos2, float zPos2, float xRot, float yRot, float zRot, float breakForce, BOOL fixedRot, BOOL p15, BOOL collision, BOOL p17, int p18);
	void ATTACH_ENTITY_TO_ENTITY_PHYSICALLY_OVERRIDE_INVERSE_MASS(Entity firstEntityIndex, Entity secondEntityIndex, int firstEntityBoneIndex, int secondEntityBoneIndex, float secondEntityOffsetX, float secondEntityOffsetY, float secondEntityOffsetZ, float firstEntityOffsetX, float firstEntityOffsetY, float firstEntityOffsetZ, float vecRotationX, float vecRotationY, float vecRotationZ, float physicalStrength, BOOL constrainRotation, BOOL doInitialWarp, BOOL collideWithEntity, BOOL addInitialSeperation, int rotOrder, float invMassScaleA, float invMassScaleB);
	void PROCESS_ENTITY_ATTACHMENTS(Entity entity);
	int GET_ENTITY_BONE_INDEX_BY_NAME(Entity entity, const char* boneName);
	void CLEAR_ENTITY_LAST_DAMAGE_ENTITY(Entity entity);
	void DELETE_ENTITY(Entity* entity);
	void DETACH_ENTITY(Entity entity, BOOL dynamic, BOOL collision);
	void FREEZE_ENTITY_POSITION(Entity entity, BOOL toggle);
	void SET_ENTITY_SHOULD_FREEZE_WAITING_ON_COLLISION(Entity entity, BOOL toggle);
	BOOL PLAY_ENTITY_ANIM(Entity entity, const char* animName, const char* animDict, float p3, BOOL loop, BOOL stayInAnim, BOOL p6, float delta, Any bitset);
	BOOL PLAY_SYNCHRONIZED_ENTITY_ANIM(Entity entity, int syncedScene, const char* animation, const char* propName, float p4, float p5, Any p6, float p7);
	BOOL PLAY_SYNCHRONIZED_MAP_ENTITY_ANIM(float x1, float y1, float z1, float x2, Any y2, float z2, const char* p6, const char* p7, float p8, float p9, Any p10, float p11);
	BOOL STOP_SYNCHRONIZED_MAP_ENTITY_ANIM(float x1, float y1, float z1, float x2, Any y2, float z2);
	BOOL STOP_ENTITY_ANIM(Entity entity, const char* animation, const char* animGroup, float p3);
	BOOL STOP_SYNCHRONIZED_ENTITY_ANIM(Entity entity, float p1, BOOL p2);
	BOOL HAS_ANIM_EVENT_FIRED(Entity entity, Hash actionHash);
	BOOL FIND_ANIM_EVENT_PHASE(const char* animDictionary, const char* animName, const char* p2, Any* p3, Any* p4);
	void SET_ENTITY_ANIM_CURRENT_TIME(Entity entity, const char* animDictionary, const char* animName, float time);
	void SET_ENTITY_ANIM_SPEED(Entity entity, const char* animDictionary, const char* animName, float speedMultiplier);
	void SET_ENTITY_AS_MISSION_ENTITY(Entity entity, BOOL p1, BOOL p2);
	void SET_ENTITY_AS_NO_LONGER_NEEDED(Entity* entity);
	void SET_PED_AS_NO_LONGER_NEEDED(Ped* ped);
	void SET_VEHICLE_AS_NO_LONGER_NEEDED(Vehicle* vehicle);
	void SET_OBJECT_AS_NO_LONGER_NEEDED(Object* object);
	void SET_ENTITY_CAN_BE_DAMAGED(Entity entity, BOOL toggle);
	BOOL GET_ENTITY_CAN_BE_DAMAGED(Entity entity);
	void SET_ENTITY_CAN_BE_DAMAGED_BY_RELATIONSHIP_GROUP(Entity entity, BOOL bCanBeDamaged, int relGroup);
	void SET_ENTITY_CAN_ONLY_BE_DAMAGED_BY_SCRIPT_PARTICIPANTS(Entity entity, BOOL toggle);
	void SET_ENTITY_CAN_BE_TARGETED_WITHOUT_LOS(Entity entity, BOOL toggle);
	void SET_ENTITY_COLLISION(Entity entity, BOOL toggle, BOOL keepPhysics);
	BOOL GET_ENTITY_COLLISION_DISABLED(Entity entity);
	void SET_ENTITY_COMPLETELY_DISABLE_COLLISION(Entity entity, BOOL toggle, BOOL keepPhysics);
	void SET_ENTITY_COORDS(Entity entity, float xPos, float yPos, float zPos, BOOL xAxis, BOOL yAxis, BOOL zAxis, BOOL clearArea);
	void SET_ENTITY_COORDS_WITHOUT_PLANTS_RESET(Entity entity, float xPos, float yPos, float zPos, BOOL alive, BOOL deadFlag, BOOL ragdollFlag, BOOL clearArea);
	void SET_ENTITY_COORDS_NO_OFFSET(Entity entity, float xPos, float yPos, float zPos, BOOL xAxis, BOOL yAxis, BOOL zAxis);
	void SET_ENTITY_DYNAMIC(Entity entity, BOOL toggle);
	void SET_ENTITY_HEADING(Entity entity, float heading);
	void SET_ENTITY_HEALTH(Entity entity, int health, int p2);
	void SET_ENTITY_INVINCIBLE(Entity entity, BOOL toggle);
	void SET_ENTITY_IS_TARGET_PRIORITY(Entity entity, BOOL p1, float p2);
	void SET_ENTITY_LIGHTS(Entity entity, BOOL toggle);
	void SET_ENTITY_LOAD_COLLISION_FLAG(Entity entity, BOOL toggle, Any p2);
	BOOL HAS_COLLISION_LOADED_AROUND_ENTITY(Entity entity);
	void SET_ENTITY_MAX_SPEED(Entity entity, float speed);
	void SET_ENTITY_ONLY_DAMAGED_BY_PLAYER(Entity entity, BOOL toggle);
	void SET_ENTITY_ONLY_DAMAGED_BY_RELATIONSHIP_GROUP(Entity entity, BOOL p1, Any p2);
	void SET_ENTITY_PROOFS(Entity entity, BOOL bulletProof, BOOL fireProof, BOOL explosionProof, BOOL collisionProof, BOOL meleeProof, BOOL steamProof, BOOL p7, BOOL waterProof);
	BOOL GET_ENTITY_PROOFS(Entity entity, BOOL* bulletProof, BOOL* fireProof, BOOL* explosionProof, BOOL* collisionProof, BOOL* meleeProof, BOOL* steamProof, BOOL* p7, BOOL* drownProof);
	void SET_ENTITY_QUATERNION(Entity entity, float x, float y, float z, float w);
	void SET_ENTITY_RECORDS_COLLISIONS(Entity entity, BOOL toggle);
	void SET_ENTITY_ROTATION(Entity entity, float pitch, float roll, float yaw, int rotationOrder, BOOL p5);
	void SET_ENTITY_VISIBLE(Entity entity, BOOL toggle, BOOL p2);
	void SET_ENTITY_WATER_REFLECTION_FLAG(Entity entity, BOOL toggle);
	void SET_ENTITY_MIRROR_REFLECTION_FLAG(Entity entity, BOOL p1);
	void SET_ENTITY_VELOCITY(Entity entity, float x, float y, float z);
	void SET_ENTITY_ANGULAR_VELOCITY(Entity entity, float x, float y, float z);
	void SET_ENTITY_HAS_GRAVITY(Entity entity, BOOL toggle);
	void SET_ENTITY_LOD_DIST(Entity entity, int value);
	int GET_ENTITY_LOD_DIST(Entity entity);
	void SET_ENTITY_ALPHA(Entity entity, int alphaLevel, BOOL skin);
	int GET_ENTITY_ALPHA(Entity entity);
	void RESET_ENTITY_ALPHA(Entity entity);
	void RESET_PICKUP_ENTITY_GLOW(Entity entity);
	void SET_PICKUP_COLLIDES_WITH_PROJECTILES(Any p0, Any p1);
	void SET_ENTITY_SORT_BIAS(Entity entity, float p1);
	void SET_ENTITY_ALWAYS_PRERENDER(Entity entity, BOOL toggle);
	void SET_ENTITY_RENDER_SCORCHED(Entity entity, BOOL toggle);
	void SET_ENTITY_TRAFFICLIGHT_OVERRIDE(Entity entity, int state);
	void SET_ENTITY_IS_IN_VEHICLE(Entity entity);
	void CREATE_MODEL_SWAP(float x, float y, float z, float radius, Hash originalModel, Hash newModel, BOOL p6);
	void REMOVE_MODEL_SWAP(float x, float y, float z, float radius, Hash originalModel, Hash newModel, BOOL p6);
	void CREATE_MODEL_HIDE(float x, float y, float z, float radius, Hash modelHash, BOOL p5);
	void CREATE_MODEL_HIDE_EXCLUDING_SCRIPT_OBJECTS(float x, float y, float z, float radius, Hash modelHash, BOOL p5);
	void REMOVE_MODEL_HIDE(float x, float y, float z, float radius, Hash modelHash, BOOL p5);
	void CREATE_FORCED_OBJECT(float x, float y, float z, Any p3, Hash modelHash, BOOL p5);
	void REMOVE_FORCED_OBJECT(float x, float y, float z, float p3, Hash modelHash);
	void SET_ENTITY_NO_COLLISION_ENTITY(Entity entity1, Entity entity2, BOOL thisFrameOnly);
	void SET_ENTITY_MOTION_BLUR(Entity entity, BOOL toggle);
	void SET_CAN_AUTO_VAULT_ON_ENTITY(Entity entity, BOOL toggle);
	void SET_CAN_CLIMB_ON_ENTITY(Entity entity, BOOL toggle);
	void SET_WAIT_FOR_COLLISIONS_BEFORE_PROBE(Entity entity, BOOL toggle);
	void SET_ENTITY_NOWEAPONDECALS(Entity entity, BOOL p1);
	void SET_ENTITY_USE_MAX_DISTANCE_FOR_WATER_REFLECTION(Entity entity, BOOL p1);
	Vector3 GET_ENTITY_BONE_ROTATION(Entity entity, int boneIndex);
	Vector3 GET_ENTITY_BONE_POSTION(Entity entity, int boneIndex);
	Vector3 GET_ENTITY_BONE_OBJECT_ROTATION(Entity entity, int boneIndex);
	Vector3 GET_ENTITY_BONE_OBJECT_POSTION(Entity entity, int boneIndex);
	int GET_ENTITY_BONE_COUNT(Entity entity);
	void ENABLE_ENTITY_BULLET_COLLISION(Entity entity);
	void SET_ENTITY_CAN_ONLY_BE_DAMAGED_BY_ENTITY(Entity entity1, Entity entity2);
	void SET_ENTITY_CANT_CAUSE_COLLISION_DAMAGED_ENTITY(Entity entity1, Entity entity2);
	void SET_ALLOW_MIGRATE_TO_SPECTATOR(Entity entity, Any p1);
	Entity GET_ENTITY_OF_TYPE_ATTACHED_TO_ENTITY(Entity entity, Hash modelHash);
	void SET_PICK_UP_BY_CARGOBOB_DISABLED(Entity entity, BOOL toggle);
}

namespace EVENT
{
	void SET_DECISION_MAKER(Ped ped, Hash name);
	void CLEAR_DECISION_MAKER_EVENT_RESPONSE(Hash name, int eventType);
	void BLOCK_DECISION_MAKER_EVENT(Hash name, int eventType);
	void UNBLOCK_DECISION_MAKER_EVENT(Hash name, int eventType);
	int ADD_SHOCKING_EVENT_AT_POSITION(int eventType, float x, float y, float z, float duration);
	int ADD_SHOCKING_EVENT_FOR_ENTITY(int eventType, Entity entity, float duration);
	BOOL IS_SHOCKING_EVENT_IN_SPHERE(int eventType, float x, float y, float z, float radius);
	BOOL REMOVE_SHOCKING_EVENT(ScrHandle event);
	void REMOVE_ALL_SHOCKING_EVENTS(BOOL p0);
	void REMOVE_SHOCKING_EVENT_SPAWN_BLOCKING_AREAS();
	void SUPPRESS_SHOCKING_EVENTS_NEXT_FRAME();
	void SUPPRESS_SHOCKING_EVENT_TYPE_NEXT_FRAME(int eventType);
	void SUPPRESS_AGITATION_EVENTS_NEXT_FRAME();
}

namespace FILES
{
	int GET_NUM_TATTOO_SHOP_DLC_ITEMS(int character);
	BOOL GET_TATTOO_SHOP_DLC_ITEM_DATA(int characterType, int decorationIndex, Any* outComponent);
	int GET_TATTOO_SHOP_DLC_ITEM_INDEX(Hash overlayHash, Any p1, int character);
	void INIT_SHOP_PED_COMPONENT(Any* outComponent);
	void INIT_SHOP_PED_PROP(Any* outProp);
	int SETUP_SHOP_PED_APPAREL_QUERY(int p0, int p1, int p2, int p3);
	int SETUP_SHOP_PED_APPAREL_QUERY_TU(int character, int p1, int p2, BOOL p3, int p4, int componentId);
	void GET_SHOP_PED_QUERY_COMPONENT(int componentId, Any* outComponent);
	int GET_SHOP_PED_QUERY_COMPONENT_INDEX(Hash componentHash);
	void GET_SHOP_PED_COMPONENT(Hash componentHash, Any* outComponent);
	void GET_SHOP_PED_QUERY_PROP(int componentId, Any* outProp);
	int GET_SHOP_PED_QUERY_PROP_INDEX(Hash componentHash);
	void GET_SHOP_PED_PROP(Hash componentHash, Any* outProp);
	Hash GET_HASH_NAME_FOR_COMPONENT(Entity entity, int componentId, int drawableVariant, int textureVariant);
	Hash GET_HASH_NAME_FOR_PROP(Entity entity, int componentId, int propIndex, int propTextureIndex);
	int GET_SHOP_PED_APPAREL_VARIANT_COMPONENT_COUNT(Hash componentHash);
	int GET_SHOP_PED_APPAREL_VARIANT_PROP_COUNT(Hash propHash);
	void GET_VARIANT_COMPONENT(Hash componentHash, int variantComponentIndex, Hash* nameHash, int* enumValue, int* componentType);
	void GET_VARIANT_PROP(Hash componentHash, int variantPropIndex, Hash* nameHash, int* enumValue, int* anchorPoint);
	int GET_SHOP_PED_APPAREL_FORCED_COMPONENT_COUNT(Hash componentHash);
	int GET_SHOP_PED_APPAREL_FORCED_PROP_COUNT(Hash componentHash);
	void GET_FORCED_COMPONENT(Hash componentHash, int forcedComponentIndex, Hash* nameHash, int* enumValue, int* componentType);
	void GET_FORCED_PROP(Hash componentHash, int forcedPropIndex, Hash* nameHash, int* enumValue, int* anchorPoint);
	BOOL DOES_SHOP_PED_APPAREL_HAVE_RESTRICTION_TAG(Hash componentHash, Hash restrictionTagHash, int componentId);
	BOOL DOES_CURRENT_PED_COMPONENT_HAVE_RESTRICTION_TAG(Ped ped, int componentId, Hash restrictionTagHash);
	BOOL DOES_CURRENT_PED_PROP_HAVE_RESTRICTION_TAG(Ped ped, int componentId, Hash restrictionTagHash);
	int SETUP_SHOP_PED_OUTFIT_QUERY(int character, BOOL p1);
	void GET_SHOP_PED_QUERY_OUTFIT(int outfitIndex, Any* outfit);
	void GET_SHOP_PED_OUTFIT(Any p0, Any* p1);
	int GET_SHOP_PED_OUTFIT_LOCATE(Any p0);
	BOOL GET_SHOP_PED_OUTFIT_PROP_VARIANT(Hash outfitHash, int variantIndex, Any* outPropVariant);
	BOOL GET_SHOP_PED_OUTFIT_COMPONENT_VARIANT(Hash outfitHash, int variantIndex, Any* outComponentVariant);
	int GET_NUM_DLC_VEHICLES();
	Hash GET_DLC_VEHICLE_MODEL(int dlcVehicleIndex);
	BOOL GET_DLC_VEHICLE_DATA(int dlcVehicleIndex, Any* outData);
	int GET_DLC_VEHICLE_FLAGS(int dlcVehicleIndex);
	int GET_NUM_DLC_WEAPONS();
	int GET_NUM_DLC_WEAPONS_SP();
	BOOL GET_DLC_WEAPON_DATA(int dlcWeaponIndex, Any* outData);
	BOOL GET_DLC_WEAPON_DATA_SP(int dlcWeaponIndex, Any* outData);
	int GET_NUM_DLC_WEAPON_COMPONENTS(int dlcWeaponIndex);
	int GET_NUM_DLC_WEAPON_COMPONENTS_SP(int dlcWeaponIndex);
	BOOL GET_DLC_WEAPON_COMPONENT_DATA(int dlcWeaponIndex, int dlcWeapCompIndex, Any* ComponentDataPtr);
	BOOL GET_DLC_WEAPON_COMPONENT_DATA_SP(int dlcWeaponIndex, int dlcWeapCompIndex, Any* ComponentDataPtr);
	BOOL IS_CONTENT_ITEM_LOCKED(Hash itemHash);
	BOOL IS_DLC_VEHICLE_MOD(Hash hash);
	Hash GET_DLC_VEHICLE_MOD_LOCK_HASH(Hash hash);
	void EXECUTE_CONTENT_CHANGESET_GROUP_FOR_ALL(Hash hash);
	void REVERT_CONTENT_CHANGESET_GROUP_FOR_ALL(Hash hash);
}

namespace FIRE
{
	FireId START_SCRIPT_FIRE(float X, float Y, float Z, int maxChildren, BOOL isGasFire);
	void REMOVE_SCRIPT_FIRE(FireId fireHandle);
	FireId START_ENTITY_FIRE(Entity entity);
	void STOP_ENTITY_FIRE(Entity entity);
	BOOL IS_ENTITY_ON_FIRE(Entity entity);
	int GET_NUMBER_OF_FIRES_IN_RANGE(float x, float y, float z, float radius);
	void SET_FLAMMABILITY_MULTIPLIER(float p0);
	void STOP_FIRE_IN_RANGE(float x, float y, float z, float radius);
	BOOL GET_CLOSEST_FIRE_POS(Vector3* outPosition, float x, float y, float z);
	void ADD_EXPLOSION(float x, float y, float z, int explosionType, float damageScale, BOOL isAudible, BOOL isInvisible, float cameraShake, BOOL noDamage);
	void ADD_OWNED_EXPLOSION(Ped ped, float x, float y, float z, int explosionType, float damageScale, BOOL isAudible, BOOL isInvisible, float cameraShake);
	void ADD_EXPLOSION_WITH_USER_VFX(float x, float y, float z, int explosionType, Hash explosionFx, float damageScale, BOOL isAudible, BOOL isInvisible, float cameraShake);
	BOOL IS_EXPLOSION_IN_AREA(int explosionType, float x1, float y1, float z1, float x2, float y2, float z2);
	BOOL IS_EXPLOSION_ACTIVE_IN_AREA(int explosionType, float x1, float y1, float z1, float x2, float y2, float z2);
	BOOL IS_EXPLOSION_IN_SPHERE(int explosionType, float x, float y, float z, float radius);
	Entity GET_OWNER_OF_EXPLOSION_IN_SPHERE(int explosionType, float x, float y, float z, float radius);
	BOOL IS_EXPLOSION_IN_ANGLED_AREA(int explosionType, float x1, float y1, float z1, float x2, float y2, float z2, float width);
	Entity GET_OWNER_OF_EXPLOSION_IN_ANGLED_AREA(int explosionType, float x1, float y1, float z1, float x2, float y2, float z2, float radius);
}

namespace GRAPHICS
{
	void SET_DEBUG_LINES_AND_SPHERES_DRAWING_ACTIVE(BOOL enabled);
	void DRAW_DEBUG_LINE(float x1, float y1, float z1, float x2, float y2, float z2, int r, int g, int b, int alpha);
	void DRAW_DEBUG_LINE_WITH_TWO_COLOURS(float x1, float y1, float z1, float x2, float y2, float z2, int r1, int g1, int b1, int r2, int g2, int b2, int alpha1, int alpha2);
	void DRAW_DEBUG_SPHERE(float x, float y, float z, float radius, int red, int green, int blue, int alpha);
	void DRAW_DEBUG_BOX(float x1, float y1, float z1, float x2, float y2, float z2, int r, int g, int b, int alpha);
	void DRAW_DEBUG_CROSS(float x, float y, float z, float size, int red, int green, int blue, int alpha);
	void DRAW_DEBUG_TEXT(const char* text, float x, float y, float z, int red, int green, int blue, int alpha);
	void DRAW_DEBUG_TEXT_2D(const char* text, float x, float y, float z, int red, int green, int blue, int alpha);
	void DRAW_LINE(float x1, float y1, float z1, float x2, float y2, float z2, int red, int green, int blue, int alpha);
	void DRAW_POLY(float x1, float y1, float z1, float x2, float y2, float z2, float x3, float y3, float z3, int red, int green, int blue, int alpha);
	void DRAW_TEXTURED_POLY(float x1, float y1, float z1, float x2, float y2, float z2, float x3, float y3, float z3, int red, int green, int blue, int alpha, const char* textureDict, const char* textureName, float u1, float v1, float w1, float u2, float v2, float w2, float u3, float v3, float w3);
	void DRAW_TEXTURED_POLY_WITH_THREE_COLOURS(float x1, float y1, float z1, float x2, float y2, float z2, float x3, float y3, float z3, float red1, float green1, float blue1, int alpha1, float red2, float green2, float blue2, int alpha2, float red3, float green3, float blue3, int alpha3, const char* textureDict, const char* textureName, float u1, float v1, float w1, float u2, float v2, float w2, float u3, float v3, float w3);
	void DRAW_BOX(float x1, float y1, float z1, float x2, float y2, float z2, int red, int green, int blue, int alpha);
	void SET_BACKFACECULLING(BOOL toggle);
	void SET_DEPTHWRITING(BOOL toggle);
	BOOL BEGIN_TAKE_MISSION_CREATOR_PHOTO();
	int GET_STATUS_OF_TAKE_MISSION_CREATOR_PHOTO();
	void FREE_MEMORY_FOR_MISSION_CREATOR_PHOTO();
	BOOL LOAD_MISSION_CREATOR_PHOTO(Any* p0, Any p1, Any p2, Any p3);
	int GET_STATUS_OF_LOAD_MISSION_CREATOR_PHOTO(Any* p0);
	BOOL BEGIN_CREATE_MISSION_CREATOR_PHOTO_PREVIEW();
	int GET_STATUS_OF_CREATE_MISSION_CREATOR_PHOTO_PREVIEW();
	void FREE_MEMORY_FOR_MISSION_CREATOR_PHOTO_PREVIEW();
	BOOL BEGIN_TAKE_HIGH_QUALITY_PHOTO();
	int GET_STATUS_OF_TAKE_HIGH_QUALITY_PHOTO();
	void FREE_MEMORY_FOR_HIGH_QUALITY_PHOTO();
	void SET_TAKEN_PHOTO_IS_MUGSHOT(BOOL toggle);
	void SET_ARENA_THEME_AND_VARIATION_FOR_TAKEN_PHOTO(Any p0, int p1);
	void SET_ON_ISLAND_X_FOR_TAKEN_PHOTO(Any p0);
	BOOL SAVE_HIGH_QUALITY_PHOTO(int unused);
	int GET_STATUS_OF_SAVE_HIGH_QUALITY_PHOTO();
	BOOL BEGIN_CREATE_LOW_QUALITY_COPY_OF_PHOTO(Any p0);
	int GET_STATUS_OF_CREATE_LOW_QUALITY_COPY_OF_PHOTO(int p0);
	void FREE_MEMORY_FOR_LOW_QUALITY_PHOTO();
	void DRAW_LOW_QUALITY_PHOTO_TO_PHONE(BOOL p0, BOOL p1);
	int GET_MAXIMUM_NUMBER_OF_PHOTOS();
	int GET_MAXIMUM_NUMBER_OF_CLOUD_PHOTOS();
	int GET_CURRENT_NUMBER_OF_CLOUD_PHOTOS();
	BOOL QUEUE_OPERATION_TO_CREATE_SORTED_LIST_OF_PHOTOS(Any p0);
	int GET_STATUS_OF_SORTED_LIST_OPERATION(Any p0);
	void CLEAR_STATUS_OF_SORTED_LIST_OPERATION();
	BOOL DOES_THIS_PHOTO_SLOT_CONTAIN_A_VALID_PHOTO(Any p0);
	BOOL LOAD_HIGH_QUALITY_PHOTO(Any p0);
	int GET_LOAD_HIGH_QUALITY_PHOTO_STATUS(int p0);
	void DRAW_LIGHT_WITH_RANGEEX(float x, float y, float z, int r, int g, int b, float range, float intensity, float shadow);
	void DRAW_LIGHT_WITH_RANGE(float posX, float posY, float posZ, int colorR, int colorG, int colorB, float range, float intensity);
	void DRAW_SPOT_LIGHT(float posX, float posY, float posZ, float dirX, float dirY, float dirZ, int colorR, int colorG, int colorB, float distance, float brightness, float hardness, float radius, float falloff);
	void DRAW_SHADOWED_SPOT_LIGHT(float posX, float posY, float posZ, float dirX, float dirY, float dirZ, int colorR, int colorG, int colorB, float distance, float brightness, float roundness, float radius, float falloff, int shadowId);
	void FADE_UP_PED_LIGHT(float p0);
	void UPDATE_LIGHTS_ON_ENTITY(Entity entity);
	void SET_LIGHT_OVERRIDE_MAX_INTENSITY_SCALE(Any p0);
	float GET_LIGHT_OVERRIDE_MAX_INTENSITY_SCALE();
	void DRAW_MARKER(int type, float posX, float posY, float posZ, float dirX, float dirY, float dirZ, float rotX, float rotY, float rotZ, float scaleX, float scaleY, float scaleZ, int red, int green, int blue, int alpha, BOOL bobUpAndDown, BOOL faceCamera, int p19, BOOL rotate, const char* textureDict, const char* textureName, BOOL drawOnEnts);
	void DRAW_MARKER_EX(int type, float posX, float posY, float posZ, float dirX, float dirY, float dirZ, float rotX, float rotY, float rotZ, float scaleX, float scaleY, float scaleZ, int red, int green, int blue, int alpha, BOOL bobUpAndDown, BOOL faceCamera, Any p19, BOOL rotate, const char* textureDict, const char* textureName, BOOL drawOnEnts, BOOL p24, BOOL p25);
	void DRAW_MARKER_SPHERE(float x, float y, float z, float radius, int red, int green, int blue, float alpha);
	int CREATE_CHECKPOINT(int type, float posX1, float posY1, float posZ1, float posX2, float posY2, float posZ2, float diameter, int red, int green, int blue, int alpha, int reserved);
	void SET_CHECKPOINT_INSIDE_CYLINDER_HEIGHT_SCALE(int checkpoint, float scale);
	void SET_CHECKPOINT_INSIDE_CYLINDER_SCALE(int checkpoint, float scale);
	void SET_CHECKPOINT_CYLINDER_HEIGHT(int checkpoint, float nearHeight, float farHeight, float radius);
	void SET_CHECKPOINT_RGBA(int checkpoint, int red, int green, int blue, int alpha);
	void SET_CHECKPOINT_RGBA2(int checkpoint, int red, int green, int blue, int alpha);
	void SET_CHECKPOINT_CLIPPLANE_WITH_POS_NORM(int checkpoint, float posX, float posY, float posZ, float unkX, float unkY, float unkZ);
	void SET_CHECKPOINT_FORCE_OLD_ARROW_POINTING(int checkpoint);
	void SET_CHECKPOINT_DECAL_ROT_ALIGNED_TO_CAMERA_ROT(int checkpoint);
	void SET_CHECKPOINT_FORCE_DIRECTION(int checkpoint);
	void SET_CHECKPOINT_DIRECTION(int checkpoint, float posX, float posY, float posZ);
	void DELETE_CHECKPOINT(int checkpoint);
	void DONT_RENDER_IN_GAME_UI(BOOL p0);
	void FORCE_RENDER_IN_GAME_UI(BOOL toggle);
	void REQUEST_STREAMED_TEXTURE_DICT(const char* textureDict, BOOL p1);
	BOOL HAS_STREAMED_TEXTURE_DICT_LOADED(const char* textureDict);
	void SET_STREAMED_TEXTURE_DICT_AS_NO_LONGER_NEEDED(const char* textureDict);
	void DRAW_RECT(float x, float y, float width, float height, int r, int g, int b, int a, BOOL p8);
	void SET_SCRIPT_GFX_DRAW_BEHIND_PAUSEMENU(BOOL toggle);
	void SET_SCRIPT_GFX_DRAW_ORDER(int drawOrder);
	void SET_SCRIPT_GFX_ALIGN(int horizontalAlign, int verticalAlign);
	void RESET_SCRIPT_GFX_ALIGN();
	void SET_SCRIPT_GFX_ALIGN_PARAMS(float x, float y, float w, float h);
	void GET_SCRIPT_GFX_ALIGN_POSITION(float x, float y, float* calculatedX, float* calculatedY);
	float GET_SAFE_ZONE_SIZE();
	void DRAW_SPRITE(const char* textureDict, const char* textureName, float screenX, float screenY, float width, float height, float heading, int red, int green, int blue, int alpha, BOOL p11, Any p12);
	void DRAW_SPRITE_ARX(const char* textureDict, const char* textureName, float x, float y, float width, float height, float p6, int red, int green, int blue, int alpha, Any p11, Any p12);
	void DRAW_SPRITE_NAMED_RENDERTARGET(const char* textureDict, const char* textureName, float screenX, float screenY, float width, float height, float heading, int red, int green, int blue, int alpha, Any p11);
	void DRAW_SPRITE_ARX_WITH_UV(const char* textureDict, const char* textureName, float x, float y, float width, float height, float u1, float v1, float u2, float v2, float heading, int red, int green, int blue, int alpha, Any p15);
	int ADD_ENTITY_ICON(Entity entity, const char* icon);
	void SET_ENTITY_ICON_VISIBILITY(Entity entity, BOOL toggle);
	void SET_ENTITY_ICON_COLOR(Entity entity, int red, int green, int blue, int alpha);
	void SET_DRAW_ORIGIN(float x, float y, float z, BOOL p3);
	void CLEAR_DRAW_ORIGIN();
	int SET_BINK_MOVIE(const char* name);
	void PLAY_BINK_MOVIE(int binkMovie);
	void STOP_BINK_MOVIE(int binkMovie);
	void RELEASE_BINK_MOVIE(int binkMovie);
	void DRAW_BINK_MOVIE(int binkMovie, float p1, float p2, float p3, float p4, float p5, int r, int g, int b, int a);
	void SET_BINK_MOVIE_TIME(int binkMovie, float progress);
	float GET_BINK_MOVIE_TIME(int binkMovie);
	void SET_BINK_MOVIE_VOLUME(int binkMovie, float value);
	void ATTACH_TV_AUDIO_TO_ENTITY(Entity entity);
	void SET_BINK_MOVIE_AUDIO_FRONTEND(int binkMovie, BOOL p1);
	void SET_TV_AUDIO_FRONTEND(BOOL toggle);
	void SET_BINK_SHOULD_SKIP(int binkMovie, BOOL bShouldSkip);
	int LOAD_MOVIE_MESH_SET(const char* movieMeshSetName);
	void RELEASE_MOVIE_MESH_SET(int movieMeshSet);
	int QUERY_MOVIE_MESH_SET_STATE(Any p0);
	void GET_SCREEN_RESOLUTION(int* x, int* y);
	void GET_ACTUAL_SCREEN_RESOLUTION(int* x, int* y);
	float GET_ASPECT_RATIO(BOOL b);
	float GET_SCREEN_ASPECT_RATIO();
	BOOL GET_IS_WIDESCREEN();
	BOOL GET_IS_HIDEF();
	void ADJUST_NEXT_POS_SIZE_AS_NORMALIZED_16_9();
	void SET_NIGHTVISION(BOOL toggle);
	BOOL GET_REQUESTINGNIGHTVISION();
	BOOL GET_USINGNIGHTVISION();
	void SET_EXPOSURETWEAK(BOOL toggle);
	void FORCE_EXPOSURE_READBACK(BOOL toggle);
	void OVERRIDE_NIGHTVISION_LIGHT_RANGE(float p0);
	void SET_NOISEOVERIDE(BOOL toggle);
	void SET_NOISINESSOVERIDE(float value);
	BOOL GET_SCREEN_COORD_FROM_WORLD_COORD(float worldX, float worldY, float worldZ, float* screenX, float* screenY);
	Vector3 GET_TEXTURE_RESOLUTION(const char* textureDict, const char* textureName);
	BOOL OVERRIDE_PED_CREW_LOGO_TEXTURE(Ped ped, const char* txd, const char* txn);
	void SET_DISTANCE_BLUR_STRENGTH_OVERRIDE(float p0);
	void SET_FLASH(float p0, float p1, float fadeIn, float duration, float fadeOut);
	void DISABLE_OCCLUSION_THIS_FRAME();
	void SET_ARTIFICIAL_LIGHTS_STATE(BOOL state);
	void SET_ARTIFICIAL_VEHICLE_LIGHTS_STATE(BOOL toggle);
	void DISABLE_HDTEX_THIS_FRAME();
	int CREATE_TRACKED_POINT();
	void SET_TRACKED_POINT_INFO(int point, float x, float y, float z, float radius);
	BOOL IS_TRACKED_POINT_VISIBLE(int point);
	void DESTROY_TRACKED_POINT(int point);
	int SET_GRASS_CULL_SPHERE(float p0, float p1, float p2, float p3);
	void REMOVE_GRASS_CULL_SPHERE(int handle);
	void PROCGRASS_ENABLE_CULLSPHERE(int handle, float x, float y, float z, float scale);
	void PROCGRASS_DISABLE_CULLSPHERE(int handle);
	BOOL PROCGRASS_IS_CULLSPHERE_ENABLED(int handle);
	void PROCGRASS_ENABLE_AMBSCALESCAN();
	void PROCGRASS_DISABLE_AMBSCALESCAN();
	void DISABLE_PROCOBJ_CREATION();
	void ENABLE_PROCOBJ_CREATION();
	void GRASSBATCH_ENABLE_FLATTENING_EXT_IN_SPHERE(float x, float y, float z, Any p3, float p4, float p5, float p6, float scale);
	void GRASSBATCH_ENABLE_FLATTENING_IN_SPHERE(float x, float y, float z, float radius, float p4, float p5, float p6);
	void GRASSBATCH_DISABLE_FLATTENING();
	void CASCADE_SHADOWS_INIT_SESSION();
	void CASCADE_SHADOWS_SET_CASCADE_BOUNDS(Any p0, BOOL p1, float p2, float p3, float p4, float p5, BOOL p6, float p7);
	void CASCADE_SHADOWS_SET_CASCADE_BOUNDS_SCALE(float p0);
	void CASCADE_SHADOWS_SET_ENTITY_TRACKER_SCALE(float p0);
	void CASCADE_SHADOWS_SET_SPLIT_Z_EXP_WEIGHT(float p0);
	void CASCADE_SHADOWS_SET_BOUND_POSITION(Any p0);
	void CASCADE_SHADOWS_ENABLE_ENTITY_TRACKER(BOOL toggle);
	void CASCADE_SHADOWS_SET_SCREEN_SIZE_CHECK_ENABLED(BOOL p0);
	void CASCADE_SHADOWS_SET_SHADOW_SAMPLE_TYPE(const char* type);
	void CASCADE_SHADOWS_CLEAR_SHADOW_SAMPLE_TYPE();
	void CASCADE_SHADOWS_SET_AIRCRAFT_MODE(BOOL p0);
	void CASCADE_SHADOWS_SET_DYNAMIC_DEPTH_MODE(BOOL p0);
	void CASCADE_SHADOWS_SET_DYNAMIC_DEPTH_VALUE(float p0);
	void CASCADE_SHADOWS_ENABLE_FREEZER(BOOL p0);
	void WATER_REFLECTION_SET_SCRIPT_OBJECT_VISIBILITY(Any p0);
	void GOLF_TRAIL_SET_ENABLED(BOOL toggle);
	void GOLF_TRAIL_SET_PATH(float p0, float p1, float p2, float p3, float p4, float p5, float p6, float p7, BOOL p8);
	void GOLF_TRAIL_SET_RADIUS(float p0, float p1, float p2);
	void GOLF_TRAIL_SET_COLOUR(int p0, int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8, int p9, int p10, int p11);
	void GOLF_TRAIL_SET_TESSELLATION(int p0, int p1);
	void GOLF_TRAIL_SET_FIXED_CONTROL_POINT_ENABLE(BOOL p0);
	void GOLF_TRAIL_SET_FIXED_CONTROL_POINT(int type, float xPos, float yPos, float zPos, float p4, int red, int green, int blue, int alpha);
	void GOLF_TRAIL_SET_SHADER_PARAMS(float p0, float p1, float p2, float p3, float p4);
	void GOLF_TRAIL_SET_FACING(BOOL p0);
	float GOLF_TRAIL_GET_MAX_HEIGHT();
	Vector3 GOLF_TRAIL_GET_VISUAL_CONTROL_POINT(int p0);
	void SET_SEETHROUGH(BOOL toggle);
	BOOL GET_USINGSEETHROUGH();
	void SEETHROUGH_RESET();
	void SEETHROUGH_SET_FADE_STARTDISTANCE(float distance);
	void SEETHROUGH_SET_FADE_ENDDISTANCE(float distance);
	float SEETHROUGH_GET_MAX_THICKNESS();
	void SEETHROUGH_SET_MAX_THICKNESS(float thickness);
	void SEETHROUGH_SET_NOISE_MIN(float amount);
	void SEETHROUGH_SET_NOISE_MAX(float amount);
	void SEETHROUGH_SET_HILIGHT_INTENSITY(float intensity);
	void SEETHROUGH_SET_HIGHLIGHT_NOISE(float noise);
	void SEETHROUGH_SET_HEATSCALE(int index, float heatScale);
	void SEETHROUGH_SET_COLOR_NEAR(int red, int green, int blue);
	void SET_MOTIONBLUR_MAX_VEL_SCALER(float p0);
	float GET_MOTIONBLUR_MAX_VEL_SCALER();
	void SET_FORCE_MOTIONBLUR(BOOL toggle);
	void TOGGLE_PLAYER_DAMAGE_OVERLAY(BOOL toggle);
	void RESET_ADAPTATION(int p0);
	BOOL TRIGGER_SCREENBLUR_FADE_IN(float transitionTime);
	BOOL TRIGGER_SCREENBLUR_FADE_OUT(float transitionTime);
	void DISABLE_SCREENBLUR_FADE();
	float GET_SCREENBLUR_FADE_CURRENT_TIME();
	BOOL IS_SCREENBLUR_FADE_RUNNING();
	void TOGGLE_PAUSED_RENDERPHASES(BOOL toggle);
	BOOL GET_TOGGLE_PAUSED_RENDERPHASES_STATUS();
	void RESET_PAUSED_RENDERPHASES();
	void GRAB_PAUSEMENU_OWNERSHIP();
	void SET_HIDOF_OVERRIDE(BOOL p0, BOOL p1, float nearplaneOut, float nearplaneIn, float farplaneOut, float farplaneIn);
	void SET_LOCK_ADAPTIVE_DOF_DISTANCE(BOOL p0);
	BOOL PHONEPHOTOEDITOR_TOGGLE(BOOL p0);
	BOOL PHONEPHOTOEDITOR_IS_ACTIVE();
	BOOL PHONEPHOTOEDITOR_SET_FRAME_TXD(const char* textureDict, BOOL p1);
	BOOL START_PARTICLE_FX_NON_LOOPED_AT_COORD(const char* effectName, float xPos, float yPos, float zPos, float xRot, float yRot, float zRot, float scale, BOOL xAxis, BOOL yAxis, BOOL zAxis);
	BOOL START_NETWORKED_PARTICLE_FX_NON_LOOPED_AT_COORD(const char* effectName, float xPos, float yPos, float zPos, float xRot, float yRot, float zRot, float scale, BOOL xAxis, BOOL yAxis, BOOL zAxis, BOOL p11);
	BOOL START_PARTICLE_FX_NON_LOOPED_ON_PED_BONE(const char* effectName, Ped ped, float offsetX, float offsetY, float offsetZ, float rotX, float rotY, float rotZ, int boneIndex, float scale, BOOL axisX, BOOL axisY, BOOL axisZ);
	BOOL START_NETWORKED_PARTICLE_FX_NON_LOOPED_ON_PED_BONE(const char* effectName, Ped ped, float offsetX, float offsetY, float offsetZ, float rotX, float rotY, float rotZ, int boneIndex, float scale, BOOL axisX, BOOL axisY, BOOL axisZ);
	BOOL START_PARTICLE_FX_NON_LOOPED_ON_ENTITY(const char* effectName, Entity entity, float offsetX, float offsetY, float offsetZ, float rotX, float rotY, float rotZ, float scale, BOOL axisX, BOOL axisY, BOOL axisZ);
	BOOL START_NETWORKED_PARTICLE_FX_NON_LOOPED_ON_ENTITY(const char* effectName, Entity entity, float offsetX, float offsetY, float offsetZ, float rotX, float rotY, float rotZ, float scale, BOOL axisX, BOOL axisY, BOOL axisZ);
	BOOL START_PARTICLE_FX_NON_LOOPED_ON_ENTITY_BONE(const char* effectName, Entity entity, float offsetX, float offsetY, float offsetZ, float rotX, float rotY, float rotZ, int boneIndex, float scale, BOOL axisX, BOOL axisY, BOOL axisZ);
	void SET_PARTICLE_FX_NON_LOOPED_COLOUR(float r, float g, float b);
	void SET_PARTICLE_FX_NON_LOOPED_ALPHA(float alpha);
	void SET_PARTICLE_FX_NON_LOOPED_SCALE(float scale);
	void SET_PARTICLE_FX_NON_LOOPED_EMITTER_SIZE(float p0, float p1, float scale);
	void SET_PARTICLE_FX_FORCE_VEHICLE_INTERIOR(BOOL toggle);
	int START_PARTICLE_FX_LOOPED_AT_COORD(const char* effectName, float x, float y, float z, float xRot, float yRot, float zRot, float scale, BOOL xAxis, BOOL yAxis, BOOL zAxis, BOOL p11);
	int START_PARTICLE_FX_LOOPED_ON_PED_BONE(const char* effectName, Ped ped, float xOffset, float yOffset, float zOffset, float xRot, float yRot, float zRot, int boneIndex, float scale, BOOL xAxis, BOOL yAxis, BOOL zAxis);
	int START_PARTICLE_FX_LOOPED_ON_ENTITY(const char* effectName, Entity entity, float xOffset, float yOffset, float zOffset, float xRot, float yRot, float zRot, float scale, BOOL xAxis, BOOL yAxis, BOOL zAxis);
	int START_PARTICLE_FX_LOOPED_ON_ENTITY_BONE(const char* effectName, Entity entity, float xOffset, float yOffset, float zOffset, float xRot, float yRot, float zRot, int boneIndex, float scale, BOOL xAxis, BOOL yAxis, BOOL zAxis);
	int START_NETWORKED_PARTICLE_FX_LOOPED_ON_ENTITY(const char* effectName, Entity entity, float xOffset, float yOffset, float zOffset, float xRot, float yRot, float zRot, float scale, BOOL xAxis, BOOL yAxis, BOOL zAxis, float r, float g, float b, float a);
	int START_NETWORKED_PARTICLE_FX_LOOPED_ON_ENTITY_BONE(const char* effectName, Entity entity, float xOffset, float yOffset, float zOffset, float xRot, float yRot, float zRot, int boneIndex, float scale, BOOL xAxis, BOOL yAxis, BOOL zAxis, float r, float g, float b, float a);
	void STOP_PARTICLE_FX_LOOPED(int ptfxHandle, BOOL p1);
	void REMOVE_PARTICLE_FX(int ptfxHandle, BOOL p1);
	void REMOVE_PARTICLE_FX_FROM_ENTITY(Entity entity);
	void REMOVE_PARTICLE_FX_IN_RANGE(float X, float Y, float Z, float radius);
	void FORCE_PARTICLE_FX_IN_VEHICLE_INTERIOR(Any p0, Any p1);
	BOOL DOES_PARTICLE_FX_LOOPED_EXIST(int ptfxHandle);
	void SET_PARTICLE_FX_LOOPED_OFFSETS(int ptfxHandle, float x, float y, float z, float rotX, float rotY, float rotZ);
	void SET_PARTICLE_FX_LOOPED_EVOLUTION(int ptfxHandle, const char* propertyName, float amount, BOOL noNetwork);
	void SET_PARTICLE_FX_LOOPED_COLOUR(int ptfxHandle, float r, float g, float b, BOOL p4);
	void SET_PARTICLE_FX_LOOPED_ALPHA(int ptfxHandle, float alpha);
	void SET_PARTICLE_FX_LOOPED_SCALE(int ptfxHandle, float scale);
	void SET_PARTICLE_FX_LOOPED_FAR_CLIP_DIST(int ptfxHandle, float range);
	void SET_PARTICLE_FX_CAM_INSIDE_VEHICLE(BOOL p0);
	void SET_PARTICLE_FX_CAM_INSIDE_NONPLAYER_VEHICLE(Vehicle vehicle, BOOL p1);
	void SET_PARTICLE_FX_SHOOTOUT_BOAT(Any p0);
	void CLEAR_PARTICLE_FX_SHOOTOUT_BOAT();
	void SET_PARTICLE_FX_BLOOD_SCALE(Any p0);
	void DISABLE_IN_WATER_PTFX(BOOL toggle);
	void DISABLE_DOWNWASH_PTFX(BOOL toggle);
	void SET_PARTICLE_FX_SLIPSTREAM_LODRANGE_SCALE(float scale);
	void ENABLE_CLOWN_BLOOD_VFX(BOOL toggle);
	void ENABLE_ALIEN_BLOOD_VFX(BOOL toggle);
	void SET_PARTICLE_FX_BULLET_IMPACT_SCALE(float scale);
	void SET_PARTICLE_FX_BULLET_IMPACT_LODRANGE_SCALE(float p0);
	void SET_PARTICLE_FX_BULLET_TRACE_NO_ANGLE_REJECT(BOOL p0);
	void SET_PARTICLE_FX_BANG_SCRAPE_LODRANGE_SCALE(float p0);
	void SET_PARTICLE_FX_FOOT_LODRANGE_SCALE(float p0);
	void SET_PARTICLE_FX_FOOT_OVERRIDE_NAME(const char* p0);
	void SET_SKIDMARK_RANGE_SCALE(float scale);
	void SET_PTFX_FORCE_VEHICLE_INTERIOR_FLAG(Any p0);
	void REGISTER_POSTFX_BULLET_IMPACT(float weaponWorldPosX, float weaponWorldPosY, float weaponWorldPosZ, float intensity);
	void FORCE_POSTFX_BULLET_IMPACTS_AFTER_HUD(BOOL p0);
	void USE_PARTICLE_FX_ASSET(const char* name);
	void SET_PARTICLE_FX_OVERRIDE(const char* oldAsset, const char* newAsset);
	void RESET_PARTICLE_FX_OVERRIDE(const char* name);
	void SET_WEATHER_PTFX_USE_OVERRIDE_SETTINGS(BOOL p0);
	void SET_WEATHER_PTFX_OVERRIDE_CURR_LEVEL(float p0);
	void WASH_DECALS_IN_RANGE(float x, float y, float z, float range, float p4);
	void WASH_DECALS_FROM_VEHICLE(Vehicle vehicle, float p1);
	void FADE_DECALS_IN_RANGE(float x, float y, float z, float p3, float p4);
	void REMOVE_DECALS_IN_RANGE(float x, float y, float z, float range);
	void REMOVE_DECALS_FROM_OBJECT(Object obj);
	void REMOVE_DECALS_FROM_OBJECT_FACING(Object obj, float x, float y, float z);
	void REMOVE_DECALS_FROM_VEHICLE(Vehicle vehicle);
	int ADD_DECAL(int decalType, float posX, float posY, float posZ, float p4, float p5, float p6, float p7, float p8, float p9, float width, float height, float rCoef, float gCoef, float bCoef, float opacity, float timeout, BOOL p17, BOOL p18, BOOL p19);
	int ADD_PETROL_DECAL(float x, float y, float z, float groundLvl, float width, float transparency);
	int ADD_OIL_DECAL(float x, float y, float z, float groundLvl, float width, float transparency);
	void START_PETROL_TRAIL_DECALS(float p0);
	void ADD_PETROL_TRAIL_DECAL_INFO(float x, float y, float z, float p3);
	void END_PETROL_TRAIL_DECALS();
	void REMOVE_DECAL(int decal);
	BOOL IS_DECAL_ALIVE(int decal);
	float GET_DECAL_WASH_LEVEL(int decal);
	void SET_DISABLE_PETROL_DECALS_IGNITING_THIS_FRAME();
	void SET_DISABLE_PETROL_DECALS_RECYCLING_THIS_FRAME();
	void SET_DISABLE_DECAL_RENDERING_THIS_FRAME();
	BOOL GET_IS_PETROL_DECAL_IN_RANGE(float xCoord, float yCoord, float zCoord, float radius);
	void PATCH_DECAL_DIFFUSE_MAP(int decalType, const char* textureDict, const char* textureName);
	void UNPATCH_DECAL_DIFFUSE_MAP(int decalType);
	void MOVE_VEHICLE_DECALS(Any p0, Any p1);
	BOOL ADD_VEHICLE_CREW_EMBLEM(Vehicle vehicle, Ped ped, int boneIndex, float x1, float x2, float x3, float y1, float y2, float y3, float z1, float z2, float z3, float scale, Any p13, int alpha);
	BOOL ABORT_VEHICLE_CREW_EMBLEM_REQUEST(int* p0);
	void REMOVE_VEHICLE_CREW_EMBLEM(Vehicle vehicle, int p1);
	int GET_VEHICLE_CREW_EMBLEM_REQUEST_STATE(Vehicle vehicle, int p1);
	BOOL DOES_VEHICLE_HAVE_CREW_EMBLEM(Vehicle vehicle, int p1);
	void DISABLE_COMPOSITE_SHOTGUN_DECALS(BOOL toggle);
	void DISABLE_SCUFF_DECALS(BOOL toggle);
	void SET_DECAL_BULLET_IMPACT_RANGE_SCALE(float p0);
	void OVERRIDE_INTERIOR_SMOKE_NAME(const char* name);
	void OVERRIDE_INTERIOR_SMOKE_LEVEL(float level);
	void OVERRIDE_INTERIOR_SMOKE_END();
	void REGISTER_NOIR_LENS_EFFECT();
	void DISABLE_VEHICLE_DISTANTLIGHTS(BOOL toggle);
	void RENDER_SHADOWED_LIGHTS_WITH_NO_SHADOWS(BOOL p0);
	void REQUEST_EARLY_LIGHT_CHECK();
	void USE_SNOW_FOOT_VFX_WHEN_UNSHELTERED(BOOL toggle);
	void USE_SNOW_WHEEL_VFX_WHEN_UNSHELTERED(BOOL toggle);
	void DISABLE_REGION_VFX(Any p0);
	void PRESET_INTERIOR_AMBIENT_CACHE(const char* timecycleModifierName);
	void SET_TIMECYCLE_MODIFIER(const char* modifierName);
	void SET_TIMECYCLE_MODIFIER_STRENGTH(float strength);
	void SET_TRANSITION_TIMECYCLE_MODIFIER(const char* modifierName, float transition);
	void SET_TRANSITION_OUT_OF_TIMECYCLE_MODIFIER(float strength);
	void CLEAR_TIMECYCLE_MODIFIER();
	int GET_TIMECYCLE_MODIFIER_INDEX();
	int GET_TIMECYCLE_TRANSITION_MODIFIER_INDEX();
	BOOL GET_IS_TIMECYCLE_TRANSITIONING_OUT();
	void PUSH_TIMECYCLE_MODIFIER();
	void POP_TIMECYCLE_MODIFIER();
	void SET_CURRENT_PLAYER_TCMODIFIER(const char* modifierName);
	void SET_PLAYER_TCMODIFIER_TRANSITION(float value);
	void SET_NEXT_PLAYER_TCMODIFIER(const char* modifierName);
	void ADD_TCMODIFIER_OVERRIDE(const char* modifierName1, const char* modifierName2);
	void CLEAR_ALL_TCMODIFIER_OVERRIDES(const char* p0);
	void SET_EXTRA_TCMODIFIER(const char* modifierName);
	void CLEAR_EXTRA_TCMODIFIER();
	int GET_EXTRA_TCMODIFIER();
	void ENABLE_MOON_CYCLE_OVERRIDE(float strength);
	void DISABLE_MOON_CYCLE_OVERRIDE();
	int REQUEST_SCALEFORM_MOVIE(const char* scaleformName);
	int REQUEST_SCALEFORM_MOVIE_WITH_IGNORE_SUPER_WIDESCREEN(const char* scaleformName);
	int REQUEST_SCALEFORM_MOVIE_INSTANCE(const char* scaleformName);
	int REQUEST_SCALEFORM_MOVIE_SKIP_RENDER_WHILE_PAUSED(const char* scaleformName);
	BOOL HAS_SCALEFORM_MOVIE_LOADED(int scaleformHandle);
	BOOL IS_ACTIVE_SCALEFORM_MOVIE_DELETING(int val);
	BOOL IS_SCALEFORM_MOVIE_DELETING(int val);
	BOOL HAS_SCALEFORM_MOVIE_FILENAME_LOADED(const char* scaleformName);
	BOOL HAS_SCALEFORM_CONTAINER_MOVIE_LOADED_INTO_PARENT(int scaleformHandle);
	void SET_SCALEFORM_MOVIE_AS_NO_LONGER_NEEDED(int* scaleformHandle);
	void SET_SCALEFORM_MOVIE_TO_USE_SYSTEM_TIME(int scaleform, BOOL toggle);
	void SET_SCALEFORM_MOVIE_TO_USE_LARGE_RT(int scaleformHandle, BOOL toggle);
	void SET_SCALEFORM_MOVIE_TO_USE_SUPER_LARGE_RT(int scaleformHandle, BOOL toggle);
	void DRAW_SCALEFORM_MOVIE(int scaleformHandle, float x, float y, float width, float height, int red, int green, int blue, int alpha, int p9);
	void DRAW_SCALEFORM_MOVIE_FULLSCREEN(int scaleform, int red, int green, int blue, int alpha, int p5);
	void DRAW_SCALEFORM_MOVIE_FULLSCREEN_MASKED(int scaleform1, int scaleform2, int red, int green, int blue, int alpha);
	void DRAW_SCALEFORM_MOVIE_3D(int scaleform, float posX, float posY, float posZ, float rotX, float rotY, float rotZ, float p7, float p8, float p9, float scaleX, float scaleY, float scaleZ, int rotationOrder);
	void DRAW_SCALEFORM_MOVIE_3D_SOLID(int scaleform, float posX, float posY, float posZ, float rotX, float rotY, float rotZ, float p7, float p8, float p9, float scaleX, float scaleY, float scaleZ, int rotationOrder);
	void CALL_SCALEFORM_MOVIE_METHOD(int scaleform, const char* method);
	void CALL_SCALEFORM_MOVIE_METHOD_WITH_NUMBER(int scaleform, const char* methodName, float param1, float param2, float param3, float param4, float param5);
	void CALL_SCALEFORM_MOVIE_METHOD_WITH_STRING(int scaleform, const char* methodName, const char* param1, const char* param2, const char* param3, const char* param4, const char* param5);
	void CALL_SCALEFORM_MOVIE_METHOD_WITH_NUMBER_AND_STRING(int scaleform, const char* methodName, float floatParam1, float floatParam2, float floatParam3, float floatParam4, float floatParam5, const char* stringParam1, const char* stringParam2, const char* stringParam3, const char* stringParam4, const char* stringParam5);
	BOOL BEGIN_SCALEFORM_SCRIPT_HUD_MOVIE_METHOD(int hudComponent, const char* methodName);
	BOOL BEGIN_SCALEFORM_MOVIE_METHOD(int scaleform, const char* methodName);
	BOOL BEGIN_SCALEFORM_MOVIE_METHOD_ON_FRONTEND(const char* methodName);
	BOOL BEGIN_SCALEFORM_MOVIE_METHOD_ON_FRONTEND_HEADER(const char* methodName);
	void END_SCALEFORM_MOVIE_METHOD();
	int END_SCALEFORM_MOVIE_METHOD_RETURN_VALUE();
	BOOL IS_SCALEFORM_MOVIE_METHOD_RETURN_VALUE_READY(int methodReturn);
	int GET_SCALEFORM_MOVIE_METHOD_RETURN_VALUE_INT(int methodReturn);
	BOOL GET_SCALEFORM_MOVIE_METHOD_RETURN_VALUE_BOOL(int methodReturn);
	const char* GET_SCALEFORM_MOVIE_METHOD_RETURN_VALUE_STRING(int methodReturn);
	void SCALEFORM_MOVIE_METHOD_ADD_PARAM_INT(int value);
	void SCALEFORM_MOVIE_METHOD_ADD_PARAM_FLOAT(float value);
	void SCALEFORM_MOVIE_METHOD_ADD_PARAM_BOOL(BOOL value);
	void BEGIN_TEXT_COMMAND_SCALEFORM_STRING(const char* componentType);
	void END_TEXT_COMMAND_SCALEFORM_STRING();
	void END_TEXT_COMMAND_UNPARSED_SCALEFORM_STRING();
	void SCALEFORM_MOVIE_METHOD_ADD_PARAM_LITERAL_STRING(const char* string);
	void SCALEFORM_MOVIE_METHOD_ADD_PARAM_TEXTURE_NAME_STRING(const char* string);
	void SCALEFORM_MOVIE_METHOD_ADD_PARAM_PLAYER_NAME_STRING(const char* string);
	BOOL DOES_LATEST_BRIEF_STRING_EXIST(int p0);
	void SCALEFORM_MOVIE_METHOD_ADD_PARAM_LATEST_BRIEF_STRING(int value);
	void REQUEST_SCALEFORM_SCRIPT_HUD_MOVIE(int hudComponent);
	BOOL HAS_SCALEFORM_SCRIPT_HUD_MOVIE_LOADED(int hudComponent);
	void REMOVE_SCALEFORM_SCRIPT_HUD_MOVIE(int hudComponent);
	BOOL PASS_KEYBOARD_INPUT_TO_SCALEFORM(int scaleformHandle);
	void SET_TV_CHANNEL(int channel);
	int GET_TV_CHANNEL();
	void SET_TV_VOLUME(float volume);
	float GET_TV_VOLUME();
	void DRAW_TV_CHANNEL(float xPos, float yPos, float xScale, float yScale, float rotation, int red, int green, int blue, int alpha);
	void SET_TV_CHANNEL_PLAYLIST(int tvChannel, const char* playlistName, BOOL restart);
	void SET_TV_CHANNEL_PLAYLIST_AT_HOUR(int tvChannel, const char* playlistName, int hour);
	void CLEAR_TV_CHANNEL_PLAYLIST(int tvChannel);
	BOOL IS_PLAYLIST_ON_CHANNEL(int tvChannel, Any p1);
	BOOL IS_TVSHOW_CURRENTLY_PLAYING(Hash videoCliphash);
	void ENABLE_MOVIE_KEYFRAME_WAIT(BOOL toggle);
	void SET_TV_PLAYER_WATCHING_THIS_FRAME(Any p0);
	Hash GET_CURRENT_TV_CLIP_NAMEHASH();
	void ENABLE_MOVIE_SUBTITLES(BOOL toggle);
	BOOL UI3DSCENE_IS_AVAILABLE();
	BOOL UI3DSCENE_PUSH_PRESET(const char* presetName);
	BOOL UI3DSCENE_ASSIGN_PED_TO_SLOT(const char* presetName, Ped ped, int slot, float posX, float posY, float posZ);
	void UI3DSCENE_CLEAR_PATCHED_DATA();
	void UI3DSCENE_MAKE_PUSHED_PRESET_PERSISTENT(BOOL toggle);
	void TERRAINGRID_ACTIVATE(BOOL toggle);
	void TERRAINGRID_SET_PARAMS(float x, float y, float z, float forwardX, float forwardY, float forwardZ, float sizeX, float sizeY, float sizeZ, float gridScale, float glowIntensity, float normalHeight, float heightDiff);
	void TERRAINGRID_SET_COLOURS(int lowR, int lowG, int lowB, int lowAlpha, int r, int g, int b, int alpha, int highR, int highG, int highB, int highAlpha);
	void ANIMPOSTFX_PLAY(const char* effectName, int duration, BOOL looped);
	void ANIMPOSTFX_STOP(const char* effectName);
	float ANIMPOSTFX_GET_CURRENT_TIME(const char* effectName);
	BOOL ANIMPOSTFX_IS_RUNNING(const char* effectName);
	void ANIMPOSTFX_STOP_ALL();
	void ANIMPOSTFX_STOP_AND_FLUSH_REQUESTS(const char* effectName);
}

namespace HUD
{
	void BEGIN_TEXT_COMMAND_BUSYSPINNER_ON(const char* string);
	void END_TEXT_COMMAND_BUSYSPINNER_ON(int busySpinnerType);
	void BUSYSPINNER_OFF();
	void PRELOAD_BUSYSPINNER();
	BOOL BUSYSPINNER_IS_ON();
	BOOL BUSYSPINNER_IS_DISPLAYING();
	void DISABLE_PAUSEMENU_SPINNER(BOOL p0);
	void SET_MOUSE_CURSOR_THIS_FRAME();
	void SET_MOUSE_CURSOR_STYLE(int spriteId);
	void SET_MOUSE_CURSOR_VISIBLE(BOOL toggle);
	BOOL IS_MOUSE_ROLLED_OVER_INSTRUCTIONAL_BUTTONS();
	BOOL GET_MOUSE_EVENT(int scaleformHandle, Any* p1, Any* p2, Any* p3);
	void THEFEED_ONLY_SHOW_TOOLTIPS(BOOL toggle);
	void THEFEED_SET_SCRIPTED_MENU_HEIGHT(float pos);
	void THEFEED_HIDE();
	void THEFEED_HIDE_THIS_FRAME();
	void THEFEED_SHOW();
	void THEFEED_FLUSH_QUEUE();
	void THEFEED_REMOVE_ITEM(int notificationId);
	void THEFEED_FORCE_RENDER_ON();
	void THEFEED_FORCE_RENDER_OFF();
	void THEFEED_PAUSE();
	void THEFEED_RESUME();
	BOOL THEFEED_IS_PAUSED();
	void THEFEED_REPORT_LOGO_ON();
	void THEFEED_REPORT_LOGO_OFF();
	int THEFEED_GET_LAST_SHOWN_PHONE_ACTIVATABLE_FEED_ID();
	void THEFEED_AUTO_POST_GAMETIPS_ON();
	void THEFEED_AUTO_POST_GAMETIPS_OFF();
	void THEFEED_SET_BACKGROUND_COLOR_FOR_NEXT_POST(int hudColorIndex);
	void THEFEED_SET_RGBA_PARAMETER_FOR_NEXT_MESSAGE(int red, int green, int blue, int alpha);
	void THEFEED_SET_FLASH_DURATION_PARAMETER_FOR_NEXT_MESSAGE(int count);
	void THEFEED_SET_VIBRATE_PARAMETER_FOR_NEXT_MESSAGE(BOOL toggle);
	void THEFEED_RESET_ALL_PARAMETERS();
	void THEFEED_FREEZE_NEXT_POST();
	void THEFEED_CLEAR_FROZEN_POST();
	void THEFEED_SET_SNAP_FEED_ITEM_POSITIONS(BOOL p0);
	void THEFEED_UPDATE_ITEM_TEXTURE(const char* txdString1, const char* txnString1, const char* txdString2, const char* txnString2);
	void BEGIN_TEXT_COMMAND_THEFEED_POST(const char* text);
	int END_TEXT_COMMAND_THEFEED_POST_STATS(const char* statTitle, int iconEnum, BOOL stepVal, int barValue, BOOL isImportant, const char* pictureTextureDict, const char* pictureTextureName);
	int END_TEXT_COMMAND_THEFEED_POST_MESSAGETEXT(const char* txdName, const char* textureName, BOOL flash, int iconType, const char* sender, const char* subject);
	int END_TEXT_COMMAND_THEFEED_POST_MESSAGETEXT_SUBTITLE_LABEL(const char* txdName, const char* textureName, BOOL flash, int iconType, const char* sender, const char* subject);
	int END_TEXT_COMMAND_THEFEED_POST_MESSAGETEXT_TU(const char* txdName, const char* textureName, BOOL flash, int iconType, const char* sender, const char* subject, float duration);
	int END_TEXT_COMMAND_THEFEED_POST_MESSAGETEXT_WITH_CREW_TAG(const char* txdName, const char* textureName, BOOL flash, int iconType, const char* sender, const char* subject, float duration, const char* clanTag);
	int END_TEXT_COMMAND_THEFEED_POST_MESSAGETEXT_WITH_CREW_TAG_AND_ADDITIONAL_ICON(const char* txdName, const char* textureName, BOOL flash, int iconType1, const char* sender, const char* subject, float duration, const char* clanTag, int iconType2, int p9);
	int END_TEXT_COMMAND_THEFEED_POST_TICKER(BOOL blink, BOOL p1);
	int END_TEXT_COMMAND_THEFEED_POST_TICKER_FORCED(BOOL blink, BOOL p1);
	int END_TEXT_COMMAND_THEFEED_POST_TICKER_WITH_TOKENS(BOOL blink, BOOL p1);
	int END_TEXT_COMMAND_THEFEED_POST_AWARD(const char* textureDict, const char* textureName, int rpBonus, int colorOverlay, const char* titleLabel);
	int END_TEXT_COMMAND_THEFEED_POST_CREWTAG(BOOL p0, BOOL p1, int* p2, int p3, BOOL isLeader, BOOL unk0, int clanDesc, int R, int G, int B);
	int END_TEXT_COMMAND_THEFEED_POST_CREWTAG_WITH_GAME_NAME(BOOL p0, BOOL p1, int* p2, int p3, BOOL isLeader, BOOL unk0, int clanDesc, const char* playerName, int R, int G, int B);
	int END_TEXT_COMMAND_THEFEED_POST_UNLOCK(const char* gxtLabel1, int p1, const char* gxtLabel2);
	int END_TEXT_COMMAND_THEFEED_POST_UNLOCK_TU(const char* gxtLabel1, int p1, const char* gxtLabel2, int p3);
	int END_TEXT_COMMAND_THEFEED_POST_UNLOCK_TU_WITH_COLOR(Any p0, Any p1, Any p2, Any p3, Any p4, Any p5);
	int END_TEXT_COMMAND_THEFEED_POST_MPTICKER(BOOL blink, BOOL p1);
	int END_TEXT_COMMAND_THEFEED_POST_CREW_RANKUP_WITH_LITERAL_FLAG(const char* p0, const char* p1, const char* p2, BOOL p3, BOOL p4);
	int END_TEXT_COMMAND_THEFEED_POST_VERSUS_TU(const char* txdName1, const char* textureName1, int count1, const char* txdName2, const char* textureName2, int count2, int hudColor1, int hudColor2);
	int END_TEXT_COMMAND_THEFEED_POST_REPLAY(int type, int image, const char* text);
	int END_TEXT_COMMAND_THEFEED_POST_REPLAY_INPUT(int type, const char* button, const char* text);
	void BEGIN_TEXT_COMMAND_PRINT(const char* GxtEntry);
	void END_TEXT_COMMAND_PRINT(int duration, BOOL drawImmediately);
	void BEGIN_TEXT_COMMAND_IS_MESSAGE_DISPLAYED(const char* text);
	BOOL END_TEXT_COMMAND_IS_MESSAGE_DISPLAYED();
	void BEGIN_TEXT_COMMAND_DISPLAY_TEXT(const char* text);
	void END_TEXT_COMMAND_DISPLAY_TEXT(float x, float y, int p2);
	void BEGIN_TEXT_COMMAND_GET_SCREEN_WIDTH_OF_DISPLAY_TEXT(const char* text);
	float END_TEXT_COMMAND_GET_SCREEN_WIDTH_OF_DISPLAY_TEXT(BOOL p0);
	void BEGIN_TEXT_COMMAND_GET_NUMBER_OF_LINES_FOR_STRING(const char* entry);
	int END_TEXT_COMMAND_GET_NUMBER_OF_LINES_FOR_STRING(float x, float y);
	void BEGIN_TEXT_COMMAND_DISPLAY_HELP(const char* inputType);
	void END_TEXT_COMMAND_DISPLAY_HELP(int p0, BOOL loop, BOOL beep, int shape);
	void BEGIN_TEXT_COMMAND_IS_THIS_HELP_MESSAGE_BEING_DISPLAYED(const char* labelName);
	BOOL END_TEXT_COMMAND_IS_THIS_HELP_MESSAGE_BEING_DISPLAYED(int p0);
	void BEGIN_TEXT_COMMAND_SET_BLIP_NAME(const char* textLabel);
	void END_TEXT_COMMAND_SET_BLIP_NAME(Blip blip);
	void BEGIN_TEXT_COMMAND_ADD_DIRECTLY_TO_PREVIOUS_BRIEFS(const char* p0);
	void END_TEXT_COMMAND_ADD_DIRECTLY_TO_PREVIOUS_BRIEFS(BOOL p0);
	void BEGIN_TEXT_COMMAND_CLEAR_PRINT(const char* text);
	void END_TEXT_COMMAND_CLEAR_PRINT();
	void BEGIN_TEXT_COMMAND_OVERRIDE_BUTTON_TEXT(const char* gxtEntry);
	void END_TEXT_COMMAND_OVERRIDE_BUTTON_TEXT(int p0);
	void ADD_TEXT_COMPONENT_INTEGER(int value);
	void ADD_TEXT_COMPONENT_FLOAT(float value, int decimalPlaces);
	void ADD_TEXT_COMPONENT_SUBSTRING_TEXT_LABEL(const char* labelName);
	void ADD_TEXT_COMPONENT_SUBSTRING_TEXT_LABEL_HASH_KEY(Hash gxtEntryHash);
	void ADD_TEXT_COMPONENT_SUBSTRING_BLIP_NAME(Blip blip);
	void ADD_TEXT_COMPONENT_SUBSTRING_PLAYER_NAME(const char* text);
	void ADD_TEXT_COMPONENT_SUBSTRING_TIME(int timestamp, int flags);
	void ADD_TEXT_COMPONENT_FORMATTED_INTEGER(int value, BOOL commaSeparated);
	void ADD_TEXT_COMPONENT_SUBSTRING_PHONE_NUMBER(const char* p0, int p1);
	void ADD_TEXT_COMPONENT_SUBSTRING_WEBSITE(const char* website);
	void ADD_TEXT_COMPONENT_SUBSTRING_KEYBOARD_DISPLAY(const char* string);
	void SET_COLOUR_OF_NEXT_TEXT_COMPONENT(int hudColor);
	const char* GET_CHARACTER_FROM_AUDIO_CONVERSATION_FILENAME(const char* text, int position, int length);
	const char* GET_CHARACTER_FROM_AUDIO_CONVERSATION_FILENAME_WITH_BYTE_LIMIT(const char* text, int position, int length, int maxLength);
	const char* GET_CHARACTER_FROM_AUDIO_CONVERSATION_FILENAME_BYTES(const char* text, int startPosition, int endPosition);
	const char* GET_FILENAME_FOR_AUDIO_CONVERSATION(const char* labelName);
	void CLEAR_PRINTS();
	void CLEAR_BRIEF();
	void CLEAR_ALL_HELP_MESSAGES();
	void CLEAR_THIS_PRINT(const char* p0);
	void CLEAR_SMALL_PRINTS();
	BOOL DOES_TEXT_BLOCK_EXIST(const char* gxt);
	void REQUEST_ADDITIONAL_TEXT(const char* gxt, int slot);
	void REQUEST_ADDITIONAL_TEXT_FOR_DLC(const char* gxt, int slot);
	BOOL HAS_ADDITIONAL_TEXT_LOADED(int slot);
	void CLEAR_ADDITIONAL_TEXT(int p0, BOOL p1);
	BOOL IS_STREAMING_ADDITIONAL_TEXT(int p0);
	BOOL HAS_THIS_ADDITIONAL_TEXT_LOADED(const char* gxt, int slot);
	BOOL IS_MESSAGE_BEING_DISPLAYED();
	BOOL DOES_TEXT_LABEL_EXIST(const char* gxt);
	const char* GET_FIRST_N_CHARACTERS_OF_LITERAL_STRING(const char* string, int length);
	int GET_LENGTH_OF_STRING_WITH_THIS_TEXT_LABEL(const char* gxt);
	int GET_LENGTH_OF_LITERAL_STRING(const char* string);
	int GET_LENGTH_OF_LITERAL_STRING_IN_BYTES(const char* string);
	const char* GET_STREET_NAME_FROM_HASH_KEY(Hash hash);
	BOOL IS_HUD_PREFERENCE_SWITCHED_ON();
	BOOL IS_RADAR_PREFERENCE_SWITCHED_ON();
	BOOL IS_SUBTITLE_PREFERENCE_SWITCHED_ON();
	void DISPLAY_HUD(BOOL toggle);
	void DISPLAY_HUD_WHEN_NOT_IN_STATE_OF_PLAY_THIS_FRAME();
	void DISPLAY_HUD_WHEN_PAUSED_THIS_FRAME();
	void DISPLAY_RADAR(BOOL toggle);
	void SET_FAKE_SPECTATOR_MODE(BOOL toggle);
	BOOL GET_FAKE_SPECTATOR_MODE();
	BOOL IS_HUD_HIDDEN();
	BOOL IS_RADAR_HIDDEN();
	BOOL IS_MINIMAP_RENDERING();
	void USE_VEHICLE_TARGETING_RETICULE(Any p0);
	void ADD_VALID_VEHICLE_HIT_HASH(Any p0);
	void CLEAR_VALID_VEHICLE_HIT_HASHES();
	void SET_BLIP_ROUTE(Blip blip, BOOL enabled);
	void CLEAR_ALL_BLIP_ROUTES();
	void SET_BLIP_ROUTE_COLOUR(Blip blip, int colour);
	void SET_FORCE_SHOW_GPS(BOOL toggle);
	void SET_USE_SET_DESTINATION_IN_PAUSE_MAP(BOOL toggle);
	void SET_BLOCK_WANTED_FLASH(BOOL disabled);
	void ADD_NEXT_MESSAGE_TO_PREVIOUS_BRIEFS(BOOL p0);
	void FORCE_NEXT_MESSAGE_TO_PREVIOUS_BRIEFS_LIST(int p0);
	void SET_RADAR_ZOOM_PRECISE(float zoom);
	void SET_RADAR_ZOOM(int zoomLevel);
	void SET_RADAR_ZOOM_TO_BLIP(Blip blip, float zoom);
	void SET_RADAR_ZOOM_TO_DISTANCE(float zoom);
	void UPDATE_RADAR_ZOOM_TO_BLIP();
	void GET_HUD_COLOUR(int hudColorIndex, int* r, int* g, int* b, int* a);
	void SET_SCRIPT_VARIABLE_HUD_COLOUR(int r, int g, int b, int a);
	void SET_SECOND_SCRIPT_VARIABLE_HUD_COLOUR(int r, int g, int b, int a);
	void REPLACE_HUD_COLOUR(int hudColorIndex, int hudColorIndex2);
	void REPLACE_HUD_COLOUR_WITH_RGBA(int hudColorIndex, int r, int g, int b, int a);
	void SET_ABILITY_BAR_VISIBILITY(BOOL visible);
	void SET_ALLOW_ABILITY_BAR(BOOL toggle);
	void FLASH_ABILITY_BAR(int millisecondsToFlash);
	void SET_ABILITY_BAR_VALUE(float p0, float p1);
	void FLASH_WANTED_DISPLAY(BOOL p0);
	void FORCE_OFF_WANTED_STAR_FLASH(BOOL toggle);
	void SET_CUSTOM_MP_HUD_COLOR(int hudColorId);
	float GET_RENDERED_CHARACTER_HEIGHT(float size, int font);
	void SET_TEXT_SCALE(float scale, float size);
	void SET_TEXT_COLOUR(int red, int green, int blue, int alpha);
	void SET_TEXT_CENTRE(BOOL align);
	void SET_TEXT_RIGHT_JUSTIFY(BOOL toggle);
	void SET_TEXT_JUSTIFICATION(int justifyType);
	void SET_TEXT_WRAP(float start, float end);
	void SET_TEXT_LEADING(int p0);
	void SET_TEXT_PROPORTIONAL(BOOL p0);
	void SET_TEXT_FONT(int fontType);
	void SET_TEXT_DROP_SHADOW();
	void SET_TEXT_DROPSHADOW(int distance, int r, int g, int b, int a);
	void SET_TEXT_OUTLINE();
	void SET_TEXT_EDGE(int p0, int r, int g, int b, int a);
	void SET_TEXT_RENDER_ID(int renderId);
	int GET_DEFAULT_SCRIPT_RENDERTARGET_RENDER_ID();
	BOOL REGISTER_NAMED_RENDERTARGET(const char* name, BOOL p1);
	BOOL IS_NAMED_RENDERTARGET_REGISTERED(const char* name);
	BOOL RELEASE_NAMED_RENDERTARGET(const char* name);
	void LINK_NAMED_RENDERTARGET(Hash modelHash);
	int GET_NAMED_RENDERTARGET_RENDER_ID(const char* name);
	BOOL IS_NAMED_RENDERTARGET_LINKED(Hash modelHash);
	void CLEAR_HELP(BOOL toggle);
	BOOL IS_HELP_MESSAGE_ON_SCREEN();
	BOOL HAS_SCRIPT_HIDDEN_HELP_THIS_FRAME();
	BOOL IS_HELP_MESSAGE_BEING_DISPLAYED();
	BOOL IS_HELP_MESSAGE_FADING_OUT();
	void SET_HELP_MESSAGE_STYLE(int style, int hudColor, int alpha, int p3, int p4);
	int GET_STANDARD_BLIP_ENUM_ID();
	int GET_WAYPOINT_BLIP_ENUM_ID();
	int GET_NUMBER_OF_ACTIVE_BLIPS();
	Blip GET_NEXT_BLIP_INFO_ID(int blipSprite);
	Blip GET_FIRST_BLIP_INFO_ID(int blipSprite);
	Blip GET_CLOSEST_BLIP_INFO_ID(int blipSprite);
	Vector3 GET_BLIP_INFO_ID_COORD(Blip blip);
	int GET_BLIP_INFO_ID_DISPLAY(Blip blip);
	int GET_BLIP_INFO_ID_TYPE(Blip blip);
	Entity GET_BLIP_INFO_ID_ENTITY_INDEX(Blip blip);
	Pickup GET_BLIP_INFO_ID_PICKUP_INDEX(Blip blip);
	Blip GET_BLIP_FROM_ENTITY(Entity entity);
	Blip ADD_BLIP_FOR_RADIUS(float posX, float posY, float posZ, float radius);
	Blip ADD_BLIP_FOR_AREA(float x, float y, float z, float width, float height);
	Blip ADD_BLIP_FOR_ENTITY(Entity entity);
	Blip ADD_BLIP_FOR_PICKUP(Pickup pickup);
	Blip ADD_BLIP_FOR_COORD(float x, float y, float z);
	void TRIGGER_SONAR_BLIP(float posX, float posY, float posZ, float radius, int p4);
	void ALLOW_SONAR_BLIPS(BOOL toggle);
	void SET_BLIP_COORDS(Blip blip, float posX, float posY, float posZ);
	Vector3 GET_BLIP_COORDS(Blip blip);
	void SET_BLIP_SPRITE(Blip blip, int spriteId);
	int GET_BLIP_SPRITE(Blip blip);
	void SET_COP_BLIP_SPRITE(int p0, float p1);
	void SET_COP_BLIP_SPRITE_AS_STANDARD();
	void SET_BLIP_NAME_FROM_TEXT_FILE(Blip blip, const char* gxtEntry);
	void SET_BLIP_NAME_TO_PLAYER_NAME(Blip blip, Player player);
	void SET_BLIP_ALPHA(Blip blip, int alpha);
	int GET_BLIP_ALPHA(Blip blip);
	void SET_BLIP_FADE(Blip blip, int opacity, int duration);
	int GET_BLIP_FADE_DIRECTION(Blip blip);
	void SET_BLIP_ROTATION(Blip blip, int rotation);
	void SET_BLIP_ROTATION_WITH_FLOAT(Blip blip, float heading);
	int GET_BLIP_ROTATION(Blip blip);
	void SET_BLIP_FLASH_TIMER(Blip blip, int duration);
	void SET_BLIP_FLASH_INTERVAL(Blip blip, Any p1);
	void SET_BLIP_COLOUR(Blip blip, int color);
	void SET_BLIP_SECONDARY_COLOUR(Blip blip, int r, int g, int b);
	int GET_BLIP_COLOUR(Blip blip);
	int GET_BLIP_HUD_COLOUR(Blip blip);
	BOOL IS_BLIP_SHORT_RANGE(Blip blip);
	BOOL IS_BLIP_ON_MINIMAP(Blip blip);
	BOOL DOES_BLIP_HAVE_GPS_ROUTE(Blip blip);
	void SET_BLIP_HIDDEN_ON_LEGEND(Blip blip, BOOL toggle);
	void SET_BLIP_HIGH_DETAIL(Blip blip, BOOL toggle);
	void SET_BLIP_AS_MISSION_CREATOR_BLIP(Blip blip, BOOL toggle);
	BOOL IS_MISSION_CREATOR_BLIP(Blip blip);
	Blip GET_NEW_SELECTED_MISSION_CREATOR_BLIP();
	BOOL IS_HOVERING_OVER_MISSION_CREATOR_BLIP();
	void SHOW_START_MISSION_INSTRUCTIONAL_BUTTON(BOOL toggle);
	void SHOW_CONTACT_INSTRUCTIONAL_BUTTON(BOOL toggle);
	void RELOAD_MAP_MENU();
	void SET_BLIP_MARKER_LONG_DISTANCE(Any p0, Any p1);
	void SET_BLIP_FLASHES(Blip blip, BOOL toggle);
	void SET_BLIP_FLASHES_ALTERNATE(Blip blip, BOOL toggle);
	BOOL IS_BLIP_FLASHING(Blip blip);
	void SET_BLIP_AS_SHORT_RANGE(Blip blip, BOOL toggle);
	void SET_BLIP_SCALE(Blip blip, float scale);
	void SET_BLIP_SCALE_2D(Blip blip, float xScale, float yScale);
	void SET_BLIP_PRIORITY(Blip blip, int priority);
	void SET_BLIP_DISPLAY(Blip blip, int displayId);
	void SET_BLIP_CATEGORY(Blip blip, int index);
	void REMOVE_BLIP(Blip* blip);
	void SET_BLIP_AS_FRIENDLY(Blip blip, BOOL toggle);
	void PULSE_BLIP(Blip blip);
	void SHOW_NUMBER_ON_BLIP(Blip blip, int number);
	void HIDE_NUMBER_ON_BLIP(Blip blip);
	void SHOW_HEIGHT_ON_BLIP(Blip blip, BOOL toggle);
	void SHOW_TICK_ON_BLIP(Blip blip, BOOL toggle);
	void SHOW_GOLD_TICK_ON_BLIP(Blip blip, BOOL toggle);
	void SHOW_FOR_SALE_ICON_ON_BLIP(Blip blip, BOOL toggle);
	void SHOW_HEADING_INDICATOR_ON_BLIP(Blip blip, BOOL toggle);
	void SHOW_OUTLINE_INDICATOR_ON_BLIP(Blip blip, BOOL toggle);
	void SHOW_FRIEND_INDICATOR_ON_BLIP(Blip blip, BOOL toggle);
	void SHOW_CREW_INDICATOR_ON_BLIP(Blip blip, BOOL toggle);
	void SET_BLIP_EXTENDED_HEIGHT_THRESHOLD(Blip blip, BOOL toggle);
	void SET_BLIP_SHORT_HEIGHT_THRESHOLD(Any p0, Any p1);
	void SET_BLIP_USE_HEIGHT_INDICATOR_ON_EDGE(Blip blip, Any p1);
	void SET_BLIP_AS_MINIMAL_ON_EDGE(Blip blip, BOOL toggle);
	void SET_RADIUS_BLIP_EDGE(Blip blip, BOOL toggle);
	BOOL DOES_BLIP_EXIST(Blip blip);
	void SET_WAYPOINT_OFF();
	void DELETE_WAYPOINTS_FROM_THIS_PLAYER();
	void REFRESH_WAYPOINT();
	BOOL IS_WAYPOINT_ACTIVE();
	void SET_NEW_WAYPOINT(float x, float y);
	void SET_BLIP_BRIGHT(Blip blip, BOOL toggle);
	void SET_BLIP_SHOW_CONE(Blip blip, BOOL toggle, int hudColorIndex);
	void REMOVE_COP_BLIP_FROM_PED(Ped ped);
	void SETUP_FAKE_CONE_DATA(Blip blip, float p1, float p2, float p3, float p4, float p5, float p6, Any p7, int p8);
	void REMOVE_FAKE_CONE_DATA(Blip blip);
	void CLEAR_FAKE_CONE_ARRAY();
	BOOL SET_MINIMAP_COMPONENT(int componentId, BOOL toggle, int overrideColor);
	void SET_MINIMAP_SONAR_SWEEP(BOOL toggle);
	void SHOW_ACCOUNT_PICKER();
	Blip GET_MAIN_PLAYER_BLIP_ID();
	void SET_PM_WARNINGSCREEN_ACTIVE(BOOL p0);
	void HIDE_LOADING_ON_FADE_THIS_FRAME();
	void SET_RADAR_AS_INTERIOR_THIS_FRAME(Hash interior, float x, float y, int z, int zoom);
	void SET_INSIDE_VERY_SMALL_INTERIOR(BOOL toggle);
	void SET_INSIDE_VERY_LARGE_INTERIOR(BOOL toggle);
	void SET_RADAR_AS_EXTERIOR_THIS_FRAME();
	void SET_FAKE_PAUSEMAP_PLAYER_POSITION_THIS_FRAME(float x, float y);
	void SET_FAKE_GPS_PLAYER_POSITION_THIS_FRAME(float x, float y, Any p2);
	BOOL IS_PAUSEMAP_IN_INTERIOR_MODE();
	void HIDE_MINIMAP_EXTERIOR_MAP_THIS_FRAME();
	void HIDE_MINIMAP_INTERIOR_MAP_THIS_FRAME();
	void SET_USE_ISLAND_MAP(BOOL toggle);
	void SET_PAUSE_EXTERIOR_RENDERING_WHILE_IN_INTERIOR_();
	void DONT_TILT_MINIMAP_THIS_FRAME();
	void DONT_ZOOM_MINIMAP_WHEN_RUNNING_THIS_FRAME();
	void DONT_ZOOM_MINIMAP_WHEN_SNIPING_THIS_FRAME();
	void SET_WIDESCREEN_FORMAT(Any p0);
	void DISPLAY_AREA_NAME(BOOL toggle);
	void DISPLAY_CASH(BOOL toggle);
	void USE_FAKE_MP_CASH(BOOL toggle);
	void CHANGE_FAKE_MP_CASH(int cash, int bank);
	void DISPLAY_AMMO_THIS_FRAME(BOOL display);
	void DISPLAY_SNIPER_SCOPE_THIS_FRAME();
	void HIDE_HUD_AND_RADAR_THIS_FRAME();
	void ALLOW_DISPLAY_OF_MULTIPLAYER_CASH_TEXT(BOOL allow);
	void SET_MULTIPLAYER_WALLET_CASH();
	void REMOVE_MULTIPLAYER_WALLET_CASH();
	void SET_MULTIPLAYER_BANK_CASH();
	void REMOVE_MULTIPLAYER_BANK_CASH();
	void SET_MULTIPLAYER_HUD_CASH(int p0, BOOL p1);
	void REMOVE_MULTIPLAYER_HUD_CASH();
	void HIDE_HELP_TEXT_THIS_FRAME();
	BOOL IS_IME_IN_PROGRESS();
	void DISPLAY_HELP_TEXT_THIS_FRAME(const char* message, BOOL p1);
	void HUD_FORCE_WEAPON_WHEEL(BOOL show);
	void HUD_FORCE_SPECIAL_VEHICLE_WEAPON_WHEEL();
	void HUD_SUPPRESS_WEAPON_WHEEL_RESULTS_THIS_FRAME();
	Hash HUD_GET_WEAPON_WHEEL_CURRENTLY_HIGHLIGHTED();
	void HUD_SET_WEAPON_WHEEL_TOP_SLOT(Hash weaponHash);
	Hash HUD_GET_WEAPON_WHEEL_TOP_SLOT(int weaponTypeIndex);
	void HUD_SHOWING_CHARACTER_SWITCH_SELECTION(BOOL toggle);
	void SET_GPS_FLAGS(int p0, float p1);
	void CLEAR_GPS_FLAGS();
	void SET_RACE_TRACK_RENDER(BOOL toggle);
	void CLEAR_GPS_RACE_TRACK();
	void START_GPS_CUSTOM_ROUTE(int hudColor, BOOL displayOnFoot, BOOL followPlayer);
	void ADD_POINT_TO_GPS_CUSTOM_ROUTE(float x, float y, float z);
	void SET_GPS_CUSTOM_ROUTE_RENDER(BOOL toggle, int radarThickness, int mapThickness);
	void CLEAR_GPS_CUSTOM_ROUTE();
	void START_GPS_MULTI_ROUTE(int hudColor, BOOL routeFromPlayer, BOOL displayOnFoot);
	void ADD_POINT_TO_GPS_MULTI_ROUTE(float x, float y, float z);
	void SET_GPS_MULTI_ROUTE_RENDER(BOOL toggle);
	void CLEAR_GPS_MULTI_ROUTE();
	void CLEAR_GPS_PLAYER_WAYPOINT();
	void SET_GPS_FLASHES(BOOL toggle);
	void SET_PLAYER_ICON_COLOUR(int color);
	void FLASH_MINIMAP_DISPLAY();
	void FLASH_MINIMAP_DISPLAY_WITH_COLOR(int hudColorIndex);
	void TOGGLE_STEALTH_RADAR(BOOL toggle);
	void SET_MINIMAP_IN_SPECTATOR_MODE(BOOL toggle, Ped ped);
	void SET_MISSION_NAME(BOOL p0, const char* name);
	void SET_MISSION_NAME_FOR_UGC_MISSION(BOOL p0, const char* name);
	void SET_DESCRIPTION_FOR_UGC_MISSION_EIGHT_STRINGS(BOOL p0, const char* p1, const char* p2, const char* p3, const char* p4, const char* p5, const char* p6, const char* p7, const char* p8);
	void SET_MINIMAP_BLOCK_WAYPOINT(BOOL toggle);
	void SET_MINIMAP_IN_PROLOGUE(BOOL toggle);
	void SET_MINIMAP_HIDE_FOW(BOOL toggle);
	float GET_MINIMAP_FOW_DISCOVERY_RATIO();
	BOOL GET_MINIMAP_FOW_COORDINATE_IS_REVEALED(float x, float y, float z);
	void SET_MINIMAP_FOW_DO_NOT_UPDATE(BOOL p0);
	void SET_MINIMAP_FOW_REVEAL_COORDINATE(float x, float y, float z);
	void SET_MINIMAP_GOLF_COURSE(int hole);
	void SET_MINIMAP_GOLF_COURSE_OFF();
	void LOCK_MINIMAP_ANGLE(int angle);
	void UNLOCK_MINIMAP_ANGLE();
	void LOCK_MINIMAP_POSITION(float x, float y);
	void UNLOCK_MINIMAP_POSITION();
	void SET_FAKE_MINIMAP_MAX_ALTIMETER_HEIGHT(float altitude, BOOL p1, Any p2);
	void SET_HEALTH_HUD_DISPLAY_VALUES(int health, int capacity, BOOL wasAdded);
	void SET_MAX_HEALTH_HUD_DISPLAY(int maximumValue);
	void SET_MAX_ARMOUR_HUD_DISPLAY(int maximumValue);
	void SET_BIGMAP_ACTIVE(BOOL toggleBigMap, BOOL showFullMap);
	BOOL IS_HUD_COMPONENT_ACTIVE(int id);
	BOOL IS_SCRIPTED_HUD_COMPONENT_ACTIVE(int id);
	void HIDE_SCRIPTED_HUD_COMPONENT_THIS_FRAME(int id);
	void SHOW_SCRIPTED_HUD_COMPONENT_THIS_FRAME(int id);
	BOOL IS_SCRIPTED_HUD_COMPONENT_HIDDEN_THIS_FRAME(int id);
	void HIDE_HUD_COMPONENT_THIS_FRAME(int id);
	void SHOW_HUD_COMPONENT_THIS_FRAME(int id);
	void HIDE_STREET_AND_CAR_NAMES_THIS_FRAME();
	void RESET_RETICULE_VALUES();
	void RESET_HUD_COMPONENT_VALUES(int id);
	void SET_HUD_COMPONENT_POSITION(int id, float x, float y);
	Vector3 GET_HUD_COMPONENT_POSITION(int id);
	void CLEAR_REMINDER_MESSAGE();
	int GET_HUD_SCREEN_POSITION_FROM_WORLD_POSITION(float worldX, float worldY, float worldZ, float* screenX, float* screenY);
	void OPEN_REPORTUGC_MENU();
	void FORCE_CLOSE_REPORTUGC_MENU();
	BOOL IS_REPORTUGC_MENU_OPEN();
	BOOL IS_FLOATING_HELP_TEXT_ON_SCREEN(int hudIndex);
	void SET_FLOATING_HELP_TEXT_SCREEN_POSITION(int hudIndex, float x, float y);
	void SET_FLOATING_HELP_TEXT_WORLD_POSITION(int hudIndex, float x, float y, float z);
	void SET_FLOATING_HELP_TEXT_TO_ENTITY(int hudIndex, Entity entity, float offsetX, float offsetY);
	void SET_FLOATING_HELP_TEXT_STYLE(int hudIndex, int p1, int p2, int p3, int p4, int p5);
	void CLEAR_FLOATING_HELP(int hudIndex, BOOL p1);
	void CREATE_MP_GAMER_TAG_WITH_CREW_COLOR(Player player, const char* username, BOOL pointedClanTag, BOOL isRockstarClan, const char* clanTag, int clanFlag, int r, int g, int b);
	BOOL IS_MP_GAMER_TAG_MOVIE_ACTIVE();
	int CREATE_FAKE_MP_GAMER_TAG(Ped ped, const char* username, BOOL pointedClanTag, BOOL isRockstarClan, const char* clanTag, int clanFlag);
	void REMOVE_MP_GAMER_TAG(int gamerTagId);
	BOOL IS_MP_GAMER_TAG_ACTIVE(int gamerTagId);
	BOOL IS_MP_GAMER_TAG_FREE(int gamerTagId);
	void SET_MP_GAMER_TAG_VISIBILITY(int gamerTagId, int component, BOOL toggle, Any p3);
	void SET_ALL_MP_GAMER_TAGS_VISIBILITY(int gamerTagId, BOOL toggle);
	void SET_MP_GAMER_TAGS_SHOULD_USE_VEHICLE_HEALTH(int gamerTagId, BOOL toggle);
	void SET_MP_GAMER_TAGS_SHOULD_USE_POINTS_HEALTH(int gamerTagId, BOOL toggle);
	void SET_MP_GAMER_TAGS_POINT_HEALTH(int gamerTagId, int value, int maximumValue);
	void SET_MP_GAMER_TAG_COLOUR(int gamerTagId, int component, int hudColorIndex);
	void SET_MP_GAMER_TAG_HEALTH_BAR_COLOUR(int gamerTagId, int hudColorIndex);
	void SET_MP_GAMER_TAG_ALPHA(int gamerTagId, int component, int alpha);
	void SET_MP_GAMER_TAG_WANTED_LEVEL(int gamerTagId, int wantedlvl);
	void SET_MP_GAMER_TAG_NUM_PACKAGES(int gamerTagId, int p1);
	void SET_MP_GAMER_TAG_NAME(int gamerTagId, const char* string);
	BOOL IS_UPDATING_MP_GAMER_TAG_NAME_AND_CREW_DETAILS(int gamerTagId);
	void SET_MP_GAMER_TAG_BIG_TEXT(int gamerTagId, const char* string);
	int GET_CURRENT_WEBPAGE_ID();
	int GET_CURRENT_WEBSITE_ID();
	int GET_GLOBAL_ACTIONSCRIPT_FLAG(int flagIndex);
	void RESET_GLOBAL_ACTIONSCRIPT_FLAG(int flagIndex);
	BOOL IS_WARNING_MESSAGE_READY_FOR_CONTROL();
	void SET_WARNING_MESSAGE(const char* titleMsg, int flags, const char* promptMsg, BOOL p3, int p4, const char* p5, const char* p6, BOOL showBackground, int errorCode);
	void SET_WARNING_MESSAGE_WITH_HEADER(const char* entryHeader, const char* entryLine1, int instructionalKey, const char* entryLine2, BOOL p4, Any p5, Any* showBackground, Any* p7, BOOL p8, Any p9);
	void SET_WARNING_MESSAGE_WITH_HEADER_AND_SUBSTRING_FLAGS(const char* entryHeader, const char* entryLine1, int instructionalKey, const char* entryLine2, BOOL p4, Any p5, Any additionalIntInfo, const char* additionalTextInfoLine1, const char* additionalTextInfoLine2, BOOL showBackground, int errorCode);
	void SET_WARNING_MESSAGE_WITH_HEADER_EXTENDED(const char* entryHeader, const char* entryLine1, int flags, const char* entryLine2, BOOL p4, Any p5, Any* p6, Any* p7, BOOL showBg, Any p9, Any p10);
	void SET_WARNING_MESSAGE_WITH_HEADER_AND_SUBSTRING_FLAGS_EXTENDED(const char* labelTitle, const char* labelMessage, int p2, int p3, const char* labelMessage2, BOOL p5, int p6, int p7, const char* p8, const char* p9, BOOL background, int errorCode);
	Hash GET_WARNING_SCREEN_MESSAGE_HASH();
	BOOL SET_WARNING_MESSAGE_OPTION_ITEMS(int index, const char* name, int cash, int rp, int lvl, int colour);
	BOOL SET_WARNING_MESSAGE_OPTION_HIGHLIGHT(Any p0);
	void REMOVE_WARNING_MESSAGE_OPTION_ITEMS();
	BOOL IS_WARNING_MESSAGE_ACTIVE();
	void CLEAR_DYNAMIC_PAUSE_MENU_ERROR_MESSAGE();
	void CUSTOM_MINIMAP_SET_ACTIVE(BOOL toggle);
	void CUSTOM_MINIMAP_SET_BLIP_OBJECT(int spriteId);
	int CUSTOM_MINIMAP_CREATE_BLIP(float x, float y, float z);
	void CUSTOM_MINIMAP_CLEAR_BLIPS();
	BOOL FORCE_SONAR_BLIPS_THIS_FRAME();
	Blip GET_NORTH_BLID_INDEX();
	void DISPLAY_PLAYER_NAME_TAGS_ON_BLIPS(BOOL toggle);
	void DRAW_FRONTEND_BACKGROUND_THIS_FRAME();
	void DRAW_HUD_OVER_FADE_THIS_FRAME();
	void ACTIVATE_FRONTEND_MENU(Hash menuhash, BOOL togglePause, int component);
	void RESTART_FRONTEND_MENU(Hash menuHash, int p1);
	Hash GET_CURRENT_FRONTEND_MENU_VERSION();
	void SET_PAUSE_MENU_ACTIVE(BOOL toggle);
	void DISABLE_FRONTEND_THIS_FRAME();
	void SUPPRESS_FRONTEND_RENDERING_THIS_FRAME();
	void ALLOW_PAUSE_WHEN_NOT_IN_STATE_OF_PLAY_THIS_FRAME();
	void SET_FRONTEND_ACTIVE(BOOL active);
	BOOL IS_PAUSE_MENU_ACTIVE();
	BOOL IS_STORE_PENDING_NETWORK_SHUTDOWN_TO_OPEN();
	int GET_PAUSE_MENU_STATE();
	Vector3 GET_PAUSE_MENU_POSITION();
	BOOL IS_PAUSE_MENU_RESTARTING();
	void FORCE_SCRIPTED_GFX_WHEN_FRONTEND_ACTIVE(const char* p0);
	void PAUSE_MENUCEPTION_GO_DEEPER(int page);
	void PAUSE_MENUCEPTION_THE_KICK();
	void PAUSE_TOGGLE_FULLSCREEN_MAP(Any p0);
	void PAUSE_MENU_ACTIVATE_CONTEXT(Hash contextHash);
	void PAUSE_MENU_DEACTIVATE_CONTEXT(Hash contextHash);
	BOOL PAUSE_MENU_IS_CONTEXT_ACTIVE(Hash contextHash);
	BOOL PAUSE_MENU_IS_CONTEXT_MENU_ACTIVE();
	int PAUSE_MENU_GET_HAIR_COLOUR_INDEX();
	int PAUSE_MENU_GET_MOUSE_HOVER_INDEX();
	int PAUSE_MENU_GET_MOUSE_HOVER_UNIQUE_ID();
	BOOL PAUSE_MENU_GET_MOUSE_CLICK_EVENT(Any* p0, Any* p1, Any* p2);
	void PAUSE_MENU_REDRAW_INSTRUCTIONAL_BUTTONS(int p0);
	void PAUSE_MENU_SET_BUSY_SPINNER(BOOL p0, int position, int spinnerIndex);
	void PAUSE_MENU_SET_WARN_ON_TAB_CHANGE(BOOL p0);
	BOOL IS_FRONTEND_READY_FOR_CONTROL();
	void TAKE_CONTROL_OF_FRONTEND();
	void RELEASE_CONTROL_OF_FRONTEND();
	BOOL CODE_WANTS_SCRIPT_TO_TAKE_CONTROL();
	int GET_SCREEN_CODE_WANTS_SCRIPT_TO_CONTROL();
	BOOL IS_NAVIGATING_MENU_CONTENT();
	BOOL HAS_MENU_TRIGGER_EVENT_OCCURRED();
	BOOL HAS_MENU_LAYOUT_CHANGED_EVENT_OCCURRED();
	void SET_SAVEGAME_LIST_UNIQUE_ID(Any p0);
	void GET_MENU_TRIGGER_EVENT_DETAILS(int* lastItemMenuId, int* selectedItemUniqueId);
	void GET_MENU_LAYOUT_CHANGED_EVENT_DETAILS(int* lastItemMenuId, int* selectedItemMenuId, int* selectedItemUniqueId);
	BOOL GET_PM_PLAYER_CREW_COLOR(int* r, int* g, int* b);
	BOOL GET_MENU_PED_INT_STAT(Any p0, Any* p1);
	BOOL GET_CHARACTER_MENU_PED_INT_STAT(Any p0, Any* p1, Any p2);
	BOOL GET_MENU_PED_MASKED_INT_STAT(Hash statHash, int* outValue, int mask, BOOL p3);
	BOOL GET_CHARACTER_MENU_PED_MASKED_INT_STAT(Hash statHash, Any* outValue, int p2, int mask, BOOL p4);
	BOOL GET_MENU_PED_FLOAT_STAT(Hash statHash, float* outValue);
	BOOL GET_CHARACTER_MENU_PED_FLOAT_STAT(float statHash, float* outValue, BOOL p2);
	BOOL GET_MENU_PED_BOOL_STAT(Hash statHash, BOOL* outValue);
	void CLEAR_PED_IN_PAUSE_MENU();
	void GIVE_PED_TO_PAUSE_MENU(Ped ped, int p1);
	void SET_PAUSE_MENU_PED_LIGHTING(BOOL state);
	void SET_PAUSE_MENU_PED_SLEEP_STATE(BOOL state);
	void OPEN_ONLINE_POLICIES_MENU();
	BOOL ARE_ONLINE_POLICIES_UP_TO_DATE();
	BOOL IS_ONLINE_POLICIES_MENU_ACTIVE();
	void OPEN_SOCIAL_CLUB_MENU(Hash menu);
	void CLOSE_SOCIAL_CLUB_MENU();
	void SET_SOCIAL_CLUB_TOUR(const char* name);
	BOOL IS_SOCIAL_CLUB_ACTIVE();
	void SET_TEXT_INPUT_BOX_ENABLED(BOOL p0);
	void FORCE_CLOSE_TEXT_INPUT_BOX();
	void SET_ALLOW_COMMA_ON_TEXT_INPUT(Any p0);
	void OVERRIDE_MP_TEXT_CHAT_TEAM_STRING(Hash gxtEntryHash);
	BOOL IS_MP_TEXT_CHAT_TYPING();
	void CLOSE_MP_TEXT_CHAT();
	void MP_TEXT_CHAT_IS_TEAM_JOB(Any p0);
	void OVERRIDE_MP_TEXT_CHAT_COLOR(int p0, int hudColor);
	void MP_TEXT_CHAT_DISABLE(BOOL toggle);
	void FLAG_PLAYER_CONTEXT_IN_TOURNAMENT(BOOL toggle);
	void SET_PED_HAS_AI_BLIP(Ped ped, BOOL hasCone);
	void SET_PED_HAS_AI_BLIP_WITH_COLOUR(Ped ped, BOOL hasCone, int color);
	BOOL DOES_PED_HAVE_AI_BLIP(Ped ped);
	void SET_PED_AI_BLIP_GANG_ID(Ped ped, int gangId);
	void SET_PED_AI_BLIP_HAS_CONE(Ped ped, BOOL toggle);
	void SET_PED_AI_BLIP_FORCED_ON(Ped ped, BOOL toggle);
	void SET_PED_AI_BLIP_NOTICE_RANGE(Ped ped, float range);
	void SET_PED_AI_BLIP_SPRITE(Ped ped, int spriteId);
	Blip GET_AI_PED_PED_BLIP_INDEX(Ped ped);
	Blip GET_AI_PED_VEHICLE_BLIP_INDEX(Ped ped);
	BOOL HAS_DIRECTOR_MODE_BEEN_LAUNCHED_BY_CODE();
	void SET_DIRECTOR_MODE_LAUNCHED_BY_SCRIPT();
	void SET_PLAYER_IS_IN_DIRECTOR_MODE(BOOL toggle);
	void SET_DIRECTOR_MODE_AVAILABLE(BOOL toggle);
	void HIDE_HUDMARKERS_THIS_FRAME();
}

namespace INTERIOR
{
	float GET_INTERIOR_HEADING(Interior interior);
	void GET_INTERIOR_LOCATION_AND_NAMEHASH(Interior interior, Vector3* position, Hash* nameHash);
	int GET_INTERIOR_GROUP_ID(Interior interior);
	Vector3 GET_OFFSET_FROM_INTERIOR_IN_WORLD_COORDS(Interior interior, float x, float y, float z);
	BOOL IS_INTERIOR_SCENE();
	BOOL IS_VALID_INTERIOR(Interior interior);
	void CLEAR_ROOM_FOR_ENTITY(Entity entity);
	void FORCE_ROOM_FOR_ENTITY(Entity entity, Interior interior, Hash roomHashKey);
	Hash GET_ROOM_KEY_FROM_ENTITY(Entity entity);
	Hash GET_KEY_FOR_ENTITY_IN_ROOM(Entity entity);
	Interior GET_INTERIOR_FROM_ENTITY(Entity entity);
	void RETAIN_ENTITY_IN_INTERIOR(Entity entity, Interior interior);
	void CLEAR_INTERIOR_STATE_OF_ENTITY(Entity entity);
	void FORCE_ACTIVATING_TRACKING_ON_ENTITY(Any p0, Any p1);
	void FORCE_ROOM_FOR_GAME_VIEWPORT(int interiorID, Hash roomHashKey);
	void SET_ROOM_FOR_GAME_VIEWPORT_BY_NAME(const char* roomName);
	void SET_ROOM_FOR_GAME_VIEWPORT_BY_KEY(Hash roomHashKey);
	Hash GET_ROOM_KEY_FOR_GAME_VIEWPORT();
	void CLEAR_ROOM_FOR_GAME_VIEWPORT();
	Interior GET_INTERIOR_FROM_PRIMARY_VIEW();
	Interior GET_INTERIOR_AT_COORDS(float x, float y, float z);
	void ADD_PICKUP_TO_INTERIOR_ROOM_BY_NAME(Pickup pickup, const char* roomName);
	void PIN_INTERIOR_IN_MEMORY(Interior interior);
	void UNPIN_INTERIOR(Interior interior);
	BOOL IS_INTERIOR_READY(Interior interior);
	BOOL SET_INTERIOR_IN_USE(Interior interior);
	Interior GET_INTERIOR_AT_COORDS_WITH_TYPE(float x, float y, float z, const char* interiorType);
	Interior GET_INTERIOR_AT_COORDS_WITH_TYPEHASH(float x, float y, float z, Hash typeHash);
	void ACTIVATE_INTERIOR_GROUPS_USING_CAMERA();
	BOOL IS_COLLISION_MARKED_OUTSIDE(float x, float y, float z);
	Interior GET_INTERIOR_FROM_COLLISION(float x, float y, float z);
	void ENABLE_STADIUM_PROBES_THIS_FRAME(BOOL toggle);
	void ACTIVATE_INTERIOR_ENTITY_SET(Interior interior, const char* entitySetName);
	void DEACTIVATE_INTERIOR_ENTITY_SET(Interior interior, const char* entitySetName);
	BOOL IS_INTERIOR_ENTITY_SET_ACTIVE(Interior interior, const char* entitySetName);
	void SET_INTERIOR_ENTITY_SET_TINT_INDEX(Interior interior, const char* entitySetName, int color);
	void REFRESH_INTERIOR(Interior interior);
	void ENABLE_EXTERIOR_CULL_MODEL_THIS_FRAME(Hash mapObjectHash);
	void ENABLE_SHADOW_CULL_MODEL_THIS_FRAME(Hash mapObjectHash);
	void DISABLE_INTERIOR(Interior interior, BOOL toggle);
	BOOL IS_INTERIOR_DISABLED(Interior interior);
	void CAP_INTERIOR(Interior interior, BOOL toggle);
	BOOL IS_INTERIOR_CAPPED(Interior interior);
	void DISABLE_METRO_SYSTEM(BOOL toggle);
	void SET_IS_EXTERIOR_ONLY(Entity entity, BOOL toggle);
}

namespace ITEMSET
{
	ScrHandle CREATE_ITEMSET(BOOL p0);
	void DESTROY_ITEMSET(ScrHandle itemset);
	BOOL IS_ITEMSET_VALID(ScrHandle itemset);
	BOOL ADD_TO_ITEMSET(ScrHandle item, ScrHandle itemset);
	void REMOVE_FROM_ITEMSET(ScrHandle item, ScrHandle itemset);
	int GET_ITEMSET_SIZE(ScrHandle itemset);
	ScrHandle GET_INDEXED_ITEM_IN_ITEMSET(int index, ScrHandle itemset);
	BOOL IS_IN_ITEMSET(ScrHandle item, ScrHandle itemset);
	void CLEAN_ITEMSET(ScrHandle itemset);
}

namespace LOADINGSCREEN
{
	BOOL LOBBY_AUTO_MULTIPLAYER_MENU();
	BOOL LOBBY_AUTO_MULTIPLAYER_FREEMODE();
	void LOBBY_SET_AUTO_MULTIPLAYER(BOOL toggle);
	BOOL LOBBY_AUTO_MULTIPLAYER_EVENT();
	void LOBBY_SET_AUTO_MULTIPLAYER_EVENT(BOOL toggle);
	BOOL LOBBY_AUTO_MULTIPLAYER_RANDOM_JOB();
	void LOBBY_SET_AUTO_MP_RANDOM_JOB(BOOL toggle);
	void SHUTDOWN_SESSION_CLEARS_AUTO_MULTIPLAYER(BOOL toggle);
}

namespace LOCALIZATION
{
	int LOCALIZATION_GET_SYSTEM_LANGUAGE();
	int GET_CURRENT_LANGUAGE();
	int LOCALIZATION_GET_SYSTEM_DATE_TYPE();
}

namespace MISC
{
	int GET_ALLOCATED_STACK_SIZE();
	int GET_NUMBER_OF_FREE_STACKS_OF_THIS_SIZE(int stackSize);
	void SET_RANDOM_SEED(int seed);
	void SET_TIME_SCALE(float timeScale);
	void SET_MISSION_FLAG(BOOL toggle);
	BOOL GET_MISSION_FLAG();
	void SET_RANDOM_EVENT_FLAG(BOOL toggle);
	BOOL GET_RANDOM_EVENT_FLAG();
	const char* GET_CONTENT_TO_LOAD();
	void ACTIVITY_FEED_CREATE(const char* p0, const char* p1);
	void ACTIVITY_FEED_ADD_SUBSTRING_TO_CAPTION(const char* p0);
	void ACTIVITY_FEED_ADD_LITERAL_SUBSTRING_TO_CAPTION(const char* p0);
	void ACTIVITY_FEED_ADD_INT_TO_CAPTION(Any p0);
	void ACTIVITY_FEED_LARGE_IMAGE_URL(const char* p0);
	void ACTIVITY_FEED_ACTION_START_WITH_COMMAND_LINE(const char* p0, const char* p1);
	void ACTIVITY_FEED_ACTION_START_WITH_COMMAND_LINE_ADD(const char* p0);
	void ACTIVITY_FEED_POST();
	void ACTIVITY_FEED_ONLINE_PLAYED_WITH_POST(const char* p0);
	BOOL HAS_RESUMED_FROM_SUSPEND();
	void SET_SCRIPT_HIGH_PRIO(BOOL toggle);
	void SET_THIS_IS_A_TRIGGER_SCRIPT(BOOL toggle);
	void INFORM_CODE_OF_CONTENT_ID_OF_CURRENT_UGC_MISSION(const char* p0);
	BOOL GET_BASE_ELEMENT_LOCATION_FROM_METADATA_BLOCK(Any* p0, Any* p1, Any p2, BOOL p3);
	Hash GET_PREV_WEATHER_TYPE_HASH_NAME();
	Hash GET_NEXT_WEATHER_TYPE_HASH_NAME();
	BOOL IS_PREV_WEATHER_TYPE(const char* weatherType);
	BOOL IS_NEXT_WEATHER_TYPE(const char* weatherType);
	void SET_WEATHER_TYPE_PERSIST(const char* weatherType);
	void SET_WEATHER_TYPE_NOW_PERSIST(const char* weatherType);
	void SET_WEATHER_TYPE_NOW(const char* weatherType);
	void SET_WEATHER_TYPE_OVERTIME_PERSIST(const char* weatherType, float time);
	void SET_RANDOM_WEATHER_TYPE();
	void CLEAR_WEATHER_TYPE_PERSIST();
	void CLEAR_WEATHER_TYPE_NOW_PERSIST_NETWORK(int milliseconds);
	void GET_CURR_WEATHER_STATE(Hash* weatherType1, Hash* weatherType2, float* percentWeather2);
	void SET_CURR_WEATHER_STATE(Hash weatherType1, Hash weatherType2, float percentWeather2);
	void SET_OVERRIDE_WEATHER(const char* weatherType);
	void SET_OVERRIDE_WEATHEREX(const char* weatherType, BOOL p1);
	void CLEAR_OVERRIDE_WEATHER();
	void WATER_OVERRIDE_SET_SHOREWAVEAMPLITUDE(float amplitude);
	void WATER_OVERRIDE_SET_SHOREWAVEMINAMPLITUDE(float minAmplitude);
	void WATER_OVERRIDE_SET_SHOREWAVEMAXAMPLITUDE(float maxAmplitude);
	void WATER_OVERRIDE_SET_OCEANNOISEMINAMPLITUDE(float minAmplitude);
	void WATER_OVERRIDE_SET_OCEANWAVEAMPLITUDE(float amplitude);
	void WATER_OVERRIDE_SET_OCEANWAVEMINAMPLITUDE(float minAmplitude);
	void WATER_OVERRIDE_SET_OCEANWAVEMAXAMPLITUDE(float maxAmplitude);
	void WATER_OVERRIDE_SET_RIPPLEBUMPINESS(float bumpiness);
	void WATER_OVERRIDE_SET_RIPPLEMINBUMPINESS(float minBumpiness);
	void WATER_OVERRIDE_SET_RIPPLEMAXBUMPINESS(float maxBumpiness);
	void WATER_OVERRIDE_SET_RIPPLEDISTURB(float disturb);
	void WATER_OVERRIDE_SET_STRENGTH(float strength);
	void WATER_OVERRIDE_FADE_IN(float p0);
	void WATER_OVERRIDE_FADE_OUT(float p0);
	void SET_WIND(float speed);
	void SET_WIND_SPEED(float speed);
	float GET_WIND_SPEED();
	void SET_WIND_DIRECTION(float direction);
	Vector3 GET_WIND_DIRECTION();
	void SET_RAIN(float intensity);
	float GET_RAIN_LEVEL();
	void SET_SNOW(float level);
	float GET_SNOW_LEVEL();
	void FORCE_LIGHTNING_FLASH();
	void SET_CLOUD_SETTINGS_OVERRIDE(const char* p0);
	void PRELOAD_CLOUD_HAT(const char* name);
	void LOAD_CLOUD_HAT(const char* name, float transitionTime);
	void UNLOAD_CLOUD_HAT(const char* name, float p1);
	void UNLOAD_ALL_CLOUD_HATS();
	void SET_CLOUDS_ALPHA(float opacity);
	float GET_CLOUDS_ALPHA();
	int GET_GAME_TIMER();
	float GET_FRAME_TIME();
	float GET_SYSTEM_TIME_STEP();
	int GET_FRAME_COUNT();
	float GET_RANDOM_FLOAT_IN_RANGE(float startRange, float endRange);
	int GET_RANDOM_INT_IN_RANGE(int startRange, int endRange);
	int GET_RANDOM_MWC_INT_IN_RANGE(int startRange, int endRange);
	BOOL GET_GROUND_Z_FOR_3D_COORD(float x, float y, float z, float* groundZ, BOOL ignoreWater, BOOL p5);
	BOOL GET_GROUND_Z_AND_NORMAL_FOR_3D_COORD(float x, float y, float z, float* groundZ, Vector3* normal);
	BOOL GET_GROUND_Z_EXCLUDING_OBJECTS_FOR_3D_COORD(float x, float y, float z, float* groundZ, BOOL p4, BOOL p5);
	float ASIN(float p0);
	float ACOS(float p0);
	float TAN(float p0);
	float ATAN(float p0);
	float ATAN2(float p0, float p1);
	float GET_DISTANCE_BETWEEN_COORDS(float x1, float y1, float z1, float x2, float y2, float z2, BOOL useZ);
	float GET_ANGLE_BETWEEN_2D_VECTORS(float x1, float y1, float x2, float y2);
	float GET_HEADING_FROM_VECTOR_2D(float dx, float dy);
	float GET_RATIO_OF_CLOSEST_POINT_ON_LINE(float x1, float y1, float z1, float x2, float y2, float z2, float x3, float y3, float z3, BOOL clamp);
	Vector3 GET_CLOSEST_POINT_ON_LINE(float x1, float y1, float z1, float x2, float y2, float z2, float x3, float y3, float z3, BOOL clamp);
	BOOL GET_LINE_PLANE_INTERSECTION(float p0, float p1, float p2, float p3, float p4, float p5, float p6, float p7, float p8, float p9, float p10, float p11, float* p12);
	BOOL GET_POINT_AREA_OVERLAP(Any p0, Any p1, Any p2, Any p3, Any p4, Any p5, Any p6, Any p7, Any p8, Any p9, Any p10, Any p11, Any p12, Any p13);
	void SET_BIT(int* address, int offset);
	void CLEAR_BIT(int* address, int offset);
	Hash GET_HASH_KEY(const char* string);
	void SLERP_NEAR_QUATERNION(float t, float x, float y, float z, float w, float x1, float y1, float z1, float w1, float* outX, float* outY, float* outZ, float* outW);
	BOOL IS_AREA_OCCUPIED(float p0, float p1, float p2, float p3, float p4, float p5, BOOL p6, BOOL p7, BOOL p8, BOOL p9, BOOL p10, Any p11, BOOL p12);
	BOOL IS_AREA_OCCUPIED_SLOW(Any p0, Any p1, Any p2, Any p3, Any p4, Any p5, Any p6, Any p7, Any p8, Any p9, Any p10, Any p11, Any p12);
	BOOL IS_POSITION_OCCUPIED(float x, float y, float z, float range, BOOL p4, BOOL checkVehicles, BOOL checkPeds, BOOL p7, BOOL p8, Entity ignoreEntity, BOOL p10);
	BOOL IS_POINT_OBSCURED_BY_A_MISSION_ENTITY(float p0, float p1, float p2, float p3, float p4, float p5, Any p6);
	void CLEAR_AREA(float X, float Y, float Z, float radius, BOOL p4, BOOL ignoreCopCars, BOOL ignoreObjects, BOOL p7);
	void CLEAR_AREA_LEAVE_VEHICLE_HEALTH(float x, float y, float z, float radius, BOOL p4, BOOL p5, BOOL p6, BOOL p7);
	void CLEAR_AREA_OF_VEHICLES(float x, float y, float z, float radius, BOOL p4, BOOL p5, BOOL p6, BOOL p7, BOOL p8, BOOL p9, Any p10);
	void CLEAR_ANGLED_AREA_OF_VEHICLES(float x1, float y1, float z1, float x2, float y2, float z2, float width, BOOL p7, BOOL p8, BOOL p9, BOOL p10, BOOL p11, Any p12, Any p13);
	void CLEAR_AREA_OF_OBJECTS(float x, float y, float z, float radius, int flags);
	void CLEAR_AREA_OF_PEDS(float x, float y, float z, float radius, int flags);
	void CLEAR_AREA_OF_COPS(float x, float y, float z, float radius, int flags);
	void CLEAR_AREA_OF_PROJECTILES(float x, float y, float z, float radius, int flags);
	void CLEAR_SCENARIO_SPAWN_HISTORY();
	void SET_SAVE_MENU_ACTIVE(BOOL ignoreVehicle);
	int GET_STATUS_OF_MANUAL_SAVE();
	void SET_CREDITS_ACTIVE(BOOL toggle);
	void SET_CREDITS_FADE_OUT_WITH_SCREEN(BOOL toggle);
	BOOL HAVE_CREDITS_REACHED_END();
	BOOL ARE_CREDITS_RUNNING();
	void TERMINATE_ALL_SCRIPTS_WITH_THIS_NAME(const char* scriptName);
	void NETWORK_SET_SCRIPT_IS_SAFE_FOR_NETWORK_GAME();
	int ADD_HOSPITAL_RESTART(float x, float y, float z, float p3, Any p4);
	void DISABLE_HOSPITAL_RESTART(int hospitalIndex, BOOL toggle);
	int ADD_POLICE_RESTART(float p0, float p1, float p2, float p3, Any p4);
	void DISABLE_POLICE_RESTART(int policeIndex, BOOL toggle);
	void SET_RESTART_COORD_OVERRIDE(float x, float y, float z, float heading);
	void CLEAR_RESTART_COORD_OVERRIDE();
	void PAUSE_DEATH_ARREST_RESTART(BOOL toggle);
	void IGNORE_NEXT_RESTART(BOOL toggle);
	void SET_FADE_OUT_AFTER_DEATH(BOOL toggle);
	void SET_FADE_OUT_AFTER_ARREST(BOOL toggle);
	void SET_FADE_IN_AFTER_DEATH_ARREST(BOOL toggle);
	void SET_FADE_IN_AFTER_LOAD(BOOL toggle);
	int REGISTER_SAVE_HOUSE(float x, float y, float z, float p3, const char* p4, Any p5, Any p6);
	void SET_SAVE_HOUSE(int savehouseHandle, BOOL p1, BOOL p2);
	BOOL OVERRIDE_SAVE_HOUSE(BOOL p0, float p1, float p2, float p3, float p4, BOOL p5, float p6, float p7);
	BOOL GET_SAVE_HOUSE_DETAILS_AFTER_SUCCESSFUL_LOAD(Vector3* p0, float* p1, BOOL* fadeInAfterLoad, BOOL* p3);
	void DO_AUTO_SAVE();
	BOOL GET_IS_AUTO_SAVE_OFF();
	BOOL IS_AUTO_SAVE_IN_PROGRESS();
	BOOL HAS_CODE_REQUESTED_AUTOSAVE();
	void CLEAR_CODE_REQUESTED_AUTOSAVE();
	void BEGIN_REPLAY_STATS(Any p0, Any p1);
	void ADD_REPLAY_STAT_VALUE(Any value);
	void END_REPLAY_STATS();
	BOOL HAVE_REPLAY_STATS_BEEN_STORED();
	int GET_REPLAY_STAT_MISSION_ID();
	int GET_REPLAY_STAT_MISSION_TYPE();
	int GET_REPLAY_STAT_COUNT();
	int GET_REPLAY_STAT_AT_INDEX(int index);
	void CLEAR_REPLAY_STATS();
	BOOL QUEUE_MISSION_REPEAT_LOAD();
	BOOL QUEUE_MISSION_REPEAT_SAVE();
	BOOL QUEUE_MISSION_REPEAT_SAVE_FOR_BENCHMARK_TEST();
	int GET_STATUS_OF_MISSION_REPEAT_SAVE();
	BOOL IS_MEMORY_CARD_IN_USE();
	void SHOOT_SINGLE_BULLET_BETWEEN_COORDS(float x1, float y1, float z1, float x2, float y2, float z2, int damage, BOOL p7, Hash weaponHash, Ped ownerPed, BOOL isAudible, BOOL isInvisible, float speed);
	void SHOOT_SINGLE_BULLET_BETWEEN_COORDS_IGNORE_ENTITY(float x1, float y1, float z1, float x2, float y2, float z2, int damage, BOOL p7, Hash weaponHash, Ped ownerPed, BOOL isAudible, BOOL isInvisible, float speed, Entity entity, Any p14);
	void SHOOT_SINGLE_BULLET_BETWEEN_COORDS_IGNORE_ENTITY_NEW(float x1, float y1, float z1, float x2, float y2, float z2, int damage, BOOL p7, Hash weaponHash, Ped ownerPed, BOOL isAudible, BOOL isInvisible, float speed, Entity entity, BOOL p14, BOOL p15, Entity targetEntity, BOOL p17, Any p18, Any p19, Any p20);
	void GET_MODEL_DIMENSIONS(Hash modelHash, Vector3* minimum, Vector3* maximum);
	void SET_FAKE_WANTED_LEVEL(int fakeWantedLevel);
	int GET_FAKE_WANTED_LEVEL();
	void USING_MISSION_CREATOR(BOOL toggle);
	void ALLOW_MISSION_CREATOR_WARP(BOOL toggle);
	void SET_MINIGAME_IN_PROGRESS(BOOL toggle);
	BOOL IS_MINIGAME_IN_PROGRESS();
	BOOL IS_THIS_A_MINIGAME_SCRIPT();
	BOOL IS_SNIPER_INVERTED();
	BOOL SHOULD_USE_METRIC_MEASUREMENTS();
	int GET_PROFILE_SETTING(int profileSetting);
	BOOL ARE_STRINGS_EQUAL(const char* string1, const char* string2);
	int COMPARE_STRINGS(const char* str1, const char* str2, BOOL matchCase, int maxLength);
	int ABSI(int value);
	float ABSF(float value);
	BOOL IS_SNIPER_BULLET_IN_AREA(float x1, float y1, float z1, float x2, float y2, float z2);
	BOOL IS_PROJECTILE_IN_AREA(float x1, float y1, float z1, float x2, float y2, float z2, BOOL ownedByPlayer);
	BOOL IS_PROJECTILE_TYPE_IN_AREA(float x1, float y1, float z1, float x2, float y2, float z2, int type, BOOL ownedByPlayer);
	BOOL IS_PROJECTILE_TYPE_IN_ANGLED_AREA(float x1, float y1, float z1, float x2, float y2, float z2, float width, Any p7, BOOL ownedByPlayer);
	BOOL IS_PROJECTILE_TYPE_WITHIN_DISTANCE(float x, float y, float z, Hash projectileHash, float radius, BOOL ownedByPlayer);
	BOOL GET_COORDS_OF_PROJECTILE_TYPE_IN_AREA(float x1, float y1, float z1, float x2, float y2, float z2, Hash projectileHash, Vector3* projectilePos, BOOL ownedByPlayer);
	BOOL GET_COORDS_OF_PROJECTILE_TYPE_IN_ANGLED_AREA(float vecAngledAreaPoint1X, float vecAngledAreaPoint1Y, float vecAngledAreaPoint1Z, float vecAngledAreaPoint2X, float vecAngledAreaPoint2Y, float vecAngledAreaPoint2Z, float distanceOfOppositeFace, Hash weaponType, Vector3* positionOut, BOOL bIsPlayer);
	BOOL GET_COORDS_OF_PROJECTILE_TYPE_WITHIN_DISTANCE(Ped ped, Hash weaponHash, float distance, Vector3* outCoords, BOOL p4);
	BOOL GET_PROJECTILE_OF_PROJECTILE_TYPE_WITHIN_DISTANCE(Ped ped, Hash weaponHash, float distance, Vector3* outCoords, Object* outProjectile, BOOL p5);
	BOOL IS_BULLET_IN_ANGLED_AREA(float x1, float y1, float z1, float x2, float y2, float z2, float width, BOOL ownedByPlayer);
	BOOL IS_BULLET_IN_AREA(float x, float y, float z, float radius, BOOL ownedByPlayer);
	BOOL IS_BULLET_IN_BOX(float x1, float y1, float z1, float x2, float y2, float z2, BOOL ownedByPlayer);
	BOOL HAS_BULLET_IMPACTED_IN_AREA(float x, float y, float z, float p3, BOOL p4, BOOL p5);
	BOOL HAS_BULLET_IMPACTED_IN_BOX(float p0, float p1, float p2, float p3, float p4, float p5, BOOL p6, BOOL p7);
	BOOL IS_ORBIS_VERSION();
	BOOL IS_DURANGO_VERSION();
	BOOL IS_XBOX360_VERSION();
	BOOL IS_PS3_VERSION();
	BOOL IS_PC_VERSION();
	BOOL IS_STEAM_VERSION();
	BOOL IS_AUSSIE_VERSION();
	BOOL IS_JAPANESE_VERSION();
	BOOL IS_XBOX_PLATFORM();
	BOOL IS_SCARLETT_VERSION();
	BOOL IS_SCE_PLATFORM();
	BOOL IS_PROSPERO_VERSION();
	BOOL IS_STRING_NULL(const char* string);
	BOOL IS_STRING_NULL_OR_EMPTY(const char* string);
	BOOL STRING_TO_INT(const char* string, int* outInteger);
	void SET_BITS_IN_RANGE(int* var, int rangeStart, int rangeEnd, int p3);
	int GET_BITS_IN_RANGE(int var, int rangeStart, int rangeEnd);
	int ADD_STUNT_JUMP(float x1, float y1, float z1, float x2, float y2, float z2, float x3, float y3, float z3, float x4, float y4, float z4, float camX, float camY, float camZ, int p15, int p16, int p17);
	int ADD_STUNT_JUMP_ANGLED(float x1, float y1, float z1, float x2, float y2, float z2, float radius1, float x3, float y3, float z3, float x4, float y4, float z4, float radius2, float camX, float camY, float camZ, int p17, int p18, int p19);
	void TOGGLE_SHOW_OPTIONAL_STUNT_JUMP_CAMERA(BOOL toggle);
	void DELETE_STUNT_JUMP(int p0);
	void ENABLE_STUNT_JUMP_SET(int p0);
	void DISABLE_STUNT_JUMP_SET(int p0);
	void SET_STUNT_JUMPS_CAN_TRIGGER(BOOL toggle);
	BOOL IS_STUNT_JUMP_IN_PROGRESS();
	BOOL IS_STUNT_JUMP_MESSAGE_SHOWING();
	int GET_NUM_SUCCESSFUL_STUNT_JUMPS();
	int GET_TOTAL_SUCCESSFUL_STUNT_JUMPS();
	void CANCEL_STUNT_JUMP();
	void SET_GAME_PAUSED(BOOL toggle);
	void SET_THIS_SCRIPT_CAN_BE_PAUSED(BOOL toggle);
	void SET_THIS_SCRIPT_CAN_REMOVE_BLIPS_CREATED_BY_ANY_SCRIPT(BOOL toggle);
	BOOL HAS_CHEAT_WITH_HASH_BEEN_ACTIVATED(Hash hash, int amount);
	BOOL HAS_PC_CHEAT_WITH_HASH_BEEN_ACTIVATED(Hash hash);
	void OVERRIDE_FREEZE_FLAGS(BOOL p0);
	void SET_INSTANCE_PRIORITY_MODE(int p0);
	void SET_INSTANCE_PRIORITY_HINT(int flag);
	BOOL IS_FRONTEND_FADING();
	void POPULATE_NOW();
	int GET_INDEX_OF_CURRENT_LEVEL();
	void SET_GRAVITY_LEVEL(int level);
	void START_SAVE_DATA(Any* p0, Any p1, BOOL p2);
	void STOP_SAVE_DATA();
	int GET_SIZE_OF_SAVE_DATA(BOOL p0);
	void REGISTER_INT_TO_SAVE(Any* p0, const char* name);
	void REGISTER_INT64_TO_SAVE(Any* p0, const char* name);
	void REGISTER_ENUM_TO_SAVE(Any* p0, const char* name);
	void REGISTER_FLOAT_TO_SAVE(Any* p0, const char* name);
	void REGISTER_BOOL_TO_SAVE(Any* p0, const char* name);
	void REGISTER_TEXT_LABEL_TO_SAVE(Any* p0, const char* name);
	void REGISTER_TEXT_LABEL_15_TO_SAVE(Any* p0, const char* name);
	void REGISTER_TEXT_LABEL_23_TO_SAVE(Any* p0, const char* name);
	void REGISTER_TEXT_LABEL_31_TO_SAVE(Any* p0, const char* name);
	void REGISTER_TEXT_LABEL_63_TO_SAVE(Any* p0, const char* name);
	void START_SAVE_STRUCT_WITH_SIZE(Any* p0, int size, const char* structName);
	void STOP_SAVE_STRUCT();
	void START_SAVE_ARRAY_WITH_SIZE(Any* p0, int size, const char* arrayName);
	void STOP_SAVE_ARRAY();
	void COPY_SCRIPT_STRUCT(Any* dst, Any* src, int size);
	void ENABLE_DISPATCH_SERVICE(int dispatchService, BOOL toggle);
	void BLOCK_DISPATCH_SERVICE_RESOURCE_CREATION(int dispatchService, BOOL toggle);
	int GET_NUMBER_RESOURCES_ALLOCATED_TO_WANTED_LEVEL(int dispatchService);
	BOOL CREATE_INCIDENT(int dispatchService, float x, float y, float z, int numUnits, float radius, int* outIncidentID, Any p7, Any p8);
	BOOL CREATE_INCIDENT_WITH_ENTITY(int dispatchService, Ped ped, int numUnits, float radius, int* outIncidentID, Any p5, Any p6);
	void DELETE_INCIDENT(int incidentId);
	BOOL IS_INCIDENT_VALID(int incidentId);
	void SET_INCIDENT_REQUESTED_UNITS(int incidentId, int dispatchService, int numUnits);
	void SET_IDEAL_SPAWN_DISTANCE_FOR_INCIDENT(int incidentId, float p1);
	BOOL FIND_SPAWN_POINT_IN_DIRECTION(float posX, float posY, float posZ, float fwdVecX, float fwdVecY, float fwdVecZ, float distance, Vector3* spawnPoint);
	int ADD_POP_MULTIPLIER_AREA(float x1, float y1, float z1, float x2, float y2, float z2, float p6, float p7, BOOL p8, BOOL p9);
	BOOL DOES_POP_MULTIPLIER_AREA_EXIST(int id);
	void REMOVE_POP_MULTIPLIER_AREA(int id, BOOL p1);
	BOOL IS_POP_MULTIPLIER_AREA_NETWORKED(int id);
	int ADD_POP_MULTIPLIER_SPHERE(float x, float y, float z, float radius, float pedMultiplier, float vehicleMultiplier, BOOL p6, BOOL p7);
	BOOL DOES_POP_MULTIPLIER_SPHERE_EXIST(int id);
	void REMOVE_POP_MULTIPLIER_SPHERE(int id, BOOL p1);
	void ENABLE_TENNIS_MODE(Ped ped, BOOL toggle, BOOL p2);
	BOOL IS_TENNIS_MODE(Ped ped);
	void PLAY_TENNIS_SWING_ANIM(Ped ped, const char* animDict, const char* animName, float p3, float p4, BOOL p5);
	BOOL GET_TENNIS_SWING_ANIM_COMPLETE(Ped ped);
	BOOL GET_TENNIS_SWING_ANIM_CAN_BE_INTERRUPTED(Ped ped);
	BOOL GET_TENNIS_SWING_ANIM_SWUNG(Ped ped);
	void PLAY_TENNIS_DIVE_ANIM(Ped ped, int p1, float p2, float p3, float p4, BOOL p5);
	void SET_TENNIS_MOVE_NETWORK_SIGNAL_FLOAT(Ped ped, const char* p1, float p2);
	void RESET_DISPATCH_SPAWN_LOCATION();
	void SET_DISPATCH_SPAWN_LOCATION(float x, float y, float z);
	void RESET_DISPATCH_IDEAL_SPAWN_DISTANCE();
	void SET_DISPATCH_IDEAL_SPAWN_DISTANCE(float distance);
	void RESET_DISPATCH_TIME_BETWEEN_SPAWN_ATTEMPTS(Any p0);
	void SET_DISPATCH_TIME_BETWEEN_SPAWN_ATTEMPTS(Any p0, float p1);
	void SET_DISPATCH_TIME_BETWEEN_SPAWN_ATTEMPTS_MULTIPLIER(Any p0, float p1);
	int ADD_DISPATCH_SPAWN_ANGLED_BLOCKING_AREA(float x1, float y1, float z1, float x2, float y2, float z2, float width);
	int ADD_DISPATCH_SPAWN_SPHERE_BLOCKING_AREA(float x1, float y1, float x2, float y2);
	void REMOVE_DISPATCH_SPAWN_BLOCKING_AREA(int p0);
	void RESET_DISPATCH_SPAWN_BLOCKING_AREAS();
	void RESET_WANTED_RESPONSE_NUM_PEDS_TO_SPAWN();
	void SET_WANTED_RESPONSE_NUM_PEDS_TO_SPAWN(int p0, int p1);
	void ADD_TACTICAL_NAV_MESH_POINT(float x, float y, float z);
	void CLEAR_TACTICAL_NAV_MESH_POINTS();
	void SET_RIOT_MODE_ENABLED(BOOL toggle);
	void DISPLAY_ONSCREEN_KEYBOARD_WITH_LONGER_INITIAL_STRING(int p0, const char* windowTitle, Any* p2, const char* defaultText, const char* defaultConcat1, const char* defaultConcat2, const char* defaultConcat3, const char* defaultConcat4, const char* defaultConcat5, const char* defaultConcat6, const char* defaultConcat7, int maxInputLength);
	void DISPLAY_ONSCREEN_KEYBOARD(int p0, const char* windowTitle, const char* p2, const char* defaultText, const char* defaultConcat1, const char* defaultConcat2, const char* defaultConcat3, int maxInputLength);
	int UPDATE_ONSCREEN_KEYBOARD();
	const char* GET_ONSCREEN_KEYBOARD_RESULT();
	void CANCEL_ONSCREEN_KEYBOARD();
	void NEXT_ONSCREEN_KEYBOARD_RESULT_WILL_DISPLAY_USING_THESE_FONTS(int p0);
	void ACTION_MANAGER_ENABLE_ACTION(Hash hash, BOOL enable);
	int GET_REAL_WORLD_TIME();
	void SUPRESS_RANDOM_EVENT_THIS_FRAME(int eventType, BOOL suppress);
	void SET_EXPLOSIVE_AMMO_THIS_FRAME(Player player);
	void SET_FIRE_AMMO_THIS_FRAME(Player player);
	void SET_EXPLOSIVE_MELEE_THIS_FRAME(Player player);
	void SET_SUPER_JUMP_THIS_FRAME(Player player);
	void SET_BEAST_JUMP_THIS_FRAME(Player player);
	void SET_FORCED_JUMP_THIS_FRAME(Player player);
	BOOL HAS_GAME_INSTALLED_THIS_SESSION();
	void SET_TICKER_JOHNMARSTON_IS_DONE();
	BOOL ARE_PROFILE_SETTINGS_VALID();
	void PREVENT_ARREST_STATE_THIS_FRAME();
	void FORCE_GAME_STATE_PLAYING();
	void SCRIPT_RACE_INIT(int p0, int p1, Any p2, Any p3);
	void SCRIPT_RACE_SHUTDOWN();
	void SCRIPT_RACE_PLAYER_HIT_CHECKPOINT(Player player, Any p1, Any p2, Any p3);
	BOOL SCRIPT_RACE_GET_PLAYER_SPLIT_TIME(Player player, int* p1, int* p2);
	void START_END_USER_BENCHMARK();
	void STOP_END_USER_BENCHMARK();
	void RESET_END_USER_BENCHMARK();
	void SAVE_END_USER_BENCHMARK();
	BOOL UI_STARTED_END_USER_BENCHMARK();
	BOOL LANDING_SCREEN_STARTED_END_USER_BENCHMARK();
	BOOL IS_COMMANDLINE_END_USER_BENCHMARK();
	int GET_BENCHMARK_ITERATIONS();
	int GET_BENCHMARK_PASS();
	void RESTART_GAME();
	void QUIT_GAME();
	BOOL HAS_ASYNC_INSTALL_FINISHED();
	void CLEANUP_ASYNC_INSTALL();
	BOOL PLM_IS_IN_CONSTRAINED_MODE();
	int PLM_GET_CONSTRAINED_DURATION_MS();
	void SET_PLAYER_IS_IN_ANIMAL_FORM(BOOL toggle);
	BOOL GET_IS_PLAYER_IN_ANIMAL_FORM();
	void SET_PLAYER_IS_REPEATING_A_MISSION(BOOL toggle);
	void DISABLE_SCREEN_DIMMING_THIS_FRAME();
	float GET_CITY_DENSITY();
	void USE_ACTIVE_CAMERA_FOR_TIMESLICING_CENTRE();
	void SET_CONTENT_ID_INDEX(Hash contentId, int index);
	int GET_CONTENT_ID_INDEX(Hash contentId);
}

namespace MOBILE
{
	void CREATE_MOBILE_PHONE(int phoneType);
	void DESTROY_MOBILE_PHONE();
	void SET_MOBILE_PHONE_SCALE(float scale);
	void SET_MOBILE_PHONE_ROTATION(float rotX, float rotY, float rotZ, Any p3);
	void GET_MOBILE_PHONE_ROTATION(Vector3* rotation, Vehicle p1);
	void SET_MOBILE_PHONE_POSITION(float posX, float posY, float posZ);
	void GET_MOBILE_PHONE_POSITION(Vector3* position);
	void SCRIPT_IS_MOVING_MOBILE_PHONE_OFFSCREEN(BOOL toggle);
	BOOL CAN_PHONE_BE_SEEN_ON_SCREEN();
	void SET_MOBILE_PHONE_DOF_STATE(BOOL toggle);
	void CELL_SET_INPUT(int direction);
	void CELL_HORIZONTAL_MODE_TOGGLE(BOOL toggle);
	void CELL_CAM_ACTIVATE(BOOL p0, BOOL p1);
	void CELL_CAM_ACTIVATE_SELFIE_MODE(BOOL toggle);
	void CELL_CAM_ACTIVATE_SHALLOW_DOF_MODE(BOOL toggle);
	void CELL_CAM_SET_SELFIE_MODE_SIDE_OFFSET_SCALING(float p0);
	void CELL_CAM_SET_SELFIE_MODE_HORZ_PAN_OFFSET(float horizontalPan);
	void CELL_CAM_SET_SELFIE_MODE_VERT_PAN_OFFSET(float vertPan);
	void CELL_CAM_SET_SELFIE_MODE_ROLL_OFFSET(float roll);
	void CELL_CAM_SET_SELFIE_MODE_DISTANCE_SCALING(float distanceScaling);
	void CELL_CAM_SET_SELFIE_MODE_HEAD_YAW_OFFSET(float yaw);
	void CELL_CAM_SET_SELFIE_MODE_HEAD_ROLL_OFFSET(float roll);
	void CELL_CAM_SET_SELFIE_MODE_HEAD_PITCH_OFFSET(float pitch);
	BOOL CELL_CAM_IS_CHAR_VISIBLE_NO_FACE_CHECK(Entity entity);
	void GET_MOBILE_PHONE_RENDER_ID(int* renderId);
}

namespace MONEY
{
	void NETWORK_INITIALIZE_CASH(int wallet, int bank);
	void NETWORK_DELETE_CHARACTER(int characterSlot, BOOL p1, BOOL p2);
	void NETWORK_MANUAL_DELETE_CHARACTER(int characterSlot);
	BOOL NETWORK_GET_PLAYER_IS_HIGH_EARNER();
	void NETWORK_CLEAR_CHARACTER_WALLET(int characterSlot);
	void NETWORK_GIVE_PLAYER_JOBSHARE_CASH(int amount, Any* gamerHandle);
	void NETWORK_RECEIVE_PLAYER_JOBSHARE_CASH(int value, Any* gamerHandle);
	BOOL NETWORK_CAN_SHARE_JOB_CASH();
	void NETWORK_REFUND_CASH(int index, const char* context, const char* reason, BOOL p3);
	void NETWORK_DEDUCT_CASH(int amount, const char* p1, const char* p2, BOOL p3, BOOL p4, BOOL p5);
	BOOL NETWORK_MONEY_CAN_BET(int amount, BOOL p1, BOOL p2);
	BOOL NETWORK_CAN_BET(int amount);
	BOOL NETWORK_CASINO_CAN_BET(Hash hash);
	BOOL NETWORK_CASINO_CAN_BET_PVC();
	BOOL NETWORK_CASINO_CAN_BET_AMOUNT(Any p0);
	BOOL NETWORK_CASINO_CAN_BUY_CHIPS_PVC();
	BOOL NETWORK_CASINO_BUY_CHIPS(int p0, int p1);
	BOOL NETWORK_CASINO_SELL_CHIPS(int p0, int p1);
	void NETWORK_DEFER_CASH_TRANSACTIONS_UNTIL_SHOP_SAVE();
	BOOL CAN_PAY_AMOUNT_TO_BOSS(int p0, int p1, int amount, int* p3);
	void NETWORK_EARN_FROM_PICKUP(int amount);
	void NETWORK_EARN_FROM_CASHING_OUT(int amount);
	void NETWORK_EARN_FROM_GANGATTACK_PICKUP(int amount);
	void NETWORK_EARN_ASSASSINATE_TARGET_KILLED(int amount);
	void NETWORK_EARN_FROM_ROB_ARMORED_CARS(int amount);
	void NETWORK_EARN_FROM_CRATE_DROP(int amount);
	void NETWORK_EARN_FROM_BETTING(int amount, const char* p1);
	void NETWORK_EARN_FROM_JOB(int amount, const char* p1);
	void NETWORK_EARN_FROM_JOBX2(int amount, const char* p1);
	void NETWORK_EARN_FROM_PREMIUM_JOB(int amount, const char* p1);
	void NETWORK_EARN_FROM_BEND_JOB(int amount, const char* heistHash);
	void NETWORK_EARN_FROM_CHALLENGE_WIN(Any p0, Any* p1, BOOL p2);
	void NETWORK_EARN_FROM_BOUNTY(int amount, Any* gamerHandle, Any* p2, Any p3);
	void NETWORK_EARN_FROM_IMPORT_EXPORT(int amount, Hash modelHash);
	void NETWORK_EARN_FROM_HOLDUPS(int amount);
	void NETWORK_EARN_FROM_PROPERTY(int amount, Hash propertyName);
	void NETWORK_EARN_FROM_AI_TARGET_KILL(Any p0, Any p1);
	void NETWORK_EARN_FROM_NOT_BADSPORT(int amount);
	void NETWORK_EARN_FROM_VEHICLE(Any p0, Any p1, Any p2, Any p3, Any p4, Any p5, Any p6, Any p7);
	void NETWORK_EARN_FROM_PERSONAL_VEHICLE(Any p0, Any p1, Any p2, Any p3, Any p4, Any p5, Any p6, Any p7, Any p8);
	void NETWORK_EARN_FROM_DAILY_OBJECTIVES(int amount, const char* type, int characterSlot);
	void NETWORK_EARN_FROM_AMBIENT_JOB(int p0, const char* p1, Any* p2);
	void NETWORK_EARN_FROM_JOB_BONUS(Any p0, Any* p1, Any* p2);
	void NETWORK_EARN_FROM_CRIMINAL_MASTERMIND(Any p0, Any p1, Any p2);
	void NETWORK_EARN_HEIST_AWARD(Any p0, Any p1, Any p2);
	void NETWORK_EARN_FIRST_TIME_BONUS(Any p0, Any p1, Any p2);
	void NETWORK_EARN_GOON(Any p0, Any p1, Any p2);
	void NETWORK_EARN_BOSS(Any p0, Any p1, Any p2);
	void NETWORK_EARN_AGENCY(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_EARN_FROM_WAREHOUSE(int amount, int id);
	void NETWORK_EARN_FROM_CONTRABAND(int amount, Any p1);
	void NETWORK_EARN_FROM_DESTROYING_CONTRABAND(Any p0, Any p1, Any p2);
	void NETWORK_EARN_FROM_SMUGGLER_WORK(Any p0, Any p1, Any p2, Any p3, Any p4, Any p5);
	void NETWORK_EARN_FROM_HANGAR_TRADE(Any p0, Any p1);
	void NETWORK_EARN_PURCHASE_CLUB_HOUSE(Any p0, Any p1);
	void NETWORK_EARN_FROM_BUSINESS_PRODUCT(int amount, Any p1, Any p2, Any p3);
	void NETWORK_EARN_FROM_VEHICLE_EXPORT(int amount, Any p1, Any p2);
	void NETWORK_EARN_SMUGGLER_AGENCY(int amount, Any p1, Any p2, Any p3);
	void NETWORK_EARN_BOUNTY_HUNTER_REWARD(Any p0);
	void NETWORK_EARN_FROM_BUSINESS_BATTLE(Any p0);
	void NETWORK_EARN_FROM_CLUB_MANAGEMENT_PARTICIPATION(Any p0, int p1);
	void NETWORK_EARN_FROM_FMBB_PHONECALL_MISSION(Any p0);
	void NETWORK_EARN_FROM_BUSINESS_HUB_SELL(Any p0, Any p1, Any p2);
	void NETWORK_EARN_FROM_FMBB_BOSS_WORK(Any p0);
	void NETWORK_EARN_FMBB_WAGE_BONUS(Any p0);
	BOOL NETWORK_CAN_SPEND_MONEY(Any p0, BOOL p1, BOOL p2, BOOL p3, Any p4, Any p5);
	BOOL NETWORK_CAN_SPEND_MONEY2(Any p0, BOOL p1, BOOL p2, BOOL p3, Any* p4, Any p5, Any p6);
	void NETWORK_BUY_ITEM(int amount, Hash item, Any p2, Any p3, BOOL p4, const char* item_name, Any p6, Any p7, Any p8, BOOL p9);
	void NETWORK_SPENT_TAXI(int amount, BOOL p1, BOOL p2, Any p3, Any p4);
	void NETWORK_PAY_EMPLOYEE_WAGE(Any p0, BOOL p1, BOOL p2);
	void NETWORK_PAY_MATCH_ENTRY_FEE(int amount, const char* matchId, BOOL p2, BOOL p3);
	void NETWORK_SPENT_BETTING(int amount, int p1, const char* matchId, BOOL p3, BOOL p4);
	void NETWORK_SPENT_WAGER(Any p0, Any p1, int amount);
	void NETWORK_SPENT_IN_STRIPCLUB(Any p0, BOOL p1, Any p2, BOOL p3);
	void NETWORK_BUY_HEALTHCARE(int cost, BOOL p1, BOOL p2);
	void NETWORK_BUY_AIRSTRIKE(int cost, BOOL p1, BOOL p2, Any p3);
	void NETWORK_BUY_BACKUP_GANG(int p0, int p1, BOOL p2, BOOL p3, int npcProvider);
	void NETWORK_BUY_HELI_STRIKE(int cost, BOOL p1, BOOL p2, Any p3);
	void NETWORK_SPENT_AMMO_DROP(Any p0, BOOL p1, BOOL p2, Any p3);
	void NETWORK_BUY_BOUNTY(int amount, Player victim, BOOL p2, BOOL p3, Any p4);
	void NETWORK_BUY_PROPERTY(int cost, Hash propertyName, BOOL p2, BOOL p3);
	void NETWORK_BUY_SMOKES(int p0, BOOL p1, BOOL p2);
	void NETWORK_SPENT_HELI_PICKUP(Any p0, BOOL p1, BOOL p2, Any p3);
	void NETWORK_SPENT_BOAT_PICKUP(Any p0, BOOL p1, BOOL p2, Any p3);
	void NETWORK_SPENT_BULL_SHARK(Any p0, BOOL p1, BOOL p2, Any p3);
	void NETWORK_SPENT_CASH_DROP(int amount, BOOL p1, BOOL p2);
	void NETWORK_SPENT_HIRE_MUGGER(Any p0, BOOL p1, BOOL p2, Any p3);
	void NETWORK_SPENT_ROBBED_BY_MUGGER(int amount, BOOL p1, BOOL p2, Any p3);
	void NETWORK_SPENT_HIRE_MERCENARY(Any p0, BOOL p1, BOOL p2, Any p3);
	void NETWORK_SPENT_BUY_WANTEDLEVEL(Any p0, Any* p1, BOOL p2, BOOL p3, Any p4);
	void NETWORK_SPENT_BUY_OFFTHERADAR(Any p0, BOOL p1, BOOL p2, Any p3);
	void NETWORK_SPENT_BUY_REVEAL_PLAYERS(Any p0, BOOL p1, BOOL p2, Any p3);
	void NETWORK_SPENT_CARWASH(Any p0, Any p1, Any p2, BOOL p3, BOOL p4);
	void NETWORK_SPENT_CINEMA(Any p0, Any p1, BOOL p2, BOOL p3);
	void NETWORK_SPENT_TELESCOPE(Any p0, BOOL p1, BOOL p2);
	void NETWORK_SPENT_HOLDUPS(Any p0, BOOL p1, BOOL p2);
	void NETWORK_SPENT_BUY_PASSIVE_MODE(Any p0, BOOL p1, BOOL p2, Any p3);
	void NETWORK_SPENT_BANK_INTEREST(int p0, BOOL p1, BOOL p2);
	void NETWORK_SPENT_PROSTITUTES(Any p0, BOOL p1, BOOL p2);
	void NETWORK_SPENT_ARREST_BAIL(Any p0, BOOL p1, BOOL p2);
	void NETWORK_SPENT_PAY_VEHICLE_INSURANCE_PREMIUM(int amount, Hash vehicleModel, Any* gamerHandle, BOOL notBankrupt, BOOL hasTheMoney);
	void NETWORK_SPENT_CALL_PLAYER(Any p0, Any* p1, BOOL p2, BOOL p3);
	void NETWORK_SPENT_BOUNTY(Any p0, BOOL p1, BOOL p2);
	void NETWORK_SPENT_FROM_ROCKSTAR(int p0, BOOL p1, BOOL p2);
	int NETWORK_SPEND_EARNED_FROM_BANK_AND_WALLETS(int amount);
	const char* PROCESS_CASH_GIFT(int* p0, int* p1, const char* p2);
	void NETWORK_SPENT_MOVE_SUBMARINE(Any p0, Any p1, Any p2);
	void NETWORK_SPENT_PLAYER_HEALTHCARE(int p0, int p1, BOOL p2, BOOL p3);
	void NETWORK_SPENT_NO_COPS(Any p0, BOOL p1, BOOL p2, Any p3);
	void NETWORK_SPENT_CARGO_SOURCING(Any p0, Any p1, Any p2, Any p3, Any p4, Any p5);
	void NETWORK_SPENT_REQUEST_JOB(Any p0, BOOL p1, BOOL p2, Any p3);
	void NETWORK_SPENT_REQUEST_HEIST(Any p0, BOOL p1, BOOL p2, Any p3);
	void NETWORK_BUY_FAIRGROUND_RIDE(int amount, Any p1, BOOL p2, BOOL p3, Any p4);
	BOOL NETWORK_ECONOMY_HAS_FIXED_CRAZY_NUMBERS();
	void NETWORK_SPENT_JOB_SKIP(int amount, const char* matchId, BOOL p2, BOOL p3);
	BOOL NETWORK_SPENT_BOSS_GOON(int amount, BOOL p1, BOOL p2);
	void NETWORK_SPEND_GOON(int p0, int p1, int amount);
	void NETWORK_SPEND_BOSS(Any p0, Any p1, Any p2);
	void NETWORK_SPENT_MOVE_YACHT(int amount, BOOL p1, BOOL p2);
	void NETWORK_SPENT_RENAME_ORGANIZATION(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_BUY_CONTRABAND_MISSION(int p0, int p1, Hash p2, BOOL p3, BOOL p4);
	void NETWORK_SPENT_PA_SERVICE_HELI(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPENT_PA_SERVICE_VEHICLE(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPENT_PA_SERVICE_SNACK(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPENT_PA_SERVICE_DANCER(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPENT_PA_SERVICE_IMPOUND(Any p0, Any p1, Any p2);
	void NETWORK_SPENT_PA_HELI_PICKUP(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPENT_PURCHASE_OFFICE_PROPERTY(Any p0, Any p1, Any p2, Any p3, Any p4);
	void NETWORK_SPENT_UPGRADE_OFFICE_PROPERTY(Any p0, Any p1, Any p2, Any p3, Any p4);
	void NETWORK_SPENT_PURCHASE_WAREHOUSE_PROPERTY(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPENT_UPGRADE_WAREHOUSE_PROPERTY(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPENT_PURCHASE_IMPEXP_WAREHOUSE_PROPERTY(int amount, Any* data, BOOL p2, BOOL p3);
	void NETWORK_SPENT_UPGRADE_IMPEXP_WAREHOUSE_PROPERTY(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPENT_TRADE_IMPEXP_WAREHOUSE_PROPERTY(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPENT_ORDER_WAREHOUSE_VEHICLE(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPENT_ORDER_BODYGUARD_VEHICLE(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPENT_JUKEBOX(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPENT_PURCHASE_CLUB_HOUSE(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPENT_UPGRADE_CLUB_HOUSE(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPENT_PURCHASE_BUSINESS_PROPERTY(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPENT_UPGRADE_BUSINESS_PROPERTY(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPENT_TRADE_BUSINESS_PROPERTY(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPENT_MC_ABILITY(Any p0, Any p1, Any p2, Any p3, Any p4);
	void NETWORK_SPENT_PAY_BUSINESS_SUPPLIES(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPENT_CHANGE_APPEARANCE(Any p0, Any p1, Any p2);
	void NETWORK_SPENT_VEHICLE_EXPORT_MODS(Any p0, Any p1, Any p2, Any p3, Any p4, Any p5, Any p6, Any p7, Any p8, Any p9);
	void NETWORK_SPENT_PURCHASE_OFFICE_GARAGE(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPENT_UPGRADE_OFFICE_GARAGE(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPENT_IMPORT_EXPORT_REPAIR(Any p0, Any p1, Any p2);
	void NETWORK_SPENT_PURCHASE_HANGAR(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPENT_UPGRADE_HANGAR(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPENT_HANGAR_UTILITY_CHARGES(int amount, BOOL p1, BOOL p2);
	void NETWORK_SPENT_HANGAR_STAFF_CHARGES(int amount, BOOL p1, BOOL p2);
	void NETWORK_SPENT_BUY_TRUCK(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPENT_UPGRADE_TRUCK(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPENT_BUY_BUNKER(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPENT_UPRADE_BUNKER(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_EARN_FROM_SELL_BUNKER(int amount, Hash bunkerHash);
	void NETWORK_SPENT_BALLISTIC_EQUIPMENT(int amount, BOOL p1, BOOL p2);
	void NETWORK_EARN_RDR_BONUS(int amount, Any p1);
	void NETWORK_EARN_WAGE_PAYMENT(int amount, Any p1);
	void NETWORK_EARN_WAGE_PAYMENT_BONUS(int amount);
	void NETWORK_SPENT_BUY_BASE(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPENT_UPGRADE_BASE(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPENT_BUY_TILTROTOR(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPENT_UPGRADE_TILTROTOR(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPENT_EMPLOY_ASSASSINS(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPEND_GANGOPS_CANNON(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPEND_GANGOPS_SKIP_MISSION(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPEND_CASINO_HEIST_SKIP_MISSION(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_EARN_SELL_BASE(int amount, Hash baseNameHash);
	void NETWORK_EARN_TARGET_REFUND(int amount, int p1);
	void NETWORK_EARN_GANGOPS_WAGES(int amount, int p1);
	void NETWORK_EARN_GANGOPS_WAGES_BONUS(int amount, int p1);
	void NETWORK_EARN_DAR_CHALLENGE(int amount, Any p1);
	void NETWORK_EARN_DOOMSDAY_FINALE_BONUS(int amount, Hash vehicleHash);
	void NETWORK_EARN_GANGOPS_AWARD(int amount, const char* p1, Any p2);
	void NETWORK_EARN_GANGOPS_ELITE(int amount, const char* p1, int actIndex);
	void NETWORK_SERVICE_EARN_GANGOPS_RIVAL_DELIVERY(int earnedMoney);
	void NETWORK_SPEND_GANGOPS_START_STRAND(int type, int amount, BOOL p2, BOOL p3);
	void NETWORK_SPEND_GANGOPS_TRIP_SKIP(int amount, BOOL p1, BOOL p2);
	void NETWORK_EARN_GANGOPS_PREP_PARTICIPATION(int amount);
	void NETWORK_EARN_GANGOPS_SETUP(int amount, const char* p1);
	void NETWORK_EARN_GANGOPS_FINALE(int amount, const char* p1);
	void NETWORK_SPEND_GANGOPS_REPAIR_COST(Any p0, Any p1, Any p2);
	void NETWORK_EARN_NIGHTCLUB(Any p0);
	void NETWORK_EARN_NIGHTCLUB_DANCING(Any p0);
	void NETWORK_EARN_BB_EVENT_BONUS(int amount);
	void NETWORK_SPENT_PURCHASE_HACKER_TRUCK(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPENT_UPGRADE_HACKER_TRUCK(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_EARN_HACKER_TRUCK(Any p0, int amount, Any p2, Any p3);
	void NETWORK_SPENT_PURCHASE_NIGHTCLUB_AND_WAREHOUSE(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPENT_UPGRADE_NIGHTCLUB_AND_WAREHOUSE(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_EARN_NIGHTCLUB_AND_WAREHOUSE(Any p0, Any p1, Any p2, Any p3, Any p4, Any p5, Any p6);
	void NETWORK_SPEND_NIGHTCLUB_AND_WAREHOUSE(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPENT_RDR_HATCHET_BONUS(int amount, BOOL p1, BOOL p2);
	void NETWORK_SPENT_NIGHTCLUB_ENTRY_FEE(Player player, int amount, Any p1, BOOL p2, BOOL p3);
	void NETWORK_SPEND_NIGHTCLUB_BAR_DRINK(int amount, Any p1, BOOL p2, BOOL p3);
	void NETWORK_SPEND_BOUNTY_HUNTER_MISSION(int amount, BOOL p1, BOOL p2);
	void NETWORK_SPENT_REHIRE_DJ(int amount, Any p1, BOOL p2, BOOL p3);
	void NETWORK_SPENT_ARENA_JOIN_SPECTATOR(int amount, Any p1, BOOL p2, BOOL p3);
	void NETWORK_EARN_ARENA_SKILL_LEVEL_PROGRESSION(int amount, Any p1);
	void NETWORK_EARN_ARENA_CAREER_PROGRESSION(int amount, Any p1);
	void NETWORK_SPEND_MAKE_IT_RAIN(int amount, BOOL p1, BOOL p2);
	void NETWORK_SPEND_BUY_ARENA(int amount, BOOL p1, BOOL p2, const char* p3);
	void NETWORK_SPEND_UPGRADE_ARENA(int amount, BOOL p1, BOOL p2, const char* p3);
	void NETWORK_SPEND_ARENA_SPECTATOR_BOX(int amount, int type, BOOL p2, BOOL p3);
	void NETWORK_SPEND_SPIN_THE_WHEEL_PAYMENT(int amount, Any p1, BOOL p2);
	void NETWORK_EARN_SPIN_THE_WHEEL_CASH(int amount);
	void NETWORK_SPEND_ARENA_PREMIUM(int amount, BOOL p1, BOOL p2);
	void NETWORK_EARN_ARENA_WAR(int amount, Any p1, Any p2, Any p3);
	void NETWORK_EARN_ARENA_WAR_ASSASSINATE_TARGET(int amount);
	void NETWORK_EARN_ARENA_WAR_EVENT_CARGO(int amount);
	void NETWORK_EARN_RC_TIME_TRIAL(int amount);
	void NETWORK_EARN_DAILY_OBJECTIVE_EVENT(int amount);
	void NETWORK_SPEND_CASINO_MEMBERSHIP(int amount, BOOL p1, BOOL p2, int p3);
	void NETWORK_SPEND_BUY_CASINO(int amount, BOOL p1, BOOL p2, Any* data);
	void NETWORK_SPEND_UPGRADE_CASINO(int amount, BOOL p1, BOOL p2, Any* data);
	void NETWORK_SPEND_CASINO_GENERIC(int amount, Any p1, Any p2, Any p3, Any p4);
	void NETWORK_EARN_CASINO_TIME_TRIAL_WIN(int amount);
	void NETWORK_EARN_COLLECTABLES_ACTION_FIGURES(int amount);
	void NETWORK_EARN_CASINO_COLLECTABLE_COMPLETED_COLLECTION(int amount);
	void NETWORK_EARN_SELL_PRIZE_VEHICLE(int amount, Any p1, Any p2);
	void NETWORK_EARN_CASINO_MISSION_REWARD(int amount);
	void NETWORK_EARN_CASINO_STORY_MISSION_REWARD(int amount);
	void NETWORK_EARN_CASINO_MISSION_PARTICIPATION(int amount);
	void NETWORK_EARN_CASINO_AWARD(int amount, Hash hash);
	void NETWORK_SPEND_BUY_ARCADE(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPEND_UPGRADE_ARCADE(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPEND_CASINO_HEIST(Any p0, Any p1, Any p2, Any p3, Any p4, Any p5, Any p6, Any p7, Any p8, Any p9, Any p10);
	void NETWORK_SPEND_ARCADE_MGMT(Any p0, Any p1, Any p2, Any p3, Any p4);
	void NETWORK_SPEND_PLAY_ARCADE(Any p0, Any p1, Any p2, Any p3, Any p4);
	void NETWORK_SPEND_ARCADE(Any p0, Any p1, Any p2, Any p3, Any p4);
	void NETWORK_EARN_CASINO_HEIST(Any p0, Any p1, Any p2, Any p3, Any p4, Any p5, Any p6);
	void NETWORK_EARN_UPGRADE_ARCADE(Any p0, Any p1, Any p2);
	void NETWORK_EARN_ARCADE(Any p0, Any p1, Any p2, Any p3, Any p4);
	void NETWORK_EARN_COLLECTABLES(Any p0, Any p1, Any p2);
	void NETWORK_EARN_CHALLENGE(int amount, Any p1, Any p2);
	void NETWORK_EARN_CASINO_HEIST_AWARDS(Any p0, Any p1, Any p2, Any p3, Any p4);
	void NETWORK_EARN_COLLECTABLE_ITEM(int amount, Any p1);
	void NETWORK_EARN_COLLECTABLE_COMPLETED_COLLECTION(int amount, Any p1);
	void NETWORK_EARN_YATCH_MISSION(int amount, Any p1);
	void NETWORK_EARN_DISPATCH_CALL(int amount, Any p1);
	void NETWORK_SPEND_BEACH_PARTY(Any p0);
	void NETWORK_SPEND_SUBMARINE(Any p0, Any p1, Any p2, Any p3, Any p4, Any p5);
	void NETWORK_SPEND_CASINO_CLUB(int amount1, Any p1, BOOL p2, Any p3, int p4, int p5, int p6, int amount2, Any p8);
	void NETWORK_SPEND_BUY_SUB(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPEND_UPGRADE_SUB(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPEND_ISLAND_HEIST(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_EARN_ISLAND_HEIST(int amount1, Any p1, Any p2, Any p3, int amount2, int p5);
	void NETWORK_EARN_BEACH_PARTY_LOST_FOUND(Any p0, Any p1, Any p2);
	void NETWORK_EARN_FROM_ISLAND_HEIST_DJ_MISSION(Any p0, Any p1);
	void NETWORK_SPEND_CAR_CLUB_MEMBERSHIP(int amount1, Any p1, Any p2, int amount2, Any p4);
	void NETWORK_SPEND_CAR_CLUB_BAR(Any p0, BOOL p1, BOOL p2, Any p3);
	void NETWORK_SPEND_AUTOSHOP_MODIFY(Any p0, Any p1, Any p2, Any p3, Any p4);
	void NETWORK_SPEND_CAR_CLUB_TAKEOVER(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPEND_BUY_AUTOSHOP(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPEND_UPGRADE_AUTOSHOP(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_EARN_AUTOSHOP_BUSINESS(Any p0, Any p1, Any p2);
	void NETWORK_EARN_AUTOSHOP_INCOME(Any p0, int p1);
	void NETWORK_EARN_CARCLUB_MEMBERSHIP(Any p0);
	void NETWORK_EARN_DAILY_VEHICLE(Any p0, Any p1);
	void NETWORK_EARN_DAILY_VEHICLE_BONUS(Any p0);
	void NETWORK_EARN_TUNER_AWARD(Any p0, Any p1, Any p2);
	void NETWORK_EARN_TUNER_ROBBERY(Any p0, Any p1, Any p2, Any p3, Any p4);
	void NETWORK_EARN_UPGRADE_AUTOSHOP(Any p0, Any p1);
	void NETWORK_SPEND_INTERACTION_MENU_ABILITY(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPEND_SET_COMMON_FIELDS(Any p0, Any p1, Any p2, BOOL p3);
	void NETWORK_SPEND_SET_DISCOUNT(BOOL p0);
	void NETWORK_SPEND_BUY_AGENCY(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPEND_UPGRADE_AGENCY(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPEND_AGENCY(Any p0, Any p1, Any p2, Any p3, Any p4);
	void NETWORK_SPEND_HIDDEN(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPEND_SOURCE_BIKE(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPEND_COMP_SUV(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPEND_SUV_FST_TRVL(int p0, BOOL p1, BOOL p2, Any p3);
	void NETWORK_SPEND_SUPPLY(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPEND_BIKE_SHOP(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPEND_VEHICLE_REQUESTED(Any p0, Any p1, Any p2, Any p3, Any p4);
	void NETWORK_SPEND_GUNRUNNING(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_EARN_AGENCY_SAFE(Any p0);
	void NETWORK_EARN_AWARD_CONTRACT(Any p0, Any p1);
	void NETWORK_EARN_AGENCY_CONTRACT(Any p0, Any p1);
	void NETWORK_EARN_AWARD_PHONE(Any p0, Any p1);
	void NETWORK_EARN_AGENCY_PHONE(Any p0, Any p1, Any p2);
	void NETWORK_EARN_AWARD_FIXER_MISSION(Any p0, Any p1);
	void NETWORK_EARN_FIXER_PREP(Any p0, Any p1);
	void NETWORK_EARN_FIXER_FINALE(Any p0, Any p1);
	void NETWORK_EARN_FIXER_AGENCY_SHORT_TRIP(Any p0, Any p1);
	void NETWORK_EARN_AWARD_SHORT_TRIP(Any p0, Any p1);
	void NETWORK_EARN_FIXER_RIVAL_DELIVERY(Any p0, Any p1);
	void NETWORK_EARN_UPGRADE_AGENCY(Any p0, Any p1);
	void NETWORK_SPEND_APARTMENT_UTILITIES(int amount, BOOL p1, BOOL p2, Any* data);
	void NETWORK_SPEND_BUSINESS_PROPERTY_FEES(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_EARN_SIGHTSEEING_REWARD(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_EARN_BIKER_SHOP(Any p0, Any p1);
	void NETWORK_EARN_BIKER(Any p0);
	void NETWORK_YOHAN_SOURCE_GOODS(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPEND_BUY_MFGARAGE_(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPEND_UPGRADE_MFGARAGE_(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPEND_BUY_SUPPLIES_(int p0, BOOL p1, BOOL p2, int p3);
	void NETWORK_SPEND_BUY_ACID_LAB_(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPEND_UPGRADE_ACID_LAB_EQUIPMENT_(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPEND_UPGRADE_ACID_LAB_ARMOR_(int p0, BOOL p1, BOOL p2, int p3);
	void NETWORK_SPEND_UPGRADE_ACID_LAB_SCOOP_(int p0, BOOL p1, BOOL p2, int p3);
	void NETWORK_SPEND_UPGRADE_ACID_LAB_MINES_(int p0, BOOL p1, BOOL p2, int p3);
	void NETWORK_SPEND_RENAME_ACID_LAB_(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_SPEND_RENAME_ACID_PRODUCT_(Any p0, Any p1, Any p2, Any p3);
	void NETWORK_EARN_AWARD_JUGGALO_MISSION_(Any p0, Any p1);
	void NETWORK_EARN_AWARD_ACID_LAB_(Any p0, Any p1);
	void NETWORK_EARN_AWARD_DAILY_STASH_(Any p0, Any p1);
	void NETWORK_EARN_AWARD_DEAD_DROP_(Any p0, Any p1);
	void NETWORK_EARN_AWARD_RANDOM_EVENT_(Any p0, Any p1);
	void NETWORK_EARN_AWARD_TAXI_(Any p0, Any p1);
	void NETWORK_EARN_STREET_DEALER_(Any p0, Any p1);
	void NETWORK_EARN_SELL_ACID_(Any p0, Any p1);
	void NETWORK_EARN_SETUP_PARTICIPATION_ACID_LAB_(Any p0, Any p1);
	void NETWORK_EARN_SOURCE_PARTICIPATION_ACID_LAB_(Any p0, Any p1);
	void NETWORK_EARN_SELL_PARTICIPATION_ACID_LAB_(Any p0, Any p1);
	void NETWORK_EARN_JUGGALO_STORY_MISSION_(Any p0, Any p1);
	void NETWORK_EARN_JUGGALO_STORY_MISSION_PARTICIPATION_(Any p0, Any p1);
	void NETWORK_EARN_FOOLIGAN_JOB_(Any p0, Any p1);
	void NETWORK_EARN_FOOLIGAN_JOB_PARTICIPATION_(Any p0, Any p1);
	void NETWORK_EARN_TAXI_JOB_(Any p0, Any p1);
	void NETWORK_EARN_DAILY_STASH_HOUSE_COMPLETED_(Any p0, Any p1);
	void NETWORK_EARN_DAILY_STASH_HOUSE_PARTICIPATION_(Any p0, Any p1);
	void NETWORK_EARN_AVENGER_(int amount, int p1);
	void NETWORK_EARN_SMUGGLER_OPS_(Any p0, Any p1, Any p2);
	void NETWORK_EARN_BONUS_OBJECTIVE_(int amount, Any p1, Any p2);
	void NETWORK_EARN_PROGRESS_HUB_(Any p0, Any p1);
	void NETWORK_SPENT_AIR_FREIGHT_(int hangarCargoSourcingPrice, BOOL fromBank, BOOL fromBankAndWallet, int cost, int warehouseId, int warehouseSlot);
	void NETWORK_SPENT_SKIP_CARGO_SOURCE_SETUP_(int amount, BOOL fromBank, BOOL fromBankAndWallet, int cost);
	void NETWORK_SPENT_STEALTH_MODULE_(int amount, BOOL fromBank, BOOL fromBankAndWallet, Hash p3);
	void NETWORK_SPENT_MISSILE_JAMMER_(int amount, BOOL fromBank, BOOL fromBankAndWallet, Hash p3);
	int NETWORK_GET_VC_BANK_BALANCE();
	int NETWORK_GET_VC_WALLET_BALANCE(int characterSlot);
	int NETWORK_GET_VC_BALANCE();
	int NETWORK_GET_EVC_BALANCE();
	int NETWORK_GET_PVC_BALANCE();
	const char* NETWORK_GET_STRING_WALLET_BALANCE(int characterSlot);
	const char* NETWORK_GET_STRING_BANK_BALANCE();
	const char* NETWORK_GET_STRING_BANK_WALLET_BALANCE(int character);
	BOOL NETWORK_GET_CAN_SPEND_FROM_WALLET(int amount, int characterSlot);
	BOOL NETWORK_GET_CAN_SPEND_FROM_BANK(int amount);
	BOOL NETWORK_GET_CAN_SPEND_FROM_BANK_AND_WALLET(int amount, int characterSlot);
	int NETWORK_GET_PVC_TRANSFER_BALANCE();
	BOOL NETWORK_GET_CAN_TRANSFER_CASH(int amount);
	BOOL NETWORK_CAN_RECEIVE_PLAYER_CASH(Any p0, Any p1, Any p2, Any p3);
	int NETWORK_GET_REMAINING_TRANSFER_BALANCE();
	int WITHDRAW_VC(int amount);
	BOOL DEPOSIT_VC(int amount);
	BOOL HAS_VC_WITHDRAWAL_COMPLETED(Any p0);
	BOOL WAS_VC_WITHDRAWAL_SUCCESSFUL(Any p0);
}

namespace NETSHOPPING
{
	BOOL NET_GAMESERVER_USE_SERVER_TRANSACTIONS();
	BOOL NET_GAMESERVER_CATALOG_ITEM_IS_VALID(const char* name);
	BOOL NET_GAMESERVER_CATALOG_ITEM_KEY_IS_VALID(Hash hash);
	int NET_GAMESERVER_GET_PRICE(Hash itemHash, Hash categoryHash, BOOL p2);
	BOOL NET_GAMESERVER_CATALOG_IS_VALID();
	BOOL NET_GAMESERVER_IS_CATALOG_CURRENT();
	Hash NET_GAMESERVER_GET_CATALOG_CLOUD_CRC();
	BOOL NET_GAMESERVER_REFRESH_SERVER_CATALOG();
	BOOL NET_GAMESERVER_RETRIEVE_CATALOG_REFRESH_STATUS(int* state);
	BOOL NET_GAMESERVER_INIT_SESSION();
	BOOL NET_GAMESERVER_RETRIEVE_INIT_SESSION_STATUS(int* p0);
	BOOL NET_GAMESERVER_START_SESSION(int charSlot);
	BOOL NET_GAMESERVER_START_SESSION_PENDING();
	BOOL NET_GAMESERVER_RETRIEVE_START_SESSION_STATUS(int* p0);
	BOOL NET_GAMESERVER_RETRIEVE_SESSION_ERROR_CODE(int* p0);
	BOOL NET_GAMESERVER_IS_SESSION_VALID(int charSlot);
	BOOL NET_GAMESERVER_CLEAR_SESSION(int p0);
	BOOL NET_GAMESERVER_SESSION_APPLY_RECEIVED_DATA(int charSlot);
	BOOL NET_GAMESERVER_IS_SESSION_REFRESH_PENDING();
	BOOL NET_GAMESERVER_START_SESSION_RESTART(BOOL inventory, BOOL playerbalance);
	BOOL NET_GAMESERVER_TRANSACTION_IN_PROGRESS();
	BOOL NET_GAMESERVER_GET_SESSION_STATE_AND_STATUS(int* p0, BOOL* p1);
	BOOL NET_GAMESERVER_BASKET_START(int* transactionId, Hash categoryHash, Hash actionHash, int flags);
	BOOL NET_GAMESERVER_BASKET_END();
	BOOL NET_GAMESERVER_BASKET_IS_ACTIVE();
	BOOL NET_GAMESERVER_BASKET_ADD_ITEM(Any* itemData, int quantity);
	BOOL NET_GAMESERVER_BASKET_IS_FULL();
	BOOL NET_GAMESERVER_BASKET_APPLY_SERVER_DATA(Any p0, Any* p1);
	BOOL NET_GAMESERVER_CHECKOUT_START(int transactionId);
	BOOL NET_GAMESERVER_BEGIN_SERVICE(int* transactionId, Hash categoryHash, Hash itemHash, Hash actionTypeHash, int value, int flags);
	BOOL NET_GAMESERVER_END_SERVICE(int transactionId);
	BOOL NET_GAMESERVER_DELETE_CHARACTER(int slot, BOOL transfer, Hash reason);
	int NET_GAMESERVER_DELETE_CHARACTER_GET_STATUS();
	BOOL NET_GAMESERVER_DELETE_SET_TELEMETRY_NONCE_SEED();
	BOOL NET_GAMESERVER_TRANSFER_BANK_TO_WALLET(int charSlot, int amount);
	BOOL NET_GAMESERVER_TRANSFER_WALLET_TO_BANK(int charSlot, int amount);
	int NET_GAMESERVER_TRANSFER_BANK_TO_WALLET_GET_STATUS();
	int NET_GAMESERVER_TRANSFER_WALLET_TO_BANK_GET_STATUS();
	BOOL NET_GAMESERVER_TRANSFER_CASH_SET_TELEMETRY_NONCE_SEED();
	BOOL NET_GAMESERVER_SET_TELEMETRY_NONCE_SEED(int p0);
}

namespace NETWORK
{
	const char* GET_ONLINE_VERSION();
	BOOL NETWORK_IS_SIGNED_IN();
	BOOL NETWORK_IS_SIGNED_ONLINE();
	BOOL NETWORK_IS_NP_AVAILABLE();
	BOOL NETWORK_IS_NP_PENDING();
	int NETWORK_GET_NP_UNAVAILABLE_REASON();
	BOOL NETWORK_IS_CONNETED_TO_NP_PRESENCE();
	BOOL NETWORK_IS_LOGGED_IN_TO_PSN();
	BOOL NETWORK_HAS_VALID_ROS_CREDENTIALS();
	BOOL NETWORK_IS_REFRESHING_ROS_CREDENTIALS();
	BOOL NETWORK_IS_CLOUD_AVAILABLE();
	BOOL NETWORK_HAS_SOCIAL_CLUB_ACCOUNT();
	BOOL NETWORK_ARE_SOCIAL_CLUB_POLICIES_CURRENT();
	BOOL NETWORK_IS_HOST();
	Player NETWORK_GET_HOST_PLAYER_INDEX();
	BOOL NETWORK_WAS_GAME_SUSPENDED();
	BOOL NETWORK_HAVE_ONLINE_PRIVILEGES();
	BOOL NETWORK_HAS_AGE_RESTRICTIONS();
	BOOL NETWORK_HAVE_USER_CONTENT_PRIVILEGES(int p0);
	BOOL NETWORK_HAVE_COMMUNICATION_PRIVILEGES(int p0, Player player);
	BOOL NETWORK_CHECK_ONLINE_PRIVILEGES(Any p0, BOOL p1);
	BOOL NETWORK_CHECK_USER_CONTENT_PRIVILEGES(int p0, int p1, BOOL p2);
	BOOL NETWORK_CHECK_COMMUNICATION_PRIVILEGES(int p0, int p1, BOOL p2);
	BOOL NETWORK_CHECK_TEXT_COMMUNICATION_PRIVILEGES(Any p0, Any p1, Any p2);
	BOOL NETWORK_IS_USING_ONLINE_PROMOTION();
	BOOL NETWORK_SHOULD_SHOW_PROMOTION_ALERT_SCREEN();
	BOOL NETWORK_HAS_SOCIAL_NETWORKING_SHARING_PRIV();
	int NETWORK_GET_AGE_GROUP();
	BOOL NETWORK_CHECK_PRIVILEGES(Any p0, Any p1, Any p2);
	BOOL NETWORK_IS_PRIVILEGE_CHECK_IN_PROGRESS();
	void NETWORK_SET_PRIVILEGE_CHECK_RESULT_NOT_NEEDED();
	BOOL NETWORK_RESOLVE_PRIVILEGE_USER_CONTENT();
	BOOL NETWORK_HAVE_PLATFORM_SUBSCRIPTION();
	BOOL NETWORK_IS_PLATFORM_SUBSCRIPTION_CHECK_PENDING();
	void NETWORK_SHOW_ACCOUNT_UPGRADE_UI();
	BOOL NETWORK_IS_SHOWING_SYSTEM_UI_OR_RECENTLY_REQUESTED_UPSELL();
	BOOL NETWORK_NEED_TO_START_NEW_GAME_BUT_BLOCKED();
	BOOL NETWORK_CAN_BAIL();
	void NETWORK_BAIL(int p0, int p1, int p2);
	void NETWORK_ON_RETURN_TO_SINGLE_PLAYER();
	BOOL NETWORK_TRANSITION_START(int p0, Any p1, Any p2, Any p3);
	BOOL NETWORK_TRANSITION_ADD_STAGE(Hash hash, int p1, int p2, int state, int p4);
	BOOL NETWORK_TRANSITION_FINISH(Any p0, Any p1, Any p2);
	BOOL NETWORK_CAN_ACCESS_MULTIPLAYER(int* loadingState);
	BOOL NETWORK_IS_MULTIPLAYER_DISABLED();
	BOOL NETWORK_CAN_ENTER_MULTIPLAYER();
	BOOL NETWORK_SESSION_DO_FREEROAM_QUICKMATCH(Any p0, Any p1, Any p2, int maxPlayers);
	BOOL NETWORK_SESSION_DO_FRIEND_MATCHMAKING(int p0, int p1, int maxPlayers);
	BOOL NETWORK_SESSION_DO_CREW_MATCHMAKING(int crewId, int p1, int p2, int maxPlayers);
	BOOL NETWORK_SESSION_DO_ACTIVITY_QUICKMATCH(Any p0, Any p1, Any p2, Any p3, Any p4);
	BOOL NETWORK_SESSION_HOST(int p0, int maxPlayers, BOOL p2);
	BOOL NETWORK_SESSION_HOST_CLOSED(int p0, int maxPlayers);
	BOOL NETWORK_SESSION_HOST_FRIENDS_ONLY(int p0, int maxPlayers);
	BOOL NETWORK_SESSION_IS_CLOSED_FRIENDS();
	BOOL NETWORK_SESSION_IS_CLOSED_CREW();
	BOOL NETWORK_SESSION_IS_SOLO();
	BOOL NETWORK_SESSION_IS_PRIVATE();
	BOOL NETWORK_SESSION_END(BOOL p0, BOOL p1);
	BOOL NETWORK_SESSION_LEAVE(Any p0);
	void NETWORK_SESSION_KICK_PLAYER(Player player);
	BOOL NETWORK_SESSION_GET_KICK_VOTE(Player player);
	BOOL NETWORK_SESSION_RESERVE_SLOTS_TRANSITION(Any p0, Any p1, Any p2);
	BOOL NETWORK_JOIN_PREVIOUSLY_FAILED_SESSION();
	BOOL NETWORK_JOIN_PREVIOUSLY_FAILED_TRANSITION();
	void NETWORK_SESSION_SET_MATCHMAKING_GROUP(int matchmakingGroup);
	void NETWORK_SESSION_SET_MATCHMAKING_GROUP_MAX(int playerType, int playerCount);
	int NETWORK_SESSION_GET_MATCHMAKING_GROUP_FREE(int p0);
	void NETWORK_SESSION_ADD_ACTIVE_MATCHMAKING_GROUP(int groupId);
	void NETWORK_SESSION_SET_UNIQUE_CREW_LIMIT(Any p0);
	void NETWORK_SESSION_SET_UNIQUE_CREW_LIMIT_TRANSITION(Any p0);
	void NETWORK_SESSION_SET_UNIQUE_CREW_ONLY_CREWS_TRANSITION(BOOL p0);
	void NETWORK_SESSION_SET_CREW_LIMIT_MAX_MEMBERS_TRANSITION(Any p0);
	void NETWORK_SESSION_SET_MATCHMAKING_PROPERTY_ID(BOOL p0);
	void NETWORK_SESSION_SET_MATCHMAKING_MENTAL_STATE(int p0);
	void NETWORK_SESSION_SET_NUM_BOSSES(int num);
	void NETWORK_SESSION_SET_SCRIPT_VALIDATE_JOIN();
	void NETWORK_SESSION_VALIDATE_JOIN(BOOL p0);
	void NETWORK_ADD_FOLLOWERS(int* p0, int p1);
	void NETWORK_CLEAR_FOLLOWERS();
	void NETWORK_GET_GLOBAL_MULTIPLAYER_CLOCK(int* hours, int* minutes, int* seconds);
	void NETWORK_SESSION_SET_GAMEMODE(Any p0);
	int NETWORK_SESSION_GET_HOST_AIM_PREFERENCE();
	BOOL NETWORK_FIND_GAMERS_IN_CREW(int crewId);
	BOOL NETWORK_FIND_MATCHED_GAMERS(int attribute, float fallbackLimit, float lowerLimit, float upperLimit);
	BOOL NETWORK_IS_FINDING_GAMERS();
	BOOL NETWORK_DID_FIND_GAMERS_SUCCEED();
	int NETWORK_GET_NUM_FOUND_GAMERS();
	BOOL NETWORK_GET_FOUND_GAMER(Any* p0, Any p1);
	void NETWORK_CLEAR_FOUND_GAMERS();
	BOOL NETWORK_QUEUE_GAMER_FOR_STATUS(Any* p0);
	BOOL NETWORK_GET_GAMER_STATUS_FROM_QUEUE();
	BOOL NETWORK_IS_GETTING_GAMER_STATUS();
	BOOL NETWORK_DID_GET_GAMER_STATUS_SUCCEED();
	BOOL NETWORK_GET_GAMER_STATUS_RESULT(Any* p0, Any p1);
	void NETWORK_CLEAR_GET_GAMER_STATUS();
	void NETWORK_SESSION_JOIN_INVITE();
	void NETWORK_SESSION_CANCEL_INVITE();
	void NETWORK_SESSION_FORCE_CANCEL_INVITE();
	BOOL NETWORK_HAS_PENDING_INVITE();
	BOOL NETWORK_HAS_CONFIRMED_INVITE();
	BOOL NETWORK_REQUEST_INVITE_CONFIRMED_EVENT();
	BOOL NETWORK_SESSION_WAS_INVITED();
	void NETWORK_SESSION_GET_INVITER(Any* gamerHandle);
	BOOL NETWORK_SESSION_IS_AWAITING_INVITE_RESPONSE();
	BOOL NETWORK_SESSION_IS_DISPLAYING_INVITE_CONFIRMATION();
	void NETWORK_SUPPRESS_INVITE(BOOL toggle);
	void NETWORK_BLOCK_INVITES(BOOL toggle);
	void NETWORK_BLOCK_JOIN_QUEUE_INVITES(BOOL toggle);
	void NETWORK_SET_CAN_RECEIVE_RS_INVITES(BOOL p0);
	void NETWORK_STORE_INVITE_THROUGH_RESTART();
	void NETWORK_ALLOW_INVITE_PROCESS_IN_PLAYER_SWITCH(BOOL p0);
	void NETWORK_SET_SCRIPT_READY_FOR_EVENTS(BOOL toggle);
	BOOL NETWORK_IS_OFFLINE_INVITE_PENDING();
	void NETWORK_CLEAR_OFFLINE_INVITE_PENDING();
	void NETWORK_SESSION_HOST_SINGLE_PLAYER(int p0);
	void NETWORK_SESSION_LEAVE_SINGLE_PLAYER();
	BOOL NETWORK_IS_GAME_IN_PROGRESS();
	BOOL NETWORK_IS_SESSION_ACTIVE();
	BOOL NETWORK_IS_IN_SESSION();
	BOOL NETWORK_IS_SESSION_STARTED();
	BOOL NETWORK_IS_SESSION_BUSY();
	BOOL NETWORK_CAN_SESSION_END();
	int NETWORK_GET_GAME_MODE();
	void NETWORK_SESSION_MARK_VISIBLE(BOOL toggle);
	BOOL NETWORK_SESSION_IS_VISIBLE();
	void NETWORK_SESSION_BLOCK_JOIN_REQUESTS(BOOL toggle);
	void NETWORK_SESSION_CHANGE_SLOTS(int slots, BOOL p1);
	int NETWORK_SESSION_GET_PRIVATE_SLOTS();
	BOOL NETWORK_SESSION_VOICE_HOST();
	BOOL NETWORK_SESSION_VOICE_LEAVE();
	void NETWORK_SESSION_VOICE_CONNECT_TO_PLAYER(Any* gamerHandle);
	void NETWORK_SESSION_VOICE_RESPOND_TO_REQUEST(BOOL p0, int p1);
	void NETWORK_SESSION_VOICE_SET_TIMEOUT(int timeout);
	BOOL NETWORK_SESSION_IS_IN_VOICE_SESSION();
	BOOL NETWORK_SESSION_IS_VOICE_SESSION_ACTIVE();
	BOOL NETWORK_SESSION_IS_VOICE_SESSION_BUSY();
	BOOL NETWORK_SEND_TEXT_MESSAGE(const char* message, Any* gamerHandle);
	void NETWORK_SET_ACTIVITY_SPECTATOR(BOOL toggle);
	BOOL NETWORK_IS_ACTIVITY_SPECTATOR();
	void NETWORK_SET_ACTIVITY_PLAYER_MAX(Any p0);
	void NETWORK_SET_ACTIVITY_SPECTATOR_MAX(int maxSpectators);
	int NETWORK_GET_ACTIVITY_PLAYER_NUM(BOOL p0);
	BOOL NETWORK_IS_ACTIVITY_SPECTATOR_FROM_HANDLE(Any* gamerHandle);
	BOOL NETWORK_HOST_TRANSITION(int p0, int p1, int p2, int p3, Any p4, BOOL p5, BOOL p6, int p7, Any p8, int p9);
	BOOL NETWORK_DO_TRANSITION_QUICKMATCH(Any p0, Any p1, Any p2, Any p3, Any p4, Any p5);
	BOOL NETWORK_DO_TRANSITION_QUICKMATCH_ASYNC(Any p0, Any p1, Any p2, Any p3, Any p4, Any p5);
	BOOL NETWORK_DO_TRANSITION_QUICKMATCH_WITH_GROUP(Any p0, Any p1, Any p2, Any p3, Any* p4, Any p5, Any p6, Any p7);
	BOOL NETWORK_JOIN_GROUP_ACTIVITY();
	void NETWORK_CLEAR_GROUP_ACTIVITY();
	void NETWORK_RETAIN_ACTIVITY_GROUP();
	BOOL NETWORK_IS_TRANSITION_CLOSED_FRIENDS();
	BOOL NETWORK_IS_TRANSITION_CLOSED_CREW();
	BOOL NETWORK_IS_TRANSITION_SOLO();
	BOOL NETWORK_IS_TRANSITION_PRIVATE();
	int NETWORK_GET_NUM_TRANSITION_NON_ASYNC_GAMERS();
	void NETWORK_MARK_AS_PREFERRED_ACTIVITY(BOOL p0);
	void NETWORK_MARK_AS_WAITING_ASYNC(BOOL p0);
	void NETWORK_SET_IN_PROGRESS_FINISH_TIME(Any p0);
	void NETWORK_SET_TRANSITION_CREATOR_HANDLE(Any* p0);
	void NETWORK_CLEAR_TRANSITION_CREATOR_HANDLE();
	BOOL NETWORK_INVITE_GAMERS_TO_TRANSITION(Any* p0, Any p1);
	void NETWORK_SET_GAMER_INVITED_TO_TRANSITION(Any* gamerHandle);
	BOOL NETWORK_LEAVE_TRANSITION();
	BOOL NETWORK_LAUNCH_TRANSITION();
	void NETWORK_SET_DO_NOT_LAUNCH_FROM_JOIN_AS_MIGRATED_HOST(BOOL toggle);
	void NETWORK_CANCEL_TRANSITION_MATCHMAKING();
	void NETWORK_BAIL_TRANSITION(int p0, int p1, int p2);
	BOOL NETWORK_DO_TRANSITION_TO_GAME(BOOL p0, int maxPlayers);
	BOOL NETWORK_DO_TRANSITION_TO_NEW_GAME(BOOL p0, int maxPlayers, BOOL p2);
	BOOL NETWORK_DO_TRANSITION_TO_FREEMODE(Any* p0, Any p1, BOOL p2, int players, BOOL p4);
	BOOL NETWORK_DO_TRANSITION_TO_NEW_FREEMODE(Any* p0, Any p1, int players, BOOL p3, BOOL p4, BOOL p5);
	BOOL NETWORK_IS_TRANSITION_TO_GAME();
	int NETWORK_GET_TRANSITION_MEMBERS(Any* data, int dataCount);
	void NETWORK_APPLY_TRANSITION_PARAMETER(int p0, int p1);
	void NETWORK_APPLY_TRANSITION_PARAMETER_STRING(int p0, const char* string, BOOL p2);
	BOOL NETWORK_SEND_TRANSITION_GAMER_INSTRUCTION(Any* gamerHandle, const char* p1, int p2, int p3, BOOL p4);
	BOOL NETWORK_MARK_TRANSITION_GAMER_AS_FULLY_JOINED(Any* p0);
	BOOL NETWORK_IS_TRANSITION_HOST();
	BOOL NETWORK_IS_TRANSITION_HOST_FROM_HANDLE(Any* gamerHandle);
	BOOL NETWORK_GET_TRANSITION_HOST(Any* gamerHandle);
	BOOL NETWORK_IS_IN_TRANSITION();
	BOOL NETWORK_IS_TRANSITION_STARTED();
	BOOL NETWORK_IS_TRANSITION_BUSY();
	BOOL NETWORK_IS_TRANSITION_MATCHMAKING();
	BOOL NETWORK_IS_TRANSITION_LEAVE_POSTPONED();
	void NETWORK_TRANSITION_SET_IN_PROGRESS(Any p0);
	void NETWORK_TRANSITION_SET_CONTENT_CREATOR(Any p0);
	void NETWORK_TRANSITION_SET_ACTIVITY_ISLAND(Any p0);
	void NETWORK_OPEN_TRANSITION_MATCHMAKING();
	void NETWORK_CLOSE_TRANSITION_MATCHMAKING();
	BOOL NETWORK_IS_TRANSITION_OPEN_TO_MATCHMAKING();
	void NETWORK_SET_TRANSITION_VISIBILITY_LOCK(BOOL p0, BOOL p1);
	BOOL NETWORK_IS_TRANSITION_VISIBILITY_LOCKED();
	void NETWORK_SET_TRANSITION_ACTIVITY_ID(Any p0);
	void NETWORK_CHANGE_TRANSITION_SLOTS(Any p0, BOOL p1);
	void NETWORK_TRANSITION_BLOCK_JOIN_REQUESTS(BOOL p0);
	BOOL NETWORK_HAS_PLAYER_STARTED_TRANSITION(Player player);
	BOOL NETWORK_ARE_TRANSITION_DETAILS_VALID(Any p0);
	BOOL NETWORK_JOIN_TRANSITION(Player player);
	BOOL NETWORK_HAS_INVITED_GAMER_TO_TRANSITION(Any* p0);
	BOOL NETWORK_HAS_TRANSITION_INVITE_BEEN_ACKED(Any* p0);
	BOOL NETWORK_IS_ACTIVITY_SESSION();
	void NETWORK_DISABLE_REALTIME_MULTIPLAYER();
	void NETWORK_SET_PRESENCE_SESSION_INVITES_BLOCKED(BOOL toggle);
	BOOL NETWORK_SEND_INVITE_VIA_PRESENCE(Any* gamerHandle, const char* p1, int dataCount, int p3);
	BOOL NETWORK_SEND_TRANSITION_INVITE_VIA_PRESENCE(Any* gamerHandle, const char* p1, int dataCount, int p3);
	BOOL NETWORK_SEND_IMPORTANT_TRANSITION_INVITE_VIA_PRESENCE(Any* gamerHandle, const char* p1, int dataCount, int p3);
	int NETWORK_GET_PRESENCE_INVITE_INDEX_BY_ID(int p0);
	int NETWORK_GET_NUM_PRESENCE_INVITES();
	BOOL NETWORK_ACCEPT_PRESENCE_INVITE(int p0);
	BOOL NETWORK_REMOVE_PRESENCE_INVITE(int p0);
	int NETWORK_GET_PRESENCE_INVITE_ID(int p0);
	const char* NETWORK_GET_PRESENCE_INVITE_INVITER(int p0);
	BOOL NETWORK_GET_PRESENCE_INVITE_HANDLE(Any p0, Any* p1);
	int NETWORK_GET_PRESENCE_INVITE_SESSION_ID(Any p0);
	const char* NETWORK_GET_PRESENCE_INVITE_CONTENT_ID(int p0);
	int NETWORK_GET_PRESENCE_INVITE_PLAYLIST_LENGTH(int p0);
	int NETWORK_GET_PRESENCE_INVITE_PLAYLIST_CURRENT(int p0);
	BOOL NETWORK_GET_PRESENCE_INVITE_FROM_ADMIN(int p0);
	BOOL NETWORK_GET_PRESENCE_INVITE_IS_TOURNAMENT(Any p0);
	BOOL NETWORK_HAS_FOLLOW_INVITE();
	BOOL NETWORK_ACTION_FOLLOW_INVITE();
	BOOL NETWORK_CLEAR_FOLLOW_INVITE();
	void NETWORK_REMOVE_AND_CANCEL_ALL_INVITES();
	void NETWORK_REMOVE_TRANSITION_INVITE(Any* p0);
	void NETWORK_REMOVE_ALL_TRANSITION_INVITE();
	void NETWORK_REMOVE_AND_CANCEL_ALL_TRANSITION_INVITES();
	BOOL NETWORK_INVITE_GAMERS(Any* p0, Any p1, Any* p2, Any p3);
	BOOL NETWORK_HAS_INVITED_GAMER(Any* p0);
	BOOL NETWORK_HAS_MADE_INVITE_DECISION(Any* gamerHandle);
	int NETWORK_GET_INVITE_REPLY_STATUS(Any p0);
	BOOL NETWORK_GET_CURRENTLY_SELECTED_GAMER_HANDLE_FROM_INVITE_MENU(Any* p0);
	BOOL NETWORK_SET_CURRENTLY_SELECTED_GAMER_HANDLE_FROM_INVITE_MENU(Any* p0);
	void NETWORK_SET_INVITE_ON_CALL_FOR_INVITE_MENU(Any* p0);
	BOOL NETWORK_CHECK_DATA_MANAGER_SUCCEEDED_FOR_HANDLE(int p0, Any* gamerHandle);
	BOOL NETWORK_CHECK_DATA_MANAGER_FOR_HANDLE(Any p0, Any* gamerHandle);
	void NETWORK_SET_INVITE_FAILED_MESSAGE_FOR_INVITE_MENU(Any* p0, Any* p1);
	BOOL FILLOUT_PM_PLAYER_LIST(Any* gamerHandle, Any p1, Any p2);
	BOOL FILLOUT_PM_PLAYER_LIST_WITH_NAMES(Any* p0, Any* p1, Any p2, Any p3);
	BOOL REFRESH_PLAYER_LIST_STATS(int p0);
	BOOL NETWORK_SET_CURRENT_DATA_MANAGER_HANDLE(Any* p0);
	BOOL NETWORK_IS_IN_PLATFORM_PARTY();
	int NETWORK_GET_PLATFORM_PARTY_MEMBER_COUNT();
	int NETWORK_GET_PLATFORM_PARTY_MEMBERS(Any* data, int dataSize);
	BOOL NETWORK_IS_IN_PLATFORM_PARTY_CHAT();
	BOOL NETWORK_IS_CHATTING_IN_PLATFORM_PARTY(Any* gamerHandle);
	BOOL NETWORK_CAN_QUEUE_FOR_PREVIOUS_SESSION_JOIN();
	BOOL NETWORK_IS_QUEUING_FOR_SESSION_JOIN();
	void NETWORK_CLEAR_QUEUED_JOIN_REQUEST();
	void NETWORK_SEND_QUEUED_JOIN_REQUEST();
	void NETWORK_REMOVE_ALL_QUEUED_JOIN_REQUESTS();
	void NETWORK_SEED_RANDOM_NUMBER_GENERATOR(int seed);
	int NETWORK_GET_RANDOM_INT();
	int NETWORK_GET_RANDOM_INT_RANGED(int rangeStart, int rangeEnd);
	float NETWORK_GET_RANDOM_FLOAT_RANGED_(float rangeStart, float rangeEnd);
	BOOL NETWORK_PLAYER_IS_CHEATER();
	int NETWORK_PLAYER_GET_CHEATER_REASON();
	BOOL NETWORK_PLAYER_IS_BADSPORT();
	BOOL REMOTE_CHEATER_PLAYER_DETECTED(Player player, int a, int b);
	BOOL BAD_SPORT_PLAYER_LEFT_DETECTED(Any* gamerHandle, int event, int amountReceived);
	void NETWORK_ADD_INVALID_OBJECT_MODEL(Hash modelHash);
	void NETWORK_REMOVE_INVALID_OBJECT_MODEL(Hash modelHash);
	void NETWORK_CLEAR_INVALID_OBJECT_MODELS();
	void NETWORK_APPLY_PED_SCAR_DATA(Ped ped, int p1);
	void NETWORK_SET_THIS_SCRIPT_IS_NETWORK_SCRIPT(int maxNumMissionParticipants, BOOL p1, int instanceId);
	BOOL NETWORK_TRY_TO_SET_THIS_SCRIPT_IS_NETWORK_SCRIPT(Any p0, BOOL p1, Any p2);
	BOOL NETWORK_GET_THIS_SCRIPT_IS_NETWORK_SCRIPT();
	int NETWORK_GET_MAX_NUM_PARTICIPANTS();
	int NETWORK_GET_NUM_PARTICIPANTS();
	int NETWORK_GET_SCRIPT_STATUS();
	void NETWORK_REGISTER_HOST_BROADCAST_VARIABLES(int* vars, int numVars, const char* debugName);
	void NETWORK_REGISTER_PLAYER_BROADCAST_VARIABLES(int* vars, int numVars, const char* debugName);
	void NETWORK_REGISTER_HIGH_FREQUENCY_HOST_BROADCAST_VARIABLES(Any p0, Any p1, Any p2);
	void NETWORK_REGISTER_HIGH_FREQUENCY_PLAYER_BROADCAST_VARIABLES(Any p0, Any p1, Any p2);
	void NETWORK_FINISH_BROADCASTING_DATA();
	BOOL NETWORK_HAS_RECEIVED_HOST_BROADCAST_DATA();
	Player NETWORK_GET_PLAYER_INDEX(Player player);
	int NETWORK_GET_PARTICIPANT_INDEX(int index);
	Player NETWORK_GET_PLAYER_INDEX_FROM_PED(Ped ped);
	int NETWORK_GET_NUM_CONNECTED_PLAYERS();
	BOOL NETWORK_IS_PLAYER_CONNECTED(Player player);
	int NETWORK_GET_TOTAL_NUM_PLAYERS();
	BOOL NETWORK_IS_PARTICIPANT_ACTIVE(int p0);
	BOOL NETWORK_IS_PLAYER_ACTIVE(Player player);
	BOOL NETWORK_IS_PLAYER_A_PARTICIPANT(Player player);
	BOOL NETWORK_IS_HOST_OF_THIS_SCRIPT();
	Player NETWORK_GET_HOST_OF_THIS_SCRIPT();
	Player NETWORK_GET_HOST_OF_SCRIPT(const char* scriptName, int instance_id, int position_hash);
	void NETWORK_SET_MISSION_FINISHED();
	BOOL NETWORK_IS_SCRIPT_ACTIVE(const char* scriptName, int instance_id, BOOL p2, int position_hash);
	BOOL NETWORK_IS_SCRIPT_ACTIVE_BY_HASH(Hash scriptHash, int p1, BOOL p2, int p3);
	BOOL NETWORK_IS_THREAD_A_NETWORK_SCRIPT(int threadId);
	int NETWORK_GET_NUM_SCRIPT_PARTICIPANTS(const char* scriptName, int instance_id, int position_hash);
	int NETWORK_GET_INSTANCE_ID_OF_THIS_SCRIPT();
	Hash NETWORK_GET_POSITION_HASH_OF_THIS_SCRIPT();
	BOOL NETWORK_IS_PLAYER_A_PARTICIPANT_ON_SCRIPT(Player player, const char* script, int instance_id);
	void NETWORK_PREVENT_SCRIPT_HOST_MIGRATION();
	void NETWORK_REQUEST_TO_BE_HOST_OF_THIS_SCRIPT();
	Player PARTICIPANT_ID();
	int PARTICIPANT_ID_TO_INT();
	Player NETWORK_GET_KILLER_OF_PLAYER(Player player, Hash* weaponHash);
	Player NETWORK_GET_DESTROYER_OF_NETWORK_ID(int netId, Hash* weaponHash);
	Player NETWORK_GET_DESTROYER_OF_ENTITY(Entity entity, Hash* weaponHash);
	BOOL NETWORK_GET_ASSISTED_KILL_OF_ENTITY(Player player, Entity entity, int* p2);
	BOOL NETWORK_GET_ASSISTED_DAMAGE_OF_ENTITY(Player player, Entity entity, int* p2);
	Entity NETWORK_GET_ENTITY_KILLER_OF_PLAYER(Player player, Hash* weaponHash);
	void NETWORK_SET_CURRENT_PUBLIC_CONTENT_ID(const char* missionId);
	void NETWORK_SET_CURRENT_CHAT_OPTION(int newChatOption);
	void NETWORK_SET_CURRENT_SPAWN_LOCATION_OPTION(Hash mpSettingSpawn);
	void NETWORK_SET_VEHICLE_DRIVEN_IN_TEST_DRIVE(BOOL toggle);
	void NETWORK_SET_VEHICLE_DRIVEN_LOCATION(Hash location);
	void NETWORK_RESURRECT_LOCAL_PLAYER(float x, float y, float z, float heading, BOOL p4, BOOL changetime, BOOL p6, int p7, int p8);
	void NETWORK_SET_LOCAL_PLAYER_INVINCIBLE_TIME(int time);
	BOOL NETWORK_IS_LOCAL_PLAYER_INVINCIBLE();
	void NETWORK_DISABLE_INVINCIBLE_FLASHING(Player player, BOOL toggle);
	void NETWORK_PATCH_POST_CUTSCENE_HS4F_TUN_ENT(Ped ped);
	void NETWORK_SET_LOCAL_PLAYER_SYNC_LOOK_AT(BOOL toggle);
	BOOL NETWORK_HAS_ENTITY_BEEN_REGISTERED_WITH_THIS_THREAD(Entity entity);
	int NETWORK_GET_NETWORK_ID_FROM_ENTITY(Entity entity);
	Entity NETWORK_GET_ENTITY_FROM_NETWORK_ID(int netId);
	BOOL NETWORK_GET_ENTITY_IS_NETWORKED(Entity entity);
	BOOL NETWORK_GET_ENTITY_IS_LOCAL(Entity entity);
	void NETWORK_REGISTER_ENTITY_AS_NETWORKED(Entity entity);
	void NETWORK_UNREGISTER_NETWORKED_ENTITY(Entity entity);
	BOOL NETWORK_DOES_NETWORK_ID_EXIST(int netId);
	BOOL NETWORK_DOES_ENTITY_EXIST_WITH_NETWORK_ID(int netId);
	BOOL NETWORK_REQUEST_CONTROL_OF_NETWORK_ID(int netId);
	BOOL NETWORK_HAS_CONTROL_OF_NETWORK_ID(int netId);
	BOOL NETWORK_IS_NETWORK_ID_REMOTELY_CONTROLLED(int netId);
	BOOL NETWORK_REQUEST_CONTROL_OF_ENTITY(Entity entity);
	BOOL NETWORK_REQUEST_CONTROL_OF_DOOR(int doorID);
	BOOL NETWORK_HAS_CONTROL_OF_ENTITY(Entity entity);
	BOOL NETWORK_HAS_CONTROL_OF_PICKUP(Pickup pickup);
	BOOL NETWORK_HAS_CONTROL_OF_DOOR(Hash doorHash);
	BOOL NETWORK_IS_DOOR_NETWORKED(Hash doorHash);
	int VEH_TO_NET(Vehicle vehicle);
	int PED_TO_NET(Ped ped);
	int OBJ_TO_NET(Object object);
	Vehicle NET_TO_VEH(int netHandle);
	Ped NET_TO_PED(int netHandle);
	Object NET_TO_OBJ(int netHandle);
	Entity NET_TO_ENT(int netHandle);
	void NETWORK_GET_LOCAL_HANDLE(Any* gamerHandle, int gamerHandleSize);
	void NETWORK_HANDLE_FROM_USER_ID(const char* userId, Any* gamerHandle, int gamerHandleSize);
	void NETWORK_HANDLE_FROM_MEMBER_ID(const char* memberId, Any* gamerHandle, int gamerHandleSize);
	void NETWORK_HANDLE_FROM_PLAYER(Player player, Any* gamerHandle, int gamerHandleSize);
	Hash NETWORK_HASH_FROM_PLAYER_HANDLE(Player player);
	Hash NETWORK_HASH_FROM_GAMER_HANDLE(Any* gamerHandle);
	void NETWORK_HANDLE_FROM_FRIEND(int friendIndex, Any* gamerHandle, int gamerHandleSize);
	BOOL NETWORK_GAMERTAG_FROM_HANDLE_START(Any* gamerHandle);
	BOOL NETWORK_GAMERTAG_FROM_HANDLE_PENDING();
	BOOL NETWORK_GAMERTAG_FROM_HANDLE_SUCCEEDED();
	const char* NETWORK_GET_GAMERTAG_FROM_HANDLE(Any* gamerHandle);
	int NETWORK_DISPLAYNAMES_FROM_HANDLES_START(Any* p0, Any p1);
	int NETWORK_GET_DISPLAYNAMES_FROM_HANDLES(Any p0, Any p1, Any p2);
	BOOL NETWORK_ARE_HANDLES_THE_SAME(Any* gamerHandle1, Any* gamerHandle2);
	BOOL NETWORK_IS_HANDLE_VALID(Any* gamerHandle, int gamerHandleSize);
	Player NETWORK_GET_PLAYER_FROM_GAMER_HANDLE(Any* gamerHandle);
	const char* NETWORK_MEMBER_ID_FROM_GAMER_HANDLE(Any* gamerHandle);
	BOOL NETWORK_IS_GAMER_IN_MY_SESSION(Any* gamerHandle);
	void NETWORK_SHOW_PROFILE_UI(Any* gamerHandle);
	const char* NETWORK_PLAYER_GET_NAME(Player player);
	const char* NETWORK_PLAYER_GET_USERID(Player player, int* userID);
	BOOL NETWORK_PLAYER_IS_ROCKSTAR_DEV(Player player);
	BOOL NETWORK_PLAYER_INDEX_IS_CHEATER(Player player);
	int NETWORK_ENTITY_GET_OBJECT_ID(Entity entity);
	Entity NETWORK_GET_ENTITY_FROM_OBJECT_ID(Any p0);
	BOOL NETWORK_IS_INACTIVE_PROFILE(Any* p0);
	int NETWORK_GET_MAX_FRIENDS();
	int NETWORK_GET_FRIEND_COUNT();
	const char* NETWORK_GET_FRIEND_NAME(int friendIndex);
	const char* NETWORK_GET_FRIEND_DISPLAY_NAME(int friendIndex);
	BOOL NETWORK_IS_FRIEND_ONLINE(const char* name);
	BOOL NETWORK_IS_FRIEND_HANDLE_ONLINE(Any* gamerHandle);
	BOOL NETWORK_IS_FRIEND_IN_SAME_TITLE(const char* friendName);
	BOOL NETWORK_IS_FRIEND_IN_MULTIPLAYER(const char* friendName);
	BOOL NETWORK_IS_FRIEND(Any* gamerHandle);
	BOOL NETWORK_IS_PENDING_FRIEND(Any p0);
	BOOL NETWORK_IS_ADDING_FRIEND();
	BOOL NETWORK_ADD_FRIEND(Any* gamerHandle, const char* message);
	BOOL NETWORK_IS_FRIEND_INDEX_ONLINE(int friendIndex);
	void NETWORK_SET_PLAYER_IS_PASSIVE(BOOL toggle);
	BOOL NETWORK_GET_PLAYER_OWNS_WAYPOINT(Player player);
	BOOL NETWORK_CAN_SET_WAYPOINT();
	void NETWORK_IGNORE_REMOTE_WAYPOINTS();
	BOOL NETWORK_IS_PLAYER_ON_BLOCKLIST(Any* gamerHandle);
	BOOL NETWORK_SET_SCRIPT_AUTOMUTED(Any p0);
	BOOL NETWORK_HAS_AUTOMUTE_OVERRIDE();
	BOOL NETWORK_HAS_HEADSET();
	void NETWORK_SET_LOOK_AT_TALKERS(BOOL p0);
	BOOL NETWORK_IS_PUSH_TO_TALK_ACTIVE();
	BOOL NETWORK_GAMER_HAS_HEADSET(Any* gamerHandle);
	BOOL NETWORK_IS_GAMER_TALKING(Any* gamerHandle);
	BOOL NETWORK_PERMISSIONS_HAS_GAMER_RECORD(Any* gamerHandle);
	BOOL NETWORK_CAN_COMMUNICATE_WITH_GAMER(Any* gamerHandle);
	BOOL NETWORK_CAN_TEXT_CHAT_WITH_GAMER(Any* gamerHandle);
	BOOL NETWORK_IS_GAMER_MUTED_BY_ME(Any* gamerHandle);
	BOOL NETWORK_AM_I_MUTED_BY_GAMER(Any* gamerHandle);
	BOOL NETWORK_IS_GAMER_BLOCKED_BY_ME(Any* gamerHandle);
	BOOL NETWORK_AM_I_BLOCKED_BY_GAMER(Any* gamerHandle);
	BOOL NETWORK_CAN_VIEW_GAMER_USER_CONTENT(Any* gamerHandle);
	BOOL NETWORK_HAS_VIEW_GAMER_USER_CONTENT_RESULT(Any* gamerHandle);
	BOOL NETWORK_CAN_PLAY_MULTIPLAYER_WITH_GAMER(Any* gamerHandle);
	BOOL NETWORK_CAN_GAMER_PLAY_MULTIPLAYER_WITH_ME(Any* gamerHandle);
	BOOL NETWORK_CAN_SEND_LOCAL_INVITE(Any* gamerHandle);
	BOOL NETWORK_CAN_RECEIVE_LOCAL_INVITE(Any* gamerHandle);
	BOOL NETWORK_IS_PLAYER_TALKING(Player player);
	BOOL NETWORK_PLAYER_HAS_HEADSET(Player player);
	BOOL NETWORK_IS_PLAYER_MUTED_BY_ME(Player player);
	BOOL NETWORK_AM_I_MUTED_BY_PLAYER(Player player);
	BOOL NETWORK_IS_PLAYER_BLOCKED_BY_ME(Player player);
	BOOL NETWORK_AM_I_BLOCKED_BY_PLAYER(Player player);
	float NETWORK_GET_PLAYER_LOUDNESS(Player player);
	void NETWORK_SET_TALKER_PROXIMITY(float value);
	float NETWORK_GET_TALKER_PROXIMITY();
	void NETWORK_SET_VOICE_ACTIVE(BOOL toggle);
	void NETWORK_REMAIN_IN_GAME_CHAT(BOOL p0);
	void NETWORK_OVERRIDE_TRANSITION_CHAT(BOOL p0);
	void NETWORK_SET_TEAM_ONLY_CHAT(BOOL toggle);
	void NETWORK_SET_SCRIPT_CONTROLLING_TEAMS(Any p0);
	BOOL NETWORK_SET_SAME_TEAM_AS_LOCAL_PLAYER(Any p0, Any p1);
	void NETWORK_OVERRIDE_TEAM_RESTRICTIONS(int team, BOOL toggle);
	void NETWORK_SET_OVERRIDE_SPECTATOR_MODE(BOOL toggle);
	void NETWORK_SET_OVERRIDE_TUTORIAL_SESSION_CHAT(BOOL toggle);
	void NETWORK_SET_PROXIMITY_AFFECTS_TEAM(BOOL toggle);
	void NETWORK_SET_NO_SPECTATOR_CHAT(BOOL toggle);
	void NETWORK_SET_IGNORE_SPECTATOR_CHAT_LIMITS_SAME_TEAM(BOOL toggle);
	void NETWORK_OVERRIDE_CHAT_RESTRICTIONS(Player player, BOOL toggle);
	void NETWORK_OVERRIDE_SEND_RESTRICTIONS(Player player, BOOL toggle);
	void NETWORK_OVERRIDE_SEND_RESTRICTIONS_ALL(BOOL toggle);
	void NETWORK_OVERRIDE_RECEIVE_RESTRICTIONS(Player player, BOOL toggle);
	void NETWORK_OVERRIDE_RECEIVE_RESTRICTIONS_ALL(BOOL toggle);
	void NETWORK_SET_VOICE_CHANNEL(int channel);
	void NETWORK_CLEAR_VOICE_CHANNEL();
	void NETWORK_APPLY_VOICE_PROXIMITY_OVERRIDE(float x, float y, float z);
	void NETWORK_CLEAR_VOICE_PROXIMITY_OVERRIDE();
	void NETWORK_ENABLE_VOICE_BANDWIDTH_RESTRICTION(Player player);
	void NETWORK_DISABLE_VOICE_BANDWIDTH_RESTRICTION(Player player);
	void NETWORK_GET_MUTE_COUNT_FOR_PLAYER(Player p0, float* p1, float* p2);
	void NETWORK_SET_SPECTATOR_TO_NON_SPECTATOR_TEXT_CHAT(BOOL toggle);
	BOOL NETWORK_TEXT_CHAT_IS_TYPING();
	void SHUTDOWN_AND_LAUNCH_SINGLE_PLAYER_GAME();
	BOOL SHUTDOWN_AND_LOAD_MOST_RECENT_SAVE();
	void NETWORK_SET_FRIENDLY_FIRE_OPTION(BOOL toggle);
	void NETWORK_SET_RICH_PRESENCE(int p0, int p1, Any p2, Any p3);
	void NETWORK_SET_RICH_PRESENCE_STRING(int p0, const char* textLabel);
	int NETWORK_GET_TIMEOUT_TIME();
	void NETWORK_LEAVE_PED_BEHIND_BEFORE_WARP(Player player, float x, float y, float z, BOOL p4, BOOL p5);
	void NETWORK_LEAVE_PED_BEHIND_BEFORE_CUTSCENE(Player player, BOOL p1);
	void REMOVE_ALL_STICKY_BOMBS_FROM_ENTITY(Entity entity, Ped ped);
	void NETWORK_KEEP_ENTITY_COLLISION_DISABLED_AFTER_ANIM_SCENE(Any p0, Any p1);
	BOOL NETWORK_IS_ANY_PLAYER_NEAR(Any p0, Any p1, Any p2, Any p3, Any p4, Any p5, Any p6);
	BOOL NETWORK_CLAN_SERVICE_IS_VALID();
	BOOL NETWORK_CLAN_PLAYER_IS_ACTIVE(Any* gamerHandle);
	BOOL NETWORK_CLAN_PLAYER_GET_DESC(Any* clanDesc, int bufferSize, Any* gamerHandle);
	BOOL NETWORK_CLAN_IS_ROCKSTAR_CLAN(Any* clanDesc, int bufferSize);
	void NETWORK_CLAN_GET_UI_FORMATTED_TAG(Any* clanDesc, int bufferSize, char* formattedTag);
	int NETWORK_CLAN_GET_LOCAL_MEMBERSHIPS_COUNT();
	BOOL NETWORK_CLAN_GET_MEMBERSHIP_DESC(Any* memberDesc, int p1);
	BOOL NETWORK_CLAN_DOWNLOAD_MEMBERSHIP(Any* gamerHandle);
	BOOL NETWORK_CLAN_DOWNLOAD_MEMBERSHIP_PENDING(Any* p0);
	BOOL NETWORK_CLAN_ANY_DOWNLOAD_MEMBERSHIP_PENDING();
	BOOL NETWORK_CLAN_REMOTE_MEMBERSHIPS_ARE_IN_CACHE(int* p0);
	int NETWORK_CLAN_GET_MEMBERSHIP_COUNT(int* p0);
	BOOL NETWORK_CLAN_GET_MEMBERSHIP_VALID(int* p0, Any p1);
	BOOL NETWORK_CLAN_GET_MEMBERSHIP(int* p0, Any* clanMembership, int p2);
	BOOL NETWORK_CLAN_JOIN(int clanDesc);
	BOOL NETWORK_CLAN_CREWINFO_GET_STRING_VALUE(const char* animDict, const char* animName);
	BOOL NETWORK_CLAN_CREWINFO_GET_CREWRANKTITLE(int p0, const char* p1);
	BOOL NETWORK_CLAN_HAS_CREWINFO_METADATA_BEEN_RECEIVED();
	BOOL NETWORK_CLAN_GET_EMBLEM_TXD_NAME(Any* netHandle, char* txdName);
	BOOL NETWORK_CLAN_REQUEST_EMBLEM(Any p0);
	BOOL NETWORK_CLAN_IS_EMBLEM_READY(Any p0, Any* p1);
	void NETWORK_CLAN_RELEASE_EMBLEM(Any p0);
	BOOL NETWORK_GET_PRIMARY_CLAN_DATA_CLEAR();
	void NETWORK_GET_PRIMARY_CLAN_DATA_CANCEL();
	BOOL NETWORK_GET_PRIMARY_CLAN_DATA_START(Any* p0, Any p1);
	BOOL NETWORK_GET_PRIMARY_CLAN_DATA_PENDING();
	BOOL NETWORK_GET_PRIMARY_CLAN_DATA_SUCCESS();
	BOOL NETWORK_GET_PRIMARY_CLAN_DATA_NEW(Any* p0, Any* p1);
	void SET_NETWORK_ID_CAN_MIGRATE(int netId, BOOL toggle);
	void SET_NETWORK_ID_EXISTS_ON_ALL_MACHINES(int netId, BOOL toggle);
	void SET_NETWORK_ID_ALWAYS_EXISTS_FOR_PLAYER(int netId, Player player, BOOL toggle);
	void SET_NETWORK_ID_CAN_BE_REASSIGNED(int netId, BOOL toggle);
	void NETWORK_SET_ENTITY_CAN_BLEND(Entity entity, BOOL toggle);
	void NETWORK_SET_OBJECT_CAN_BLEND_WHEN_FIXED(Object object, BOOL toggle);
	void NETWORK_SET_ENTITY_ONLY_EXISTS_FOR_PARTICIPANTS(Entity entity, BOOL toggle);
	void SET_NETWORK_ID_VISIBLE_IN_CUTSCENE(int netId, BOOL p1, BOOL p2);
	void SET_NETWORK_ID_VISIBLE_IN_CUTSCENE_HACK(int netId, BOOL p1, BOOL p2);
	void SET_NETWORK_ID_VISIBLE_IN_CUTSCENE_REMAIN_HACK(Any p0, Any p1);
	void SET_NETWORK_CUTSCENE_ENTITIES(BOOL toggle);
	BOOL ARE_CUTSCENE_ENTITIES_NETWORKED();
	void SET_NETWORK_ID_PASS_CONTROL_IN_TUTORIAL(int netId, BOOL state);
	BOOL IS_NETWORK_ID_OWNED_BY_PARTICIPANT(int netId);
	void SET_REMOTE_PLAYER_VISIBLE_IN_CUTSCENE(Player player, BOOL locallyVisible);
	void SET_LOCAL_PLAYER_VISIBLE_IN_CUTSCENE(BOOL p0, BOOL p1);
	void SET_LOCAL_PLAYER_INVISIBLE_LOCALLY(BOOL bIncludePlayersVehicle);
	void SET_LOCAL_PLAYER_VISIBLE_LOCALLY(BOOL bIncludePlayersVehicle);
	void SET_PLAYER_INVISIBLE_LOCALLY(Player player, BOOL bIncludePlayersVehicle);
	void SET_PLAYER_VISIBLE_LOCALLY(Player player, BOOL bIncludePlayersVehicle);
	void FADE_OUT_LOCAL_PLAYER(BOOL p0);
	void NETWORK_FADE_OUT_ENTITY(Entity entity, BOOL normal, BOOL slow);
	void NETWORK_FADE_IN_ENTITY(Entity entity, BOOL state, Any p2);
	BOOL NETWORK_IS_PLAYER_FADING(Player player);
	BOOL NETWORK_IS_ENTITY_FADING(Entity entity);
	BOOL IS_PLAYER_IN_CUTSCENE(Player player);
	void SET_ENTITY_VISIBLE_IN_CUTSCENE(Any p0, BOOL p1, BOOL p2);
	void SET_ENTITY_LOCALLY_INVISIBLE(Entity entity);
	void SET_ENTITY_LOCALLY_VISIBLE(Entity entity);
	BOOL IS_DAMAGE_TRACKER_ACTIVE_ON_NETWORK_ID(int netID);
	void ACTIVATE_DAMAGE_TRACKER_ON_NETWORK_ID(int netID, BOOL toggle);
	BOOL IS_DAMAGE_TRACKER_ACTIVE_ON_PLAYER(Player player);
	void ACTIVATE_DAMAGE_TRACKER_ON_PLAYER(Player player, BOOL toggle);
	BOOL IS_SPHERE_VISIBLE_TO_ANOTHER_MACHINE(float p0, float p1, float p2, float p3);
	BOOL IS_SPHERE_VISIBLE_TO_PLAYER(Any p0, float p1, float p2, float p3, float p4);
	void RESERVE_NETWORK_MISSION_OBJECTS(int amount);
	void RESERVE_NETWORK_MISSION_PEDS(int amount);
	void RESERVE_NETWORK_MISSION_VEHICLES(int amount);
	void RESERVE_LOCAL_NETWORK_MISSION_OBJECTS(int amount);
	void RESERVE_LOCAL_NETWORK_MISSION_PEDS(int amount);
	void RESERVE_LOCAL_NETWORK_MISSION_VEHICLES(int amount);
	BOOL CAN_REGISTER_MISSION_OBJECTS(int amount);
	BOOL CAN_REGISTER_MISSION_PEDS(int amount);
	BOOL CAN_REGISTER_MISSION_VEHICLES(int amount);
	BOOL CAN_REGISTER_MISSION_PICKUPS(int amount);
	BOOL CAN_REGISTER_MISSION_DOORS(Any p0);
	BOOL CAN_REGISTER_MISSION_ENTITIES(int ped_amt, int vehicle_amt, int object_amt, int pickup_amt);
	int GET_NUM_RESERVED_MISSION_OBJECTS(BOOL p0, Any p1);
	int GET_NUM_RESERVED_MISSION_PEDS(BOOL p0, Any p1);
	int GET_NUM_RESERVED_MISSION_VEHICLES(BOOL p0, Any p1);
	int GET_NUM_CREATED_MISSION_OBJECTS(BOOL p0);
	int GET_NUM_CREATED_MISSION_PEDS(BOOL p0);
	int GET_NUM_CREATED_MISSION_VEHICLES(BOOL p0);
	void GET_RESERVED_MISSION_ENTITIES_IN_AREA(float x, float y, float z, Any p3, Any* out1, Any* out2, Any* out3);
	int GET_MAX_NUM_NETWORK_OBJECTS();
	int GET_MAX_NUM_NETWORK_PEDS();
	int GET_MAX_NUM_NETWORK_VEHICLES();
	int GET_MAX_NUM_NETWORK_PICKUPS();
	void NETWORK_SET_OBJECT_SCOPE_DISTANCE(Object object, float range);
	void NETWORK_ALLOW_CLONING_WHILE_IN_TUTORIAL(Any p0, Any p1);
	void NETWORK_SET_TASK_CUTSCENE_INSCOPE_MULTIPLER(Any p0);
	int GET_NETWORK_TIME();
	int GET_NETWORK_TIME_ACCURATE();
	BOOL HAS_NETWORK_TIME_STARTED();
	int GET_TIME_OFFSET(int timeA, int timeB);
	BOOL IS_TIME_LESS_THAN(int timeA, int timeB);
	BOOL IS_TIME_MORE_THAN(int timeA, int timeB);
	BOOL IS_TIME_EQUAL_TO(int timeA, int timeB);
	int GET_TIME_DIFFERENCE(int timeA, int timeB);
	const char* GET_TIME_AS_STRING(int time);
	const char* GET_CLOUD_TIME_AS_STRING();
	int GET_CLOUD_TIME_AS_INT();
	void CONVERT_POSIX_TIME(int posixTime, Any* timeStructure);
	void NETWORK_SET_IN_SPECTATOR_MODE(BOOL toggle, Ped playerPed);
	void NETWORK_SET_IN_SPECTATOR_MODE_EXTENDED(BOOL toggle, Ped playerPed, BOOL p2);
	void NETWORK_SET_IN_FREE_CAM_MODE(BOOL toggle);
	void NETWORK_SET_ANTAGONISTIC_TO_PLAYER(BOOL toggle, Player player);
	BOOL NETWORK_IS_IN_SPECTATOR_MODE();
	void NETWORK_SET_IN_MP_CUTSCENE(BOOL p0, BOOL p1);
	BOOL NETWORK_IS_IN_MP_CUTSCENE();
	BOOL NETWORK_IS_PLAYER_IN_MP_CUTSCENE(Player player);
	void NETWORK_HIDE_PROJECTILE_IN_CUTSCENE();
	void SET_NETWORK_VEHICLE_RESPOT_TIMER(int netId, int time, Any p2, Any p3);
	BOOL IS_NETWORK_VEHICLE_RUNNING_RESPOT_TIMER(int networkID);
	void SET_NETWORK_VEHICLE_AS_GHOST(Vehicle vehicle, BOOL toggle);
	void SET_NETWORK_VEHICLE_MAX_POSITION_DELTA_MULTIPLIER(Vehicle vehicle, float multiplier);
	void SET_NETWORK_ENABLE_HIGH_SPEED_EDGE_FALL_DETECTION(Vehicle vehicle, BOOL toggle);
	void SET_LOCAL_PLAYER_AS_GHOST(BOOL toggle, BOOL p1);
	BOOL IS_ENTITY_A_GHOST(Entity entity);
	void SET_NON_PARTICIPANTS_OF_THIS_SCRIPT_AS_GHOSTS(BOOL p0);
	void SET_REMOTE_PLAYER_AS_GHOST(Player player, BOOL p1);
	void SET_GHOST_ALPHA(int alpha);
	void RESET_GHOST_ALPHA();
	void SET_ENTITY_GHOSTED_FOR_GHOST_PLAYERS(Entity entity, BOOL toggle);
	void SET_INVERT_GHOSTING(BOOL p0);
	BOOL IS_ENTITY_IN_GHOST_COLLISION(Entity entity);
	void USE_PLAYER_COLOUR_INSTEAD_OF_TEAM_COLOUR(BOOL toggle);
	int NETWORK_CREATE_SYNCHRONISED_SCENE(float x, float y, float z, float xRot, float yRot, float zRot, int rotationOrder, BOOL useOcclusionPortal, BOOL looped, float p9, float animTime, float p11);
	void NETWORK_ADD_PED_TO_SYNCHRONISED_SCENE(Ped ped, int netScene, const char* animDict, const char* animnName, float speed, float speedMultiplier, int duration, int flag, float playbackRate, Any p9);
	void NETWORK_ADD_PED_TO_SYNCHRONISED_SCENE_WITH_IK(Any p0, Any p1, Any p2, Any p3, Any p4, Any p5, Any p6, Any p7, Any p8, Any p9);
	void NETWORK_ADD_ENTITY_TO_SYNCHRONISED_SCENE(Entity entity, int netScene, const char* animDict, const char* animName, float speed, float speedMulitiplier, int flag);
	void NETWORK_ADD_MAP_ENTITY_TO_SYNCHRONISED_SCENE(int netScene, Hash modelHash, float x, float y, float z, float p5, const char* p6, float p7, float p8, int flags);
	void NETWORK_ADD_SYNCHRONISED_SCENE_CAMERA(int netScene, const char* animDict, const char* animName);
	void NETWORK_ATTACH_SYNCHRONISED_SCENE_TO_ENTITY(int netScene, Entity entity, int bone);
	void NETWORK_START_SYNCHRONISED_SCENE(int netScene);
	void NETWORK_STOP_SYNCHRONISED_SCENE(int netScene);
	int NETWORK_GET_LOCAL_SCENE_FROM_NETWORK_ID(int netId);
	void NETWORK_FORCE_LOCAL_USE_OF_SYNCED_SCENE_CAMERA(int netScene);
	void NETWORK_ALLOW_REMOTE_SYNCED_SCENE_LOCAL_PLAYER_REQUESTS(Any p0);
	BOOL NETWORK_FIND_LARGEST_BUNCH_OF_PLAYERS(int p0, Any p1);
	BOOL NETWORK_START_RESPAWN_SEARCH_FOR_PLAYER(Player player, float x, float y, float z, float radius, float p5, float p6, float p7, int flags);
	BOOL NETWORK_START_RESPAWN_SEARCH_IN_ANGLED_AREA_FOR_PLAYER(Player player, float x1, float y1, float z1, float x2, float y2, float z2, float width, float p8, float p9, float p10, int flags);
	int NETWORK_QUERY_RESPAWN_RESULTS(Any* p0);
	void NETWORK_CANCEL_RESPAWN_SEARCH();
	void NETWORK_GET_RESPAWN_RESULT(int randomInt, Vector3* coordinates, float* heading);
	int NETWORK_GET_RESPAWN_RESULT_FLAGS(int p0);
	void NETWORK_START_SOLO_TUTORIAL_SESSION();
	void NETWORK_ALLOW_GANG_TO_JOIN_TUTORIAL_SESSION(int teamId, int instanceId);
	void NETWORK_END_TUTORIAL_SESSION();
	BOOL NETWORK_IS_IN_TUTORIAL_SESSION();
	BOOL NETWORK_WAITING_POP_CLEAR_TUTORIAL_SESSION();
	BOOL NETWORK_IS_TUTORIAL_SESSION_CHANGE_PENDING();
	int NETWORK_GET_PLAYER_TUTORIAL_SESSION_INSTANCE(Player player);
	BOOL NETWORK_ARE_PLAYERS_IN_SAME_TUTORIAL_SESSION(Player player, int index);
	void NETWORK_BLOCK_PROXY_MIGRATION_BETWEEN_TUTORIAL_SESSIONS(Any p0);
	void NETWORK_CONCEAL_PLAYER(Player player, BOOL toggle, BOOL p2);
	BOOL NETWORK_IS_PLAYER_CONCEALED(Player player);
	void NETWORK_CONCEAL_ENTITY(Entity entity, BOOL toggle);
	BOOL NETWORK_IS_ENTITY_CONCEALED(Entity entity);
	void NETWORK_OVERRIDE_CLOCK_TIME(int hours, int minutes, int seconds);
	void NETWORK_OVERRIDE_CLOCK_RATE(int ms);
	void NETWORK_CLEAR_CLOCK_TIME_OVERRIDE();
	BOOL NETWORK_IS_CLOCK_TIME_OVERRIDDEN();
	int NETWORK_ADD_ENTITY_AREA(float x1, float y1, float z1, float x2, float y2, float z2);
	int NETWORK_ADD_ENTITY_ANGLED_AREA(float x1, float y1, float z1, float x2, float y2, float z2, float width);
	int NETWORK_ADD_CLIENT_ENTITY_AREA(float x1, float y1, float z1, float x2, float y2, float z2);
	int NETWORK_ADD_CLIENT_ENTITY_ANGLED_AREA(float x1, float y1, float z1, float x2, float y2, float z2, float radius);
	BOOL NETWORK_REMOVE_ENTITY_AREA(int areaHandle);
	BOOL NETWORK_ENTITY_AREA_DOES_EXIST(int areaHandle);
	BOOL NETWORK_ENTITY_AREA_HAVE_ALL_REPLIED(int areaHandle);
	BOOL NETWORK_ENTITY_AREA_IS_OCCUPIED(int areaHandle);
	void NETWORK_USE_HIGH_PRECISION_BLENDING(int netID, BOOL toggle);
	void NETWORK_SET_CUSTOM_ARENA_BALL_PARAMS(int netId);
	void NETWORK_ENTITY_USE_HIGH_PRECISION_ROTATION(int netId, BOOL toggle);
	BOOL NETWORK_REQUEST_CLOUD_BACKGROUND_SCRIPTS();
	BOOL NETWORK_IS_CLOUD_BACKGROUND_SCRIPT_REQUEST_PENDING();
	void NETWORK_REQUEST_CLOUD_TUNABLES();
	BOOL NETWORK_IS_TUNABLE_CLOUD_REQUEST_PENDING();
	int NETWORK_GET_TUNABLE_CLOUD_CRC();
	BOOL NETWORK_DOES_TUNABLE_EXIST(const char* tunableContext, const char* tunableName);
	BOOL NETWORK_ACCESS_TUNABLE_INT(const char* tunableContext, const char* tunableName, int* value);
	BOOL NETWORK_ACCESS_TUNABLE_FLOAT(const char* tunableContext, const char* tunableName, float* value);
	BOOL NETWORK_ACCESS_TUNABLE_BOOL(const char* tunableContext, const char* tunableName);
	BOOL NETWORK_DOES_TUNABLE_EXIST_HASH(Hash tunableContext, Hash tunableName);
	BOOL NETWORK_ACCESS_TUNABLE_MODIFICATION_DETECTION_CLEAR();
	BOOL NETWORK_ACCESS_TUNABLE_INT_HASH(Hash tunableContext, Hash tunableName, int* value);
	BOOL NETWORK_ACCESS_TUNABLE_INT_MODIFICATION_DETECTION_REGISTRATION_HASH(Hash contextHash, Hash nameHash, int* value);
	BOOL NETWORK_ACCESS_TUNABLE_FLOAT_HASH(Hash tunableContext, Hash tunableName, float* value);
	BOOL NETWORK_ACCESS_TUNABLE_FLOAT_MODIFICATION_DETECTION_REGISTRATION_HASH(Hash contextHash, Hash nameHash, float* value);
	BOOL NETWORK_ACCESS_TUNABLE_BOOL_HASH(Hash tunableContext, Hash tunableName);
	BOOL NETWORK_ACCESS_TUNABLE_BOOL_MODIFICATION_DETECTION_REGISTRATION_HASH(Hash contextHash, Hash nameHash, BOOL* value);
	BOOL NETWORK_TRY_ACCESS_TUNABLE_BOOL_HASH(Hash tunableContext, Hash tunableName, BOOL defaultValue);
	int NETWORK_GET_CONTENT_MODIFIER_LIST_ID(Hash contentHash);
	int NETWORK_GET_BONE_ID_OF_FATAL_HIT();
	void NETWORK_RESET_BODY_TRACKER();
	int NETWORK_GET_NUMBER_BODY_TRACKER_HITS();
	BOOL NETWORK_HAS_BONE_BEEN_HIT_BY_KILLER(int boneIndex);
	BOOL NETWORK_SET_ATTRIBUTE_DAMAGE_TO_PLAYER(Ped ped, Player player);
	void NETWORK_TRIGGER_DAMAGE_EVENT_FOR_ZERO_DAMAGE(Entity entity, BOOL toggle);
	void NETWORK_TRIGGER_DAMAGE_EVENT_FOR_ZERO_WEAPON_HASH(Entity entity, BOOL toggle);
	void NETWORK_SET_NO_LONGER_NEEDED(Entity entity, BOOL toggle);
	BOOL NETWORK_EXPLODE_VEHICLE(Vehicle vehicle, BOOL isAudible, BOOL isInvisible, int netId);
	void NETWORK_EXPLODE_HELI(Vehicle vehicle, BOOL isAudible, BOOL isInvisible, int netId);
	void NETWORK_USE_LOGARITHMIC_BLENDING_THIS_FRAME(Entity entity);
	void NETWORK_OVERRIDE_COORDS_AND_HEADING(Entity entity, float x, float y, float z, float heading);
	void NETWORK_ENABLE_EXTRA_VEHICLE_ORIENTATION_BLEND_CHECKS(int netId, BOOL toggle);
	void NETWORK_DISABLE_PROXIMITY_MIGRATION(int netID);
	void NETWORK_SET_PROPERTY_ID(int id);
	void NETWORK_CLEAR_PROPERTY_ID();
	void NETWORK_SET_PLAYER_MENTAL_STATE(int p0);
	void NETWORK_SET_MINIMUM_RANK_FOR_MISSION(BOOL p0);
	void NETWORK_CACHE_LOCAL_PLAYER_HEAD_BLEND_DATA();
	BOOL NETWORK_HAS_CACHED_PLAYER_HEAD_BLEND_DATA(Player player);
	BOOL NETWORK_APPLY_CACHED_PLAYER_HEAD_BLEND_DATA(Ped ped, Player player);
	int GET_NUM_COMMERCE_ITEMS();
	BOOL IS_COMMERCE_DATA_VALID();
	void TRIGGER_COMMERCE_DATA_FETCH(Any p0);
	BOOL IS_COMMERCE_DATA_FETCH_IN_PROGRESS();
	const char* GET_COMMERCE_ITEM_ID(int index);
	const char* GET_COMMERCE_ITEM_NAME(int index);
	const char* GET_COMMERCE_PRODUCT_PRICE(int index);
	int GET_COMMERCE_ITEM_NUM_CATS(int index);
	const char* GET_COMMERCE_ITEM_CAT(int index, int index2);
	void OPEN_COMMERCE_STORE(const char* p0, const char* p1, int p2);
	BOOL IS_COMMERCE_STORE_OPEN();
	void SET_STORE_ENABLED(BOOL toggle);
	BOOL REQUEST_COMMERCE_ITEM_IMAGE(int index);
	void RELEASE_ALL_COMMERCE_ITEM_IMAGES();
	const char* GET_COMMERCE_ITEM_TEXTURENAME(int index);
	BOOL IS_STORE_AVAILABLE_TO_USER();
	void DELAY_MP_STORE_OPEN();
	void RESET_STORE_NETWORK_GAME_TRACKING();
	BOOL IS_USER_OLD_ENOUGH_TO_ACCESS_STORE();
	void SET_LAST_VIEWED_SHOP_ITEM(Hash p0, int p1, Hash p2);
	int GET_USER_PREMIUM_ACCESS();
	int GET_USER_STARTER_ACCESS();
	int CLOUD_DELETE_MEMBER_FILE(const char* p0);
	BOOL CLOUD_HAS_REQUEST_COMPLETED(int requestId);
	BOOL CLOUD_DID_REQUEST_SUCCEED(int requestId);
	void CLOUD_CHECK_AVAILABILITY();
	BOOL CLOUD_IS_CHECKING_AVAILABILITY();
	BOOL CLOUD_GET_AVAILABILITY_CHECK_RESULT();
	int GET_CONTENT_TO_LOAD_TYPE();
	BOOL GET_IS_LAUNCH_FROM_LIVE_AREA();
	BOOL GET_IS_LIVE_AREA_LAUNCH_WITH_CONTENT();
	void CLEAR_SERVICE_EVENT_ARGUMENTS();
	BOOL UGC_COPY_CONTENT(Any* p0, Any* p1);
	BOOL UGC_IS_CREATING();
	BOOL UGC_HAS_CREATE_FINISHED();
	BOOL UGC_DID_CREATE_SUCCEED();
	int UGC_GET_CREATE_RESULT();
	const char* UGC_GET_CREATE_CONTENT_ID();
	void UGC_CLEAR_CREATE_RESULT();
	BOOL UGC_QUERY_MY_CONTENT(Any p0, Any p1, Any* p2, Any p3, Any p4, Any p5);
	BOOL UGC_QUERY_BY_CATEGORY(Any p0, Any p1, Any p2, const char* p3, Any p4, BOOL p5);
	BOOL UGC_QUERY_BY_CONTENT_ID(const char* contentId, BOOL latestVersion, const char* contentTypeName);
	BOOL UGC_QUERY_BY_CONTENT_IDS(Any* data, int count, BOOL latestVersion, const char* contentTypeName);
	BOOL UGC_QUERY_MOST_RECENTLY_CREATED_CONTENT(int offset, int count, const char* contentTypeName, int p3);
	BOOL UGC_GET_BOOKMARKED_CONTENT(Any p0, Any p1, const char* p2, Any* p3);
	BOOL UGC_GET_MY_CONTENT(Any p0, Any p1, const char* p2, Any* p3);
	BOOL UGC_GET_FRIEND_CONTENT(Any p0, Any p1, const char* p2, Any* p3);
	BOOL UGC_GET_CREW_CONTENT(Any p0, Any p1, Any p2, const char* p3, Any* p4);
	BOOL UGC_GET_GET_BY_CATEGORY(Any p0, Any p1, Any p2, const char* p3, Any* p4);
	BOOL UGC_GET_GET_BY_CONTENT_ID(const char* contentId, const char* contentTypeName);
	BOOL UGC_GET_GET_BY_CONTENT_IDS(Any* data, int dataCount, const char* contentTypeName);
	BOOL UGC_GET_MOST_RECENTLY_CREATED_CONTENT(Any p0, Any p1, Any* p2, Any* p3);
	BOOL UGC_GET_MOST_RECENTLY_PLAYED_CONTENT(Any p0, Any p1, Any* p2, Any* p3);
	BOOL UGC_GET_TOP_RATED_CONTENT(Any p0, Any p1, Any* p2, Any* p3);
	void UGC_CANCEL_QUERY();
	BOOL UGC_IS_GETTING();
	BOOL UGC_HAS_GET_FINISHED();
	BOOL UGC_DID_GET_SUCCEED();
	BOOL UGC_WAS_QUERY_FORCE_CANCELLED();
	int UGC_GET_QUERY_RESULT();
	int UGC_GET_CONTENT_NUM();
	int UGC_GET_CONTENT_TOTAL();
	Hash UGC_GET_CONTENT_HASH();
	void UGC_CLEAR_QUERY_RESULTS();
	const char* UGC_GET_CONTENT_USER_ID(int p0);
	BOOL UGC_GET_CONTENT_CREATOR_GAMER_HANDLE(int p0, Any* p1);
	BOOL UGC_GET_CONTENT_CREATED_BY_LOCAL_PLAYER(Any p0);
	const char* UGC_GET_CONTENT_USER_NAME(Any p0);
	BOOL UGC_GET_CONTENT_IS_USING_SC_NICKNAME(Any p0);
	int UGC_GET_CONTENT_CATEGORY(int p0);
	const char* UGC_GET_CONTENT_ID(int p0);
	const char* UGC_GET_ROOT_CONTENT_ID(int p0);
	const char* UGC_GET_CONTENT_NAME(Any p0);
	int UGC_GET_CONTENT_DESCRIPTION_HASH(Any p0);
	const char* UGC_GET_CONTENT_PATH(int p0, int p1);
	void UGC_GET_CONTENT_UPDATED_DATE(Any p0, Any* p1);
	int UGC_GET_CONTENT_FILE_VERSION(Any p0, Any p1);
	BOOL UGC_GET_CONTENT_HAS_LO_RES_PHOTO(int p0);
	BOOL UGC_GET_CONTENT_HAS_HI_RES_PHOTO(int p0);
	int UGC_GET_CONTENT_LANGUAGE(Any p0);
	BOOL UGC_GET_CONTENT_IS_PUBLISHED(Any p0);
	BOOL UGC_GET_CONTENT_IS_VERIFIED(Any p0);
	float UGC_GET_CONTENT_RATING(Any p0, Any p1);
	int UGC_GET_CONTENT_RATING_COUNT(Any p0, Any p1);
	int UGC_GET_CONTENT_RATING_POSITIVE_COUNT(Any p0, Any p1);
	int UGC_GET_CONTENT_RATING_NEGATIVE_COUNT(Any p0, Any p1);
	BOOL UGC_GET_CONTENT_HAS_PLAYER_RECORD(Any p0);
	BOOL UGC_GET_CONTENT_HAS_PLAYER_BOOKMARKED(Any p0);
	int UGC_REQUEST_CONTENT_DATA_FROM_INDEX(int p0, int p1);
	int UGC_REQUEST_CONTENT_DATA_FROM_PARAMS(const char* contentTypeName, const char* contentId, int p2, int p3, int p4);
	int UGC_REQUEST_CACHED_DESCRIPTION(int p0);
	BOOL UGC_IS_DESCRIPTION_REQUEST_IN_PROGRESS(Any p0);
	BOOL UGC_HAS_DESCRIPTION_REQUEST_FINISHED(Any p0);
	BOOL UGC_DID_DESCRIPTION_REQUEST_SUCCEED(Any p0);
	const char* UGC_GET_CACHED_DESCRIPTION(Any p0, Any p1);
	BOOL UGC_RELEASE_CACHED_DESCRIPTION(Any p0);
	void UGC_RELEASE_ALL_CACHED_DESCRIPTIONS();
	BOOL UGC_PUBLISH(const char* contentId, const char* baseContentId, const char* contentTypeName);
	BOOL UGC_SET_BOOKMARKED(const char* contentId, BOOL bookmarked, const char* contentTypeName);
	BOOL UGC_SET_DELETED(Any* p0, BOOL p1, const char* p2);
	BOOL UGC_IS_MODIFYING();
	BOOL UGC_HAS_MODIFY_FINISHED();
	BOOL UGC_DID_MODIFY_SUCCEED();
	int UGC_GET_MODIFY_RESULT();
	void UGC_CLEAR_MODIFY_RESULT();
	BOOL UGC_GET_CREATORS_BY_USER_ID(Any* p0, Any* p1);
	BOOL UGC_HAS_QUERY_CREATORS_FINISHED();
	BOOL UGC_DID_QUERY_CREATORS_SUCCEED();
	int UGC_GET_CREATOR_NUM();
	BOOL UGC_LOAD_OFFLINE_QUERY(Any p0);
	void UGC_CLEAR_OFFLINE_QUERY();
	void UGC_SET_QUERY_DATA_FROM_OFFLINE(BOOL p0);
	void UGC_SET_USING_OFFLINE_CONTENT(BOOL p0);
	BOOL UGC_IS_LANGUAGE_SUPPORTED(Any p0);
	BOOL FACEBOOK_POST_COMPLETED_HEIST(const char* heistName, int cashEarned, int xpEarned);
	BOOL FACEBOOK_POST_CREATE_CHARACTER();
	BOOL FACEBOOK_POST_COMPLETED_MILESTONE(int milestoneId);
	BOOL FACEBOOK_HAS_POST_COMPLETED();
	BOOL FACEBOOK_DID_POST_SUCCEED();
	BOOL FACEBOOK_CAN_POST_TO_FACEBOOK();
	int TEXTURE_DOWNLOAD_REQUEST(Any* gamerHandle, const char* filePath, const char* name, BOOL p3);
	int TITLE_TEXTURE_DOWNLOAD_REQUEST(const char* filePath, const char* name, BOOL p2);
	int UGC_TEXTURE_DOWNLOAD_REQUEST(const char* p0, int p1, int p2, int p3, const char* p4, BOOL p5);
	void TEXTURE_DOWNLOAD_RELEASE(int p0);
	BOOL TEXTURE_DOWNLOAD_HAS_FAILED(int p0);
	const char* TEXTURE_DOWNLOAD_GET_NAME(int p0);
	int GET_STATUS_OF_TEXTURE_DOWNLOAD(int p0);
	BOOL NETWORK_CHECK_ROS_LINK_WENTDOWN_NOT_NET();
	BOOL NETWORK_SHOULD_SHOW_STRICT_NAT_WARNING();
	BOOL NETWORK_IS_CABLE_CONNECTED();
	BOOL NETWORK_HAVE_SCS_PRIVATE_MSG_PRIV();
	BOOL NETWORK_HAVE_ROS_SOCIAL_CLUB_PRIV();
	BOOL NETWORK_HAVE_ROS_BANNED_PRIV();
	BOOL NETWORK_HAVE_ROS_CREATE_TICKET_PRIV();
	BOOL NETWORK_HAVE_ROS_MULTIPLAYER_PRIV();
	BOOL NETWORK_HAVE_ROS_LEADERBOARD_WRITE_PRIV();
	BOOL NETWORK_HAS_ROS_PRIVILEGE(int index);
	BOOL NETWORK_HAS_ROS_PRIVILEGE_END_DATE(int privilege, int* banType, Any* timeData);
	BOOL NETWORK_HAS_ROS_PRIVILEGE_PLAYED_LAST_GEN();
	BOOL NETWORK_HAS_ROS_PRIVILEGE_SPECIAL_EDITION_CONTENT();
	int NETWORK_START_COMMUNICATION_PERMISSIONS_CHECK(Any p0);
	int NETWORK_START_USER_CONTENT_PERMISSIONS_CHECK(Any* netHandle);
	void NETWORK_SKIP_RADIO_RESET_NEXT_CLOSE();
	void NETWORK_SKIP_RADIO_RESET_NEXT_OPEN();
	BOOL NETWORK_SKIP_RADIO_WARNING();
	void NETWORK_FORCE_LOCAL_PLAYER_SCAR_SYNC();
	void NETWORK_DISABLE_LEAVE_REMOTE_PED_BEHIND(BOOL toggle);
	void NETWORK_ALLOW_REMOTE_ATTACHMENT_MODIFICATION(Entity entity, BOOL toggle);
	void NETWORK_SHOW_CHAT_RESTRICTION_MSC(Player player);
	void NETWORK_SHOW_PSN_UGC_RESTRICTION();
	BOOL NETWORK_IS_TITLE_UPDATE_REQUIRED();
	void NETWORK_QUIT_MP_TO_DESKTOP();
	BOOL NETWORK_IS_CONNECTED_VIA_RELAY(Player player);
	float NETWORK_GET_AVERAGE_LATENCY(Player player);
	float NETWORK_GET_AVERAGE_PING(Player player);
	float NETWORK_GET_AVERAGE_PACKET_LOSS(Player player);
	int NETWORK_GET_NUM_UNACKED_RELIABLES(Player player);
	int NETWORK_GET_UNRELIABLE_RESEND_COUNT(Player player);
	int NETWORK_GET_HIGHEST_RELIABLE_RESEND_COUNT(Player player);
	void NETWORK_REPORT_CODE_TAMPER();
	Vector3 NETWORK_GET_LAST_ENTITY_POS_RECEIVED_OVER_NETWORK(Entity entity);
	Vector3 NETWORK_GET_LAST_PLAYER_POS_RECEIVED_OVER_NETWORK(Player player);
	Vector3 NETWORK_GET_LAST_VEL_RECEIVED_OVER_NETWORK(Entity entity);
	Vector3 NETWORK_GET_PREDICTED_VELOCITY(Entity entity);
	void NETWORK_DUMP_NET_IF_CONFIG();
	void NETWORK_GET_SIGNALLING_INFO(Any* p0);
	void NETWORK_GET_NET_STATISTICS_INFO(Any* p0);
	int NETWORK_GET_PLAYER_ACCOUNT_ID(Player player);
	void NETWORK_UGC_NAV(Any p0, Any p1);
}

namespace OBJECT
{
	Object CREATE_OBJECT(Hash modelHash, float x, float y, float z, BOOL isNetwork, BOOL bScriptHostObj, BOOL dynamic);
	Object CREATE_OBJECT_NO_OFFSET(Hash modelHash, float x, float y, float z, BOOL isNetwork, BOOL bScriptHostObj, BOOL dynamic);
	void DELETE_OBJECT(Object* object);
	BOOL PLACE_OBJECT_ON_GROUND_PROPERLY(Object object);
	BOOL PLACE_OBJECT_ON_GROUND_OR_OBJECT_PROPERLY(Object object);
	BOOL ROTATE_OBJECT(Object object, float p1, float p2, BOOL p3);
	BOOL SLIDE_OBJECT(Object object, float toX, float toY, float toZ, float speedX, float speedY, float speedZ, BOOL collision);
	void SET_OBJECT_TARGETTABLE(Object object, BOOL targettable);
	void SET_OBJECT_FORCE_VEHICLES_TO_AVOID(Object object, BOOL toggle);
	Object GET_CLOSEST_OBJECT_OF_TYPE(float x, float y, float z, float radius, Hash modelHash, BOOL isMission, BOOL p6, BOOL p7);
	BOOL HAS_OBJECT_BEEN_BROKEN(Object object, Any p1);
	BOOL HAS_CLOSEST_OBJECT_OF_TYPE_BEEN_BROKEN(float p0, float p1, float p2, float p3, Hash modelHash, Any p5);
	BOOL HAS_CLOSEST_OBJECT_OF_TYPE_BEEN_COMPLETELY_DESTROYED(float x, float y, float z, float radius, Hash modelHash, BOOL p5);
	BOOL GET_HAS_OBJECT_BEEN_COMPLETELY_DESTROYED(Any p0);
	Vector3 GET_OFFSET_FROM_COORD_AND_HEADING_IN_WORLD_COORDS(float xPos, float yPos, float zPos, float heading, float xOffset, float yOffset, float zOffset);
	BOOL GET_COORDS_AND_ROTATION_OF_CLOSEST_OBJECT_OF_TYPE(float x, float y, float z, float radius, Hash modelHash, Vector3* outPosition, Vector3* outRotation, int rotationOrder);
	void SET_STATE_OF_CLOSEST_DOOR_OF_TYPE(Hash type, float x, float y, float z, BOOL locked, float heading, BOOL p6);
	void GET_STATE_OF_CLOSEST_DOOR_OF_TYPE(Hash type, float x, float y, float z, BOOL* locked, float* heading);
	void SET_LOCKED_UNSTREAMED_IN_DOOR_OF_TYPE(Hash modelHash, float x, float y, float z, BOOL locked, float xRotMult, float yRotMult, float zRotMult);
	void PLAY_OBJECT_AUTO_START_ANIM(Any p0);
	void ADD_DOOR_TO_SYSTEM(Hash doorHash, Hash modelHash, float x, float y, float z, BOOL p5, BOOL scriptDoor, BOOL isLocal);
	void REMOVE_DOOR_FROM_SYSTEM(Hash doorHash, Any p1);
	void DOOR_SYSTEM_SET_DOOR_STATE(Hash doorHash, int state, BOOL requestDoor, BOOL forceUpdate);
	int DOOR_SYSTEM_GET_DOOR_STATE(Hash doorHash);
	int DOOR_SYSTEM_GET_DOOR_PENDING_STATE(Hash doorHash);
	void DOOR_SYSTEM_SET_AUTOMATIC_RATE(Hash doorHash, float rate, BOOL requestDoor, BOOL forceUpdate);
	void DOOR_SYSTEM_SET_AUTOMATIC_DISTANCE(Hash doorHash, float distance, BOOL requestDoor, BOOL forceUpdate);
	void DOOR_SYSTEM_SET_OPEN_RATIO(Hash doorHash, float ajar, BOOL requestDoor, BOOL forceUpdate);
	float DOOR_SYSTEM_GET_AUTOMATIC_DISTANCE(Hash doorHash);
	float DOOR_SYSTEM_GET_OPEN_RATIO(Hash doorHash);
	void DOOR_SYSTEM_SET_SPRING_REMOVED(Hash doorHash, BOOL removed, BOOL requestDoor, BOOL forceUpdate);
	void DOOR_SYSTEM_SET_HOLD_OPEN(Hash doorHash, BOOL toggle);
	void DOOR_SYSTEM_SET_DOOR_OPEN_FOR_RACES(Hash doorHash, BOOL p1);
	BOOL IS_DOOR_REGISTERED_WITH_SYSTEM(Hash doorHash);
	BOOL IS_DOOR_CLOSED(Hash doorHash);
	void OPEN_ALL_BARRIERS_FOR_RACE(BOOL p0);
	void CLOSE_ALL_BARRIERS_FOR_RACE();
	BOOL DOOR_SYSTEM_GET_IS_PHYSICS_LOADED(Any p0);
	BOOL DOOR_SYSTEM_FIND_EXISTING_DOOR(float x, float y, float z, Hash modelHash, Hash* outDoorHash);
	BOOL IS_GARAGE_EMPTY(Hash garageHash, BOOL p1, int p2);
	BOOL IS_PLAYER_ENTIRELY_INSIDE_GARAGE(Hash garageHash, Player player, float p2, int p3);
	BOOL IS_PLAYER_PARTIALLY_INSIDE_GARAGE(Hash garageHash, Player player, int p2);
	BOOL ARE_ENTITIES_ENTIRELY_INSIDE_GARAGE(Hash garageHash, BOOL p1, BOOL p2, BOOL p3, Any p4);
	BOOL IS_ANY_ENTITY_ENTIRELY_INSIDE_GARAGE(Hash garageHash, BOOL p1, BOOL p2, BOOL p3, Any p4);
	BOOL IS_OBJECT_ENTIRELY_INSIDE_GARAGE(Hash garageHash, Entity entity, float p2, int p3);
	BOOL IS_OBJECT_PARTIALLY_INSIDE_GARAGE(Hash garageHash, Entity entity, int p2);
	void CLEAR_GARAGE(Hash garageHash, BOOL isNetwork);
	void CLEAR_OBJECTS_INSIDE_GARAGE(Hash garageHash, BOOL vehicles, BOOL peds, BOOL objects, BOOL isNetwork);
	void DISABLE_TIDYING_UP_IN_GARAGE(int id, BOOL toggle);
	void ENABLE_SAVING_IN_GARAGE(Hash garageHash, BOOL toggle);
	void CLOSE_SAFEHOUSE_GARAGES();
	BOOL DOES_OBJECT_OF_TYPE_EXIST_AT_COORDS(float x, float y, float z, float radius, Hash hash, BOOL p5);
	BOOL IS_POINT_IN_ANGLED_AREA(float xPos, float yPos, float zPos, float x1, float y1, float z1, float x2, float y2, float z2, float width, BOOL debug, BOOL includeZ);
	void SET_OBJECT_ALLOW_LOW_LOD_BUOYANCY(Object object, BOOL toggle);
	void SET_OBJECT_PHYSICS_PARAMS(Object object, float weight, float p2, float p3, float p4, float p5, float gravity, float p7, float p8, float p9, float p10, float buoyancy);
	float GET_OBJECT_FRAGMENT_DAMAGE_HEALTH(Any p0, BOOL p1);
	void SET_ACTIVATE_OBJECT_PHYSICS_AS_SOON_AS_IT_IS_UNFROZEN(Object object, BOOL toggle);
	BOOL IS_ANY_OBJECT_NEAR_POINT(float x, float y, float z, float range, BOOL p4);
	BOOL IS_OBJECT_NEAR_POINT(Hash objectHash, float x, float y, float z, float range);
	void REMOVE_OBJECT_HIGH_DETAIL_MODEL(Object object);
	void BREAK_OBJECT_FRAGMENT_CHILD(Object p0, Any p1, BOOL p2);
	void DAMAGE_OBJECT_FRAGMENT_CHILD(Any p0, Any p1, Any p2);
	void FIX_OBJECT_FRAGMENT(Object object);
	void TRACK_OBJECT_VISIBILITY(Object object);
	BOOL IS_OBJECT_VISIBLE(Object object);
	void SET_OBJECT_IS_SPECIAL_GOLFBALL(Object object, BOOL toggle);
	void SET_OBJECT_TAKES_DAMAGE_FROM_COLLIDING_WITH_BUILDINGS(Any p0, BOOL p1);
	void ALLOW_DAMAGE_EVENTS_FOR_NON_NETWORKED_OBJECTS(BOOL value);
	void SET_CUTSCENES_WEAPON_FLASHLIGHT_ON_THIS_FRAME(Object object, BOOL toggle);
	Object GET_RAYFIRE_MAP_OBJECT(float x, float y, float z, float radius, const char* name);
	void SET_STATE_OF_RAYFIRE_MAP_OBJECT(Object object, int state);
	int GET_STATE_OF_RAYFIRE_MAP_OBJECT(Object object);
	BOOL DOES_RAYFIRE_MAP_OBJECT_EXIST(Object object);
	float GET_RAYFIRE_MAP_OBJECT_ANIM_PHASE(Object object);
	Pickup CREATE_PICKUP(Hash pickupHash, float posX, float posY, float posZ, int p4, int value, BOOL p6, Hash modelHash);
	Pickup CREATE_PICKUP_ROTATE(Hash pickupHash, float posX, float posY, float posZ, float rotX, float rotY, float rotZ, int flag, int amount, Any p9, BOOL p10, Hash modelHash);
	void FORCE_PICKUP_ROTATE_FACE_UP();
	void SET_CUSTOM_PICKUP_WEAPON_HASH(Hash pickupHash, Pickup pickup);
	Object CREATE_AMBIENT_PICKUP(Hash pickupHash, float posX, float posY, float posZ, int flags, int value, Hash modelHash, BOOL p7, BOOL p8);
	Object CREATE_NON_NETWORKED_AMBIENT_PICKUP(Hash pickupHash, float posX, float posY, float posZ, int flags, int value, Hash modelHash, BOOL p7, BOOL p8);
	void BLOCK_PLAYERS_FOR_AMBIENT_PICKUP(Any p0, Any p1);
	Object CREATE_PORTABLE_PICKUP(Hash pickupHash, float x, float y, float z, BOOL placeOnGround, Hash modelHash);
	Object CREATE_NON_NETWORKED_PORTABLE_PICKUP(Hash pickupHash, float x, float y, float z, BOOL placeOnGround, Hash modelHash);
	void ATTACH_PORTABLE_PICKUP_TO_PED(Object pickupObject, Ped ped);
	void DETACH_PORTABLE_PICKUP_FROM_PED(Object pickupObject);
	void FORCE_PORTABLE_PICKUP_LAST_ACCESSIBLE_POSITION_SETTING(Object object);
	void HIDE_PORTABLE_PICKUP_WHEN_DETACHED(Object pickupObject, BOOL toggle);
	void SET_MAX_NUM_PORTABLE_PICKUPS_CARRIED_BY_PLAYER(Hash modelHash, int number);
	void SET_LOCAL_PLAYER_CAN_COLLECT_PORTABLE_PICKUPS(BOOL toggle);
	Vector3 GET_SAFE_PICKUP_COORDS(float x, float y, float z, float p3, float p4);
	void ADD_EXTENDED_PICKUP_PROBE_AREA(float x, float y, float z, float radius);
	void CLEAR_EXTENDED_PICKUP_PROBE_AREAS();
	Vector3 GET_PICKUP_COORDS(Pickup pickup);
	void SUPPRESS_PICKUP_SOUND_FOR_PICKUP(Any p0, Any p1);
	void REMOVE_ALL_PICKUPS_OF_TYPE(Hash pickupHash);
	BOOL HAS_PICKUP_BEEN_COLLECTED(Pickup pickup);
	void REMOVE_PICKUP(Pickup pickup);
	void CREATE_MONEY_PICKUPS(float x, float y, float z, int value, int amount, Hash model);
	BOOL DOES_PICKUP_EXIST(Pickup pickup);
	BOOL DOES_PICKUP_OBJECT_EXIST(Object pickupObject);
	Object GET_PICKUP_OBJECT(Pickup pickup);
	BOOL IS_OBJECT_A_PICKUP(Object object);
	BOOL IS_OBJECT_A_PORTABLE_PICKUP(Object object);
	BOOL DOES_PICKUP_OF_TYPE_EXIST_IN_AREA(Hash pickupHash, float x, float y, float z, float radius);
	void SET_PICKUP_REGENERATION_TIME(Pickup pickup, int duration);
	void FORCE_PICKUP_REGENERATE(Any p0);
	void SET_PLAYER_PERMITTED_TO_COLLECT_PICKUPS_OF_TYPE(Player player, Hash pickupHash, BOOL toggle);
	void SET_LOCAL_PLAYER_PERMITTED_TO_COLLECT_PICKUPS_WITH_MODEL(Hash modelHash, BOOL toggle);
	void ALLOW_ALL_PLAYERS_TO_COLLECT_PICKUPS_OF_TYPE(Hash pickupHash);
	void SET_TEAM_PICKUP_OBJECT(Object object, Any p1, BOOL p2);
	void PREVENT_COLLECTION_OF_PORTABLE_PICKUP(Object object, BOOL p1, BOOL p2);
	void SET_PICKUP_OBJECT_GLOW_WHEN_UNCOLLECTABLE(Pickup pickup, BOOL toggle);
	void SET_PICKUP_GLOW_OFFSET(Pickup pickup, float p1);
	void SET_PICKUP_OBJECT_GLOW_OFFSET(Pickup pickup, float p1, BOOL p2);
	void SET_OBJECT_GLOW_IN_SAME_TEAM(Pickup pickup);
	void SET_PICKUP_OBJECT_ARROW_MARKER(Pickup pickup, BOOL toggle);
	void ALLOW_PICKUP_ARROW_MARKER_WHEN_UNCOLLECTABLE(Pickup pickup, BOOL toggle);
	int GET_DEFAULT_AMMO_FOR_WEAPON_PICKUP(Hash pickupHash);
	void SET_PICKUP_GENERATION_RANGE_MULTIPLIER(float multiplier);
	float GET_PICKUP_GENERATION_RANGE_MULTIPLIER();
	void SET_ONLY_ALLOW_AMMO_COLLECTION_WHEN_LOW(BOOL p0);
	void SET_PICKUP_UNCOLLECTABLE(Pickup pickup, BOOL toggle);
	void SET_PICKUP_TRANSPARENT_WHEN_UNCOLLECTABLE(Pickup pickup, BOOL toggle);
	void SET_PICKUP_HIDDEN_WHEN_UNCOLLECTABLE(Pickup pickup, BOOL toggle);
	void SET_PICKUP_OBJECT_TRANSPARENT_WHEN_UNCOLLECTABLE(Pickup pickup, BOOL toggle);
	void SET_PICKUP_OBJECT_ALPHA_WHEN_TRANSPARENT(int p0);
	void SET_PORTABLE_PICKUP_PERSIST(Pickup pickup, BOOL toggle);
	void ALLOW_PORTABLE_PICKUP_TO_MIGRATE_TO_NON_PARTICIPANTS(Pickup pickup, BOOL toggle);
	void FORCE_ACTIVATE_PHYSICS_ON_UNFIXED_PICKUP(Pickup pickup, BOOL toggle);
	void ALLOW_PICKUP_BY_NONE_PARTICIPANT(Pickup pickup, BOOL toggle);
	void SUPPRESS_PICKUP_REWARD_TYPE(int rewardType, BOOL suppress);
	void CLEAR_ALL_PICKUP_REWARD_TYPE_SUPPRESSION();
	void CLEAR_PICKUP_REWARD_TYPE_SUPPRESSION(int rewardType);
	void RENDER_FAKE_PICKUP_GLOW(float x, float y, float z, int colorIndex);
	void SET_PICKUP_OBJECT_COLLECTABLE_IN_VEHICLE(Pickup pickup);
	void SET_PICKUP_TRACK_DAMAGE_EVENTS(Pickup pickup, BOOL toggle);
	void SET_ENTITY_FLAG_SUPPRESS_SHADOW(Entity entity, BOOL toggle);
	void SET_ENTITY_FLAG_RENDER_SMALL_SHADOW(Object object, BOOL toggle);
	Hash GET_WEAPON_TYPE_FROM_PICKUP_TYPE(Hash pickupHash);
	Hash GET_PICKUP_TYPE_FROM_WEAPON_HASH(Hash weaponHash);
	BOOL IS_PICKUP_WEAPON_OBJECT_VALID(Object object);
	int GET_OBJECT_TINT_INDEX(Object object);
	void SET_OBJECT_TINT_INDEX(Object object, int textureVariation);
	BOOL SET_TINT_INDEX_CLOSEST_BUILDING_OF_TYPE(float x, float y, float z, float radius, Hash modelHash, int textureVariation);
	void SET_PROP_TINT_INDEX(Any p0, Any p1);
	BOOL SET_PROP_LIGHT_COLOR(Object object, BOOL p1, int r, int g, int b);
	BOOL IS_PROP_LIGHT_OVERRIDEN(Object object);
	void SET_OBJECT_IS_VISIBLE_IN_MIRRORS(Object object, BOOL toggle);
	void SET_OBJECT_SPEED_BOOST_AMOUNT(Object object, Any p1);
	void SET_OBJECT_SPEED_BOOST_DURATION(Object object, float duration);
	Hash CONVERT_OLD_PICKUP_TYPE_TO_NEW(Hash pickupHash);
	void SET_FORCE_OBJECT_THIS_FRAME(float x, float y, float z, float p3);
	void ONLY_CLEAN_UP_OBJECT_WHEN_OUT_OF_RANGE(Object object);
	void SET_DISABLE_COLLISIONS_BETWEEN_CARS_AND_CAR_PARACHUTE(Any p0);
	void SET_PROJECTILES_SHOULD_EXPLODE_ON_CONTACT(Entity entity, Any p1);
	void SET_DRIVE_ARTICULATED_JOINT(Object object, BOOL toggle, int p2);
	void SET_DRIVE_ARTICULATED_JOINT_WITH_INFLICTOR(Object object, BOOL toggle, int p2, Ped ped);
	void SET_OBJECT_IS_A_PRESSURE_PLATE(Object object, BOOL toggle);
	void SET_WEAPON_IMPACTS_APPLY_GREATER_FORCE(Object object, BOOL p1);
	BOOL GET_IS_ARTICULATED_JOINT_AT_MIN_ANGLE(Object object, Any p1);
	BOOL GET_IS_ARTICULATED_JOINT_AT_MAX_ANGLE(Any p0, Any p1);
	void SET_IS_OBJECT_ARTICULATED(Object object, BOOL toggle);
	void SET_IS_OBJECT_BALL(Object object, BOOL toggle);
}

namespace PAD
{
	BOOL IS_CONTROL_ENABLED(int control, int action);
	BOOL IS_CONTROL_PRESSED(int control, int action);
	BOOL IS_CONTROL_RELEASED(int control, int action);
	BOOL IS_CONTROL_JUST_PRESSED(int control, int action);
	BOOL IS_CONTROL_JUST_RELEASED(int control, int action);
	int GET_CONTROL_VALUE(int control, int action);
	float GET_CONTROL_NORMAL(int control, int action);
	void SET_USE_ADJUSTED_MOUSE_COORDS(BOOL toggle);
	float GET_CONTROL_UNBOUND_NORMAL(int control, int action);
	BOOL SET_CONTROL_VALUE_NEXT_FRAME(int control, int action, float value);
	BOOL IS_DISABLED_CONTROL_PRESSED(int control, int action);
	BOOL IS_DISABLED_CONTROL_RELEASED(int control, int action);
	BOOL IS_DISABLED_CONTROL_JUST_PRESSED(int control, int action);
	BOOL IS_DISABLED_CONTROL_JUST_RELEASED(int control, int action);
	float GET_DISABLED_CONTROL_NORMAL(int control, int action);
	float GET_DISABLED_CONTROL_UNBOUND_NORMAL(int control, int action);
	int GET_CONTROL_HOW_LONG_AGO(int control);
	BOOL IS_USING_KEYBOARD_AND_MOUSE(int control);
	BOOL IS_USING_CURSOR(int control);
	BOOL SET_CURSOR_POSITION(float x, float y);
	BOOL IS_USING_REMOTE_PLAY(int control);
	BOOL HAVE_CONTROLS_CHANGED(int control);
	const char* GET_CONTROL_INSTRUCTIONAL_BUTTONS_STRING(int control, int action, BOOL allowXOSwap);
	const char* GET_CONTROL_GROUP_INSTRUCTIONAL_BUTTONS_STRING(int control, int controlGroup, BOOL allowXOSwap);
	void SET_CONTROL_LIGHT_EFFECT_COLOR(int control, int red, int green, int blue);
	void CLEAR_CONTROL_LIGHT_EFFECT(int control);
	void SET_CONTROL_SHAKE(int control, int duration, int frequency);
	void SET_CONTROL_TRIGGER_SHAKE(int control, int leftDuration, int leftFrequency, int rightDuration, int rightFrequency);
	void STOP_CONTROL_SHAKE(int control);
	void SET_CONTROL_SHAKE_SUPPRESSED_ID(int control, int uniqueId);
	void CLEAR_CONTROL_SHAKE_SUPPRESSED_ID(int control);
	BOOL IS_LOOK_INVERTED();
	BOOL IS_MOUSE_LOOK_INVERTED();
	int GET_LOCAL_PLAYER_AIM_STATE();
	int GET_LOCAL_PLAYER_GAMEPAD_AIM_STATE();
	BOOL GET_IS_USING_ALTERNATE_HANDBRAKE();
	BOOL GET_IS_USING_ALTERNATE_DRIVEBY();
	BOOL GET_ALLOW_MOVEMENT_WHILE_ZOOMED();
	void SET_PLAYERPAD_SHAKES_WHEN_CONTROLLER_DISABLED(BOOL toggle);
	void SET_INPUT_EXCLUSIVE(int control, int action);
	void DISABLE_CONTROL_ACTION(int control, int action, BOOL disableRelatedActions);
	void ENABLE_CONTROL_ACTION(int control, int action, BOOL enableRelatedActions);
	void DISABLE_ALL_CONTROL_ACTIONS(int control);
	void ENABLE_ALL_CONTROL_ACTIONS(int control);
	BOOL INIT_PC_SCRIPTED_CONTROLS(const char* schemeName);
	BOOL SWITCH_PC_SCRIPTED_CONTROLS(const char* schemeName);
	void SHUTDOWN_PC_SCRIPTED_CONTROLS();
	void ALLOW_ALTERNATIVE_SCRIPT_CONTROLS_LAYOUT(int control);
}

namespace PATHFIND
{
	void SET_ROADS_IN_AREA(float x1, float y1, float z1, float x2, float y2, float z2, BOOL nodeEnabled, BOOL unknown2);
	void SET_ROADS_IN_ANGLED_AREA(float x1, float y1, float z1, float x2, float y2, float z2, float width, BOOL unknown1, BOOL unknown2, BOOL unknown3);
	void SET_PED_PATHS_IN_AREA(float x1, float y1, float z1, float x2, float y2, float z2, BOOL p6, Any p7);
	BOOL GET_SAFE_COORD_FOR_PED(float x, float y, float z, BOOL onGround, Vector3* outPosition, int flags);
	BOOL GET_CLOSEST_VEHICLE_NODE(float x, float y, float z, Vector3* outPosition, int nodeFlags, float p5, float p6);
	BOOL GET_CLOSEST_MAJOR_VEHICLE_NODE(float x, float y, float z, Vector3* outPosition, float unknown1, float unknown2);
	BOOL GET_CLOSEST_VEHICLE_NODE_WITH_HEADING(float x, float y, float z, Vector3* outPosition, float* outHeading, int nodeType, float p6, float p7);
	BOOL GET_NTH_CLOSEST_VEHICLE_NODE(float x, float y, float z, int nthClosest, Vector3* outPosition, int nodeFlags, float unknown1, float unknown2);
	int GET_NTH_CLOSEST_VEHICLE_NODE_ID(float x, float y, float z, int nth, int nodeFlags, float p5, float p6);
	BOOL GET_NTH_CLOSEST_VEHICLE_NODE_WITH_HEADING(float x, float y, float z, int nthClosest, Vector3* outPosition, float* outHeading, int* outNumLanes, int nodeFlags, float unknown3, float unknown4);
	int GET_NTH_CLOSEST_VEHICLE_NODE_ID_WITH_HEADING(float x, float y, float z, int nthClosest, Vector3* outPosition, float* outHeading, int nodeFlags, float p7, float p8);
	BOOL GET_NTH_CLOSEST_VEHICLE_NODE_FAVOUR_DIRECTION(float x, float y, float z, float desiredX, float desiredY, float desiredZ, int nthClosest, Vector3* outPosition, float* outHeading, int nodeFlags, float p10, float p11);
	BOOL GET_VEHICLE_NODE_PROPERTIES(float x, float y, float z, int* density, int* flags);
	BOOL IS_VEHICLE_NODE_ID_VALID(int vehicleNodeId);
	void GET_VEHICLE_NODE_POSITION(int nodeId, Vector3* outPosition);
	BOOL GET_VEHICLE_NODE_IS_GPS_ALLOWED(int nodeID);
	BOOL GET_VEHICLE_NODE_IS_SWITCHED_OFF(int nodeID);
	BOOL GET_CLOSEST_ROAD(float x, float y, float z, float p3, int p4, Vector3* p5, Vector3* p6, Any* p7, Any* p8, float* p9, BOOL p10);
	BOOL LOAD_ALL_PATH_NODES(BOOL set);
	void SET_ALLOW_STREAM_PROLOGUE_NODES(BOOL toggle);
	void SET_ALLOW_STREAM_HEIST_ISLAND_NODES(int type);
	BOOL ARE_NODES_LOADED_FOR_AREA(float x1, float y1, float x2, float y2);
	BOOL REQUEST_PATH_NODES_IN_AREA_THIS_FRAME(float x1, float y1, float x2, float y2);
	void SET_ROADS_BACK_TO_ORIGINAL(float p0, float p1, float p2, float p3, float p4, float p5, Any p6);
	void SET_ROADS_BACK_TO_ORIGINAL_IN_ANGLED_AREA(float x1, float y1, float z1, float x2, float y2, float z2, float width, Any p7);
	void SET_AMBIENT_PED_RANGE_MULTIPLIER_THIS_FRAME(float multiplier);
	void ADJUST_AMBIENT_PED_SPAWN_DENSITIES_THIS_FRAME(Any p0, Any p1, Any p2, Any p3, Any p4, Any p5, Any p6);
	void SET_PED_PATHS_BACK_TO_ORIGINAL(float x1, float y1, float z1, float x2, float y2, float z2, Any p6);
	BOOL GET_RANDOM_VEHICLE_NODE(float x, float y, float z, float radius, BOOL p4, BOOL p5, BOOL p6, Vector3* outPosition, int* nodeId);
	Vector3 GET_SPAWN_COORDS_FOR_VEHICLE_NODE(int nodeAddress, float towardsCoorsX, float towardsCoorsY, float towardsCoorsZ, Vector3* centrePoint, float* heading);
	void GET_STREET_NAME_AT_COORD(float x, float y, float z, Hash* streetName, Hash* crossingRoad);
	int GENERATE_DIRECTIONS_TO_COORD(float x, float y, float z, BOOL p3, int* direction, float* p5, float* distToNxJunction);
	void SET_IGNORE_NO_GPS_FLAG(BOOL toggle);
	void SET_IGNORE_NO_GPS_FLAG_UNTIL_FIRST_NORMAL_NODE(BOOL toggle);
	void SET_GPS_DISABLED_ZONE(float x1, float y1, float z1, float x2, float y2, float z3);
	int GET_GPS_BLIP_ROUTE_LENGTH();
	BOOL GET_POS_ALONG_GPS_TYPE_ROUTE(Vector3* result, BOOL p1, float p2, int p3);
	BOOL GET_GPS_BLIP_ROUTE_FOUND();
	BOOL GET_ROAD_BOUNDARY_USING_HEADING(float x, float y, float z, float heading, Vector3* outPosition);
	BOOL GET_POSITION_BY_SIDE_OF_ROAD(float x, float y, float z, int p3, Vector3* outPosition);
	BOOL IS_POINT_ON_ROAD(float x, float y, float z, Vehicle vehicle);
	int GET_NEXT_GPS_DISABLED_ZONE_INDEX();
	void SET_GPS_DISABLED_ZONE_AT_INDEX(float x1, float y1, float z1, float x2, float y2, float z2, int index);
	void CLEAR_GPS_DISABLED_ZONE_AT_INDEX(int index);
	void ADD_NAVMESH_REQUIRED_REGION(float x, float y, float radius);
	void REMOVE_NAVMESH_REQUIRED_REGIONS();
	BOOL IS_NAVMESH_REQUIRED_REGION_IN_USE();
	void DISABLE_NAVMESH_IN_AREA(float x1, float y1, float z1, float x2, float y2, float z2, BOOL toggle);
	BOOL ARE_ALL_NAVMESH_REGIONS_LOADED();
	BOOL IS_NAVMESH_LOADED_IN_AREA(float x1, float y1, float z1, float x2, float y2, float z2);
	int GET_NUM_NAVMESHES_EXISTING_IN_AREA(float x1, float y1, float z1, float x2, float y2, float z2);
	int ADD_NAVMESH_BLOCKING_OBJECT(float p0, float p1, float p2, float p3, float p4, float p5, float p6, BOOL p7, Any p8);
	void UPDATE_NAVMESH_BLOCKING_OBJECT(Any p0, float p1, float p2, float p3, float p4, float p5, float p6, float p7, Any p8);
	void REMOVE_NAVMESH_BLOCKING_OBJECT(Any p0);
	BOOL DOES_NAVMESH_BLOCKING_OBJECT_EXIST(Any p0);
	float GET_APPROX_HEIGHT_FOR_POINT(float x, float y);
	float GET_APPROX_HEIGHT_FOR_AREA(float x1, float y1, float x2, float y2);
	float GET_APPROX_FLOOR_FOR_POINT(float x, float y);
	float GET_APPROX_FLOOR_FOR_AREA(float x1, float y1, float x2, float y2);
	float CALCULATE_TRAVEL_DISTANCE_BETWEEN_POINTS(float x1, float y1, float z1, float x2, float y2, float z2);
}

namespace PED
{
	Ped CREATE_PED(int pedType, Hash modelHash, float x, float y, float z, float heading, BOOL isNetwork, BOOL bScriptHostPed);
	void DELETE_PED(Ped* ped);
	Ped CLONE_PED(Ped ped, BOOL isNetwork, BOOL bScriptHostPed, BOOL copyHeadBlendFlag);
	Ped CLONE_PED_ALT(Ped ped, BOOL isNetwork, BOOL bScriptHostPed, BOOL copyHeadBlendFlag, BOOL p4);
	void CLONE_PED_TO_TARGET(Ped ped, Ped targetPed);
	void CLONE_PED_TO_TARGET_ALT(Ped ped, Ped targetPed, BOOL p2);
	BOOL IS_PED_IN_VEHICLE(Ped ped, Vehicle vehicle, BOOL atGetIn);
	BOOL IS_PED_IN_MODEL(Ped ped, Hash modelHash);
	BOOL IS_PED_IN_ANY_VEHICLE(Ped ped, BOOL atGetIn);
	BOOL IS_COP_PED_IN_AREA_3D(float x1, float y1, float z1, float x2, float y2, float z2);
	BOOL IS_PED_INJURED(Ped ped);
	BOOL IS_PED_HURT(Ped ped);
	BOOL IS_PED_FATALLY_INJURED(Ped ped);
	BOOL IS_PED_DEAD_OR_DYING(Ped ped, BOOL p1);
	BOOL IS_CONVERSATION_PED_DEAD(Ped ped);
	BOOL IS_PED_AIMING_FROM_COVER(Ped ped);
	BOOL IS_PED_RELOADING(Ped ped);
	BOOL IS_PED_A_PLAYER(Ped ped);
	Ped CREATE_PED_INSIDE_VEHICLE(Vehicle vehicle, int pedType, Hash modelHash, int seat, BOOL isNetwork, BOOL bScriptHostPed);
	void SET_PED_DESIRED_HEADING(Ped ped, float heading);
	void FORCE_ALL_HEADING_VALUES_TO_ALIGN(Ped ped);
	BOOL IS_PED_FACING_PED(Ped ped, Ped otherPed, float angle);
	BOOL IS_PED_IN_MELEE_COMBAT(Ped ped);
	BOOL IS_PED_STOPPED(Ped ped);
	BOOL IS_PED_SHOOTING_IN_AREA(Ped ped, float x1, float y1, float z1, float x2, float y2, float z2, BOOL p7, BOOL p8);
	BOOL IS_ANY_PED_SHOOTING_IN_AREA(float x1, float y1, float z1, float x2, float y2, float z2, BOOL p6, BOOL p7);
	BOOL IS_PED_SHOOTING(Ped ped);
	void SET_PED_ACCURACY(Ped ped, int accuracy);
	int GET_PED_ACCURACY(Ped ped);
	void SET_AMBIENT_LAW_PED_ACCURACY_MODIFIER(float multiplier);
	BOOL IS_PED_MODEL(Ped ped, Hash modelHash);
	void EXPLODE_PED_HEAD(Ped ped, Hash weaponHash);
	void REMOVE_PED_ELEGANTLY(Ped* ped);
	void ADD_ARMOUR_TO_PED(Ped ped, int amount);
	void SET_PED_ARMOUR(Ped ped, int amount);
	void SET_PED_INTO_VEHICLE(Ped ped, Vehicle vehicle, int seatIndex);
	void SET_PED_ALLOW_VEHICLES_OVERRIDE(Ped ped, BOOL toggle);
	BOOL CAN_CREATE_RANDOM_PED(BOOL p0);
	Ped CREATE_RANDOM_PED(float posX, float posY, float posZ);
	Ped CREATE_RANDOM_PED_AS_DRIVER(Vehicle vehicle, BOOL returnHandle);
	BOOL CAN_CREATE_RANDOM_DRIVER();
	BOOL CAN_CREATE_RANDOM_BIKE_RIDER();
	void SET_PED_MOVE_ANIMS_BLEND_OUT(Ped ped);
	void SET_PED_CAN_BE_DRAGGED_OUT(Ped ped, BOOL toggle);
	void SET_PED_ALLOW_HURT_COMBAT_FOR_ALL_MISSION_PEDS(BOOL toggle);
	BOOL IS_PED_MALE(Ped ped);
	BOOL IS_PED_HUMAN(Ped ped);
	Vehicle GET_VEHICLE_PED_IS_IN(Ped ped, BOOL includeEntering);
	void RESET_PED_LAST_VEHICLE(Ped ped);
	void SET_PED_DENSITY_MULTIPLIER_THIS_FRAME(float multiplier);
	void SET_SCENARIO_PED_DENSITY_MULTIPLIER_THIS_FRAME(float p0, float p1);
	void SUPPRESS_AMBIENT_PED_AGGRESSIVE_CLEANUP_THIS_FRAME();
	void SET_SCRIPTED_CONVERSION_COORD_THIS_FRAME(float x, float y, float z);
	void SET_PED_NON_CREATION_AREA(float x1, float y1, float z1, float x2, float y2, float z2);
	void CLEAR_PED_NON_CREATION_AREA();
	void INSTANTLY_FILL_PED_POPULATION();
	BOOL IS_PED_ON_MOUNT(Ped ped);
	Ped GET_MOUNT(Ped ped);
	BOOL IS_PED_ON_VEHICLE(Ped ped);
	BOOL IS_PED_ON_SPECIFIC_VEHICLE(Ped ped, Vehicle vehicle);
	void SET_PED_MONEY(Ped ped, int amount);
	int GET_PED_MONEY(Ped ped);
	void SET_HEALTH_SNACKS_CARRIED_BY_ALL_NEW_PEDS(float p0, Any p1);
	void SET_AMBIENT_PEDS_DROP_MONEY(BOOL p0);
	void SET_BLOCKING_OF_NON_TEMPORARY_EVENTS_FOR_AMBIENT_PEDS_THIS_FRAME(BOOL p0);
	void SET_PED_SUFFERS_CRITICAL_HITS(Ped ped, BOOL toggle);
	void SET_PED_UPPER_BODY_DAMAGE_ONLY(Ped ped, BOOL toggle);
	BOOL IS_PED_SITTING_IN_VEHICLE(Ped ped, Vehicle vehicle);
	BOOL IS_PED_SITTING_IN_ANY_VEHICLE(Ped ped);
	BOOL IS_PED_ON_FOOT(Ped ped);
	BOOL IS_PED_ON_ANY_BIKE(Ped ped);
	BOOL IS_PED_PLANTING_BOMB(Ped ped);
	Vector3 GET_DEAD_PED_PICKUP_COORDS(Ped ped, float p1, float p2);
	BOOL IS_PED_IN_ANY_BOAT(Ped ped);
	BOOL IS_PED_IN_ANY_SUB(Ped ped);
	BOOL IS_PED_IN_ANY_HELI(Ped ped);
	BOOL IS_PED_IN_ANY_PLANE(Ped ped);
	BOOL IS_PED_IN_FLYING_VEHICLE(Ped ped);
	void SET_PED_DIES_IN_WATER(Ped ped, BOOL toggle);
	BOOL GET_PED_DIES_IN_WATER(Ped ped);
	void SET_PED_DIES_IN_SINKING_VEHICLE(Ped ped, BOOL toggle);
	int GET_PED_ARMOUR(Ped ped);
	void SET_PED_STAY_IN_VEHICLE_WHEN_JACKED(Ped ped, BOOL toggle);
	void SET_PED_CAN_BE_SHOT_IN_VEHICLE(Ped ped, BOOL toggle);
	BOOL GET_PED_LAST_DAMAGE_BONE(Ped ped, int* outBone);
	void CLEAR_PED_LAST_DAMAGE_BONE(Ped ped);
	void SET_AI_WEAPON_DAMAGE_MODIFIER(float value);
	void RESET_AI_WEAPON_DAMAGE_MODIFIER();
	void SET_AI_MELEE_WEAPON_DAMAGE_MODIFIER(float modifier);
	void RESET_AI_MELEE_WEAPON_DAMAGE_MODIFIER();
	void SET_TREAT_AS_AMBIENT_PED_FOR_DRIVER_LOCKON(Ped ped, BOOL p1);
	void SET_PED_CAN_BE_TARGETTED(Ped ped, BOOL toggle);
	void SET_PED_CAN_BE_TARGETTED_BY_TEAM(Ped ped, int team, BOOL toggle);
	void SET_PED_CAN_BE_TARGETTED_BY_PLAYER(Ped ped, Player player, BOOL toggle);
	void SET_ALLOW_LOCKON_TO_PED_IF_FRIENDLY(Ped ped, BOOL toggle);
	void SET_USE_CAMERA_HEADING_FOR_DESIRED_DIRECTION_LOCK_ON_TEST(Ped ped, BOOL toggle);
	BOOL IS_PED_IN_ANY_POLICE_VEHICLE(Ped ped);
	void FORCE_PED_TO_OPEN_PARACHUTE(Ped ped);
	BOOL IS_PED_IN_PARACHUTE_FREE_FALL(Ped ped);
	BOOL IS_PED_FALLING(Ped ped);
	BOOL IS_PED_JUMPING(Ped ped);
	BOOL IS_PED_LANDING(Any p0);
	BOOL IS_PED_DOING_A_BEAST_JUMP(Any p0);
	BOOL IS_PED_CLIMBING(Ped ped);
	BOOL IS_PED_VAULTING(Ped ped);
	BOOL IS_PED_DIVING(Ped ped);
	BOOL IS_PED_JUMPING_OUT_OF_VEHICLE(Ped ped);
	BOOL IS_PED_OPENING_DOOR(Ped ped);
	int GET_PED_PARACHUTE_STATE(Ped ped);
	int GET_PED_PARACHUTE_LANDING_TYPE(Ped ped);
	void SET_PED_PARACHUTE_TINT_INDEX(Ped ped, int tintIndex);
	void GET_PED_PARACHUTE_TINT_INDEX(Ped ped, int* outTintIndex);
	void SET_PED_RESERVE_PARACHUTE_TINT_INDEX(Ped ped, Any p1);
	Object CREATE_PARACHUTE_BAG_OBJECT(Ped ped, BOOL p1, BOOL p2);
	void SET_PED_DUCKING(Ped ped, BOOL toggle);
	BOOL IS_PED_DUCKING(Ped ped);
	BOOL IS_PED_IN_ANY_TAXI(Ped ped);
	void SET_PED_ID_RANGE(Ped ped, float value);
	void SET_PED_HIGHLY_PERCEPTIVE(Ped ped, BOOL toggle);
	void SET_COP_PERCEPTION_OVERRIDES(float seeingRange, float seeingRangePeripheral, float hearingRange, float visualFieldMinAzimuthAngle, float visualFieldMaxAzimuthAngle, float fieldOfGazeMaxAngle, float p6);
	void SET_PED_INJURED_ON_GROUND_BEHAVIOUR(Ped ped, float p1);
	void DISABLE_PED_INJURED_ON_GROUND_BEHAVIOUR(Ped ped);
	void SET_PED_SEEING_RANGE(Ped ped, float value);
	void SET_PED_HEARING_RANGE(Ped ped, float value);
	void SET_PED_VISUAL_FIELD_MIN_ANGLE(Ped ped, float value);
	void SET_PED_VISUAL_FIELD_MAX_ANGLE(Ped ped, float value);
	void SET_PED_VISUAL_FIELD_MIN_ELEVATION_ANGLE(Ped ped, float angle);
	void SET_PED_VISUAL_FIELD_MAX_ELEVATION_ANGLE(Ped ped, float angle);
	void SET_PED_VISUAL_FIELD_PERIPHERAL_RANGE(Ped ped, float range);
	void SET_PED_VISUAL_FIELD_CENTER_ANGLE(Ped ped, float angle);
	float GET_PED_VISUAL_FIELD_CENTER_ANGLE(Ped ped);
	void SET_PED_STEALTH_MOVEMENT(Ped ped, BOOL p1, const char* action);
	BOOL GET_PED_STEALTH_MOVEMENT(Ped ped);
	int CREATE_GROUP(int unused);
	void SET_PED_AS_GROUP_LEADER(Ped ped, int groupId);
	void SET_PED_AS_GROUP_MEMBER(Ped ped, int groupId);
	void SET_PED_CAN_TELEPORT_TO_GROUP_LEADER(Ped pedHandle, int groupHandle, BOOL toggle);
	void REMOVE_GROUP(int groupId);
	void REMOVE_PED_FROM_GROUP(Ped ped);
	BOOL IS_PED_GROUP_MEMBER(Ped ped, int groupId);
	BOOL IS_PED_HANGING_ON_TO_VEHICLE(Ped ped);
	void SET_GROUP_SEPARATION_RANGE(int groupHandle, float separationRange);
	void SET_PED_MIN_GROUND_TIME_FOR_STUNGUN(Ped ped, int ms);
	BOOL IS_PED_PRONE(Ped ped);
	BOOL IS_PED_IN_COMBAT(Ped ped, Ped target);
	Entity GET_PED_TARGET_FROM_COMBAT_PED(Ped ped, Any p1);
	BOOL CAN_PED_IN_COMBAT_SEE_TARGET(Ped ped, Ped target);
	BOOL IS_PED_DOING_DRIVEBY(Ped ped);
	BOOL IS_PED_JACKING(Ped ped);
	BOOL IS_PED_BEING_JACKED(Ped ped);
	BOOL IS_PED_BEING_STUNNED(Ped ped, int p1);
	Ped GET_PEDS_JACKER(Ped ped);
	Ped GET_JACK_TARGET(Ped ped);
	BOOL IS_PED_FLEEING(Ped ped);
	BOOL IS_PED_IN_COVER(Ped ped, BOOL exceptUseWeapon);
	BOOL IS_PED_IN_COVER_FACING_LEFT(Ped ped);
	BOOL IS_PED_IN_HIGH_COVER(Ped ped);
	BOOL IS_PED_GOING_INTO_COVER(Ped ped);
	BOOL SET_PED_PINNED_DOWN(Ped ped, BOOL pinned, int i);
	int GET_SEAT_PED_IS_TRYING_TO_ENTER(Ped ped);
	Vehicle GET_VEHICLE_PED_IS_TRYING_TO_ENTER(Ped ped);
	Entity GET_PED_SOURCE_OF_DEATH(Ped ped);
	Hash GET_PED_CAUSE_OF_DEATH(Ped ped);
	int GET_PED_TIME_OF_DEATH(Ped ped);
	int COUNT_PEDS_IN_COMBAT_WITH_TARGET(Ped ped);
	int COUNT_PEDS_IN_COMBAT_WITH_TARGET_WITHIN_RADIUS(Ped ped, float x, float y, float z, float radius);
	void SET_PED_RELATIONSHIP_GROUP_DEFAULT_HASH(Ped ped, Hash hash);
	void SET_PED_RELATIONSHIP_GROUP_HASH(Ped ped, Hash hash);
	void SET_RELATIONSHIP_BETWEEN_GROUPS(int relationship, Hash group1, Hash group2);
	void CLEAR_RELATIONSHIP_BETWEEN_GROUPS(int relationship, Hash group1, Hash group2);
	BOOL ADD_RELATIONSHIP_GROUP(const char* name, Hash* groupHash);
	void REMOVE_RELATIONSHIP_GROUP(Hash groupHash);
	BOOL DOES_RELATIONSHIP_GROUP_EXIST(Hash groupHash);
	int GET_RELATIONSHIP_BETWEEN_PEDS(Ped ped1, Ped ped2);
	Hash GET_PED_RELATIONSHIP_GROUP_DEFAULT_HASH(Ped ped);
	Hash GET_PED_RELATIONSHIP_GROUP_HASH(Ped ped);
	int GET_RELATIONSHIP_BETWEEN_GROUPS(Hash group1, Hash group2);
	void SET_RELATIONSHIP_GROUP_AFFECTS_WANTED_LEVEL(Hash group, BOOL p1);
	void TELL_GROUP_PEDS_IN_AREA_TO_ATTACK(Ped ped, Any p1, float p2, Hash hash, Any p4, Any p5);
	void SET_PED_CAN_BE_TARGETED_WITHOUT_LOS(Ped ped, BOOL toggle);
	void SET_PED_TO_INFORM_RESPECTED_FRIENDS(Ped ped, float radius, int maxFriends);
	BOOL IS_PED_RESPONDING_TO_EVENT(Ped ped, Any event);
	BOOL GET_POS_FROM_FIRED_EVENT(Ped ped, int eventType, Any* outData);
	void SET_PED_FIRING_PATTERN(Ped ped, Hash patternHash);
	void SET_PED_SHOOT_RATE(Ped ped, int shootRate);
	void SET_COMBAT_FLOAT(Ped ped, int combatType, float p2);
	float GET_COMBAT_FLOAT(Ped ped, int p1);
	void GET_GROUP_SIZE(int groupID, Any* p1, int* sizeInMembers);
	BOOL DOES_GROUP_EXIST(int groupId);
	int GET_PED_GROUP_INDEX(Ped ped);
	BOOL IS_PED_IN_GROUP(Ped ped);
	Player GET_PLAYER_PED_IS_FOLLOWING(Ped ped);
	void SET_GROUP_FORMATION(int groupId, int formationType);
	void SET_GROUP_FORMATION_SPACING(int groupId, float x, float y, float z);
	void RESET_GROUP_FORMATION_DEFAULT_SPACING(int groupHandle);
	Vehicle GET_VEHICLE_PED_IS_USING(Ped ped);
	Vehicle GET_VEHICLE_PED_IS_ENTERING(Ped ped);
	void SET_PED_GRAVITY(Ped ped, BOOL toggle);
	void APPLY_DAMAGE_TO_PED(Ped ped, int damageAmount, BOOL p2, Any p3);
	int GET_TIME_PED_DAMAGED_BY_WEAPON(Ped ped, Hash weaponHash);
	void SET_PED_ALLOWED_TO_DUCK(Ped ped, BOOL toggle);
	void SET_PED_NEVER_LEAVES_GROUP(Ped ped, BOOL toggle);
	int GET_PED_TYPE(Ped ped);
	void SET_PED_AS_COP(Ped ped, BOOL toggle);
	void SET_PED_HEALTH_PENDING_LAST_DAMAGE_EVENT_OVERRIDE_FLAG(BOOL toggle);
	void SET_PED_MAX_HEALTH(Ped ped, int value);
	int GET_PED_MAX_HEALTH(Ped ped);
	void SET_PED_MAX_TIME_IN_WATER(Ped ped, float value);
	void SET_PED_MAX_TIME_UNDERWATER(Ped ped, float value);
	void SET_CORPSE_RAGDOLL_FRICTION(Ped ped, float p1);
	void SET_PED_VEHICLE_FORCED_SEAT_USAGE(Ped ped, Vehicle vehicle, int seatIndex, int flags, Any p4);
	void CLEAR_ALL_PED_VEHICLE_FORCED_SEAT_USAGE(Ped ped);
	void SET_PED_CAN_BE_KNOCKED_OFF_BIKE(Any p0, Any p1);
	void SET_PED_CAN_BE_KNOCKED_OFF_VEHICLE(Ped ped, int state);
	BOOL CAN_KNOCK_PED_OFF_VEHICLE(Ped ped);
	void KNOCK_PED_OFF_VEHICLE(Ped ped);
	void SET_PED_COORDS_NO_GANG(Ped ped, float posX, float posY, float posZ);
	Ped GET_PED_AS_GROUP_MEMBER(int groupID, int memberNumber);
	Ped GET_PED_AS_GROUP_LEADER(int groupID);
	void SET_PED_KEEP_TASK(Ped ped, BOOL toggle);
	void SET_PED_ALLOW_MINOR_REACTIONS_AS_MISSION_PED(Ped ped, BOOL toggle);
	BOOL IS_PED_SWIMMING(Ped ped);
	BOOL IS_PED_SWIMMING_UNDER_WATER(Ped ped);
	void SET_PED_COORDS_KEEP_VEHICLE(Ped ped, float posX, float posY, float posZ);
	void SET_PED_DIES_IN_VEHICLE(Ped ped, BOOL toggle);
	void SET_CREATE_RANDOM_COPS(BOOL toggle);
	void SET_CREATE_RANDOM_COPS_NOT_ON_SCENARIOS(BOOL toggle);
	void SET_CREATE_RANDOM_COPS_ON_SCENARIOS(BOOL toggle);
	BOOL CAN_CREATE_RANDOM_COPS();
	void SET_PED_AS_ENEMY(Ped ped, BOOL toggle);
	void SET_PED_CAN_SMASH_GLASS(Ped ped, BOOL p1, BOOL p2);
	BOOL IS_PED_IN_ANY_TRAIN(Ped ped);
	BOOL IS_PED_GETTING_INTO_A_VEHICLE(Ped ped);
	BOOL IS_PED_TRYING_TO_ENTER_A_LOCKED_VEHICLE(Ped ped);
	void SET_ENABLE_HANDCUFFS(Ped ped, BOOL toggle);
	void SET_ENABLE_BOUND_ANKLES(Ped ped, BOOL toggle);
	void SET_ENABLE_SCUBA(Ped ped, BOOL toggle);
	void SET_CAN_ATTACK_FRIENDLY(Ped ped, BOOL toggle, BOOL p2);
	int GET_PED_ALERTNESS(Ped ped);
	void SET_PED_ALERTNESS(Ped ped, int value);
	void SET_PED_GET_OUT_UPSIDE_DOWN_VEHICLE(Ped ped, BOOL toggle);
	void SET_PED_MOVEMENT_CLIPSET(Ped ped, const char* clipSet, float transitionSpeed);
	void RESET_PED_MOVEMENT_CLIPSET(Ped ped, float p1);
	void SET_PED_STRAFE_CLIPSET(Ped ped, const char* clipSet);
	void RESET_PED_STRAFE_CLIPSET(Ped ped);
	void SET_PED_WEAPON_MOVEMENT_CLIPSET(Ped ped, const char* clipSet);
	void RESET_PED_WEAPON_MOVEMENT_CLIPSET(Ped ped);
	void SET_PED_DRIVE_BY_CLIPSET_OVERRIDE(Ped ped, const char* clipset);
	void CLEAR_PED_DRIVE_BY_CLIPSET_OVERRIDE(Ped ped);
	void SET_PED_MOTION_IN_COVER_CLIPSET_OVERRIDE(Ped ped, const char* p1);
	void CLEAR_PED_MOTION_IN_COVER_CLIPSET_OVERRIDE(Ped ped);
	void CLEAR_PED_FALL_UPPER_BODY_CLIPSET_OVERRIDE(Ped ped);
	void SET_PED_IN_VEHICLE_CONTEXT(Ped ped, Hash context);
	void RESET_PED_IN_VEHICLE_CONTEXT(Ped ped);
	BOOL IS_SCRIPTED_SCENARIO_PED_USING_CONDITIONAL_ANIM(Ped ped, const char* animDict, const char* anim);
	void SET_PED_ALTERNATE_WALK_ANIM(Ped ped, const char* animDict, const char* animName, float p3, BOOL p4);
	void CLEAR_PED_ALTERNATE_WALK_ANIM(Ped ped, float p1);
	void SET_PED_ALTERNATE_MOVEMENT_ANIM(Ped ped, int stance, const char* animDictionary, const char* animationName, float p4, BOOL p5);
	void CLEAR_PED_ALTERNATE_MOVEMENT_ANIM(Ped ped, int stance, float p2);
	void SET_PED_GESTURE_GROUP(Ped ped, const char* animGroupGesture);
	Vector3 GET_ANIM_INITIAL_OFFSET_POSITION(const char* animDict, const char* animName, float x, float y, float z, float xRot, float yRot, float zRot, float p8, int p9);
	Vector3 GET_ANIM_INITIAL_OFFSET_ROTATION(const char* animDict, const char* animName, float x, float y, float z, float xRot, float yRot, float zRot, float p8, int p9);
	int GET_PED_DRAWABLE_VARIATION(Ped ped, int componentId);
	int GET_NUMBER_OF_PED_DRAWABLE_VARIATIONS(Ped ped, int componentId);
	int GET_PED_TEXTURE_VARIATION(Ped ped, int componentId);
	int GET_NUMBER_OF_PED_TEXTURE_VARIATIONS(Ped ped, int componentId, int drawableId);
	int GET_NUMBER_OF_PED_PROP_DRAWABLE_VARIATIONS(Ped ped, int propId);
	int GET_NUMBER_OF_PED_PROP_TEXTURE_VARIATIONS(Ped ped, int propId, int drawableId);
	int GET_PED_PALETTE_VARIATION(Ped ped, int componentId);
	BOOL GET_MP_OUTFIT_DATA_FROM_METADATA(Any* p0, Any* p1);
	int GET_FM_MALE_SHOP_PED_APPAREL_ITEM_INDEX(int p0);
	int GET_FM_FEMALE_SHOP_PED_APPAREL_ITEM_INDEX(int p0);
	BOOL IS_PED_COMPONENT_VARIATION_VALID(Ped ped, int componentId, int drawableId, int textureId);
	void SET_PED_COMPONENT_VARIATION(Ped ped, int componentId, int drawableId, int textureId, int paletteId);
	void SET_PED_RANDOM_COMPONENT_VARIATION(Ped ped, int p1);
	void SET_PED_RANDOM_PROPS(Ped ped);
	void SET_PED_DEFAULT_COMPONENT_VARIATION(Ped ped);
	void SET_PED_BLEND_FROM_PARENTS(Ped ped, Any p1, Any p2, float p3, float p4);
	void SET_PED_HEAD_BLEND_DATA(Ped ped, int shapeFirstID, int shapeSecondID, int shapeThirdID, int skinFirstID, int skinSecondID, int skinThirdID, float shapeMix, float skinMix, float thirdMix, BOOL isParent);
	BOOL GET_PED_HEAD_BLEND_DATA(Ped ped, Any* headBlendData);
	void UPDATE_PED_HEAD_BLEND_DATA(Ped ped, float shapeMix, float skinMix, float thirdMix);
	void SET_HEAD_BLEND_EYE_COLOR(Ped ped, int index);
	int GET_HEAD_BLEND_EYE_COLOR(Ped ped);
	void SET_PED_HEAD_OVERLAY(Ped ped, int overlayID, int index, float opacity);
	int GET_PED_HEAD_OVERLAY(Ped ped, int overlayID);
	int GET_PED_HEAD_OVERLAY_NUM(int overlayID);
	void SET_PED_HEAD_OVERLAY_TINT(Ped ped, int overlayID, int colorType, int colorID, int secondColorID);
	void SET_PED_HAIR_TINT(Ped ped, int colorID, int highlightColorID);
	int GET_NUM_PED_HAIR_TINTS();
	int GET_NUM_PED_MAKEUP_TINTS();
	void GET_PED_HAIR_TINT_COLOR(int hairColorIndex, int* outR, int* outG, int* outB);
	void GET_PED_MAKEUP_TINT_COLOR(int makeupColorIndex, int* outR, int* outG, int* outB);
	BOOL IS_PED_HAIR_TINT_FOR_CREATOR(int colorId);
	int GET_DEFAULT_SECONDARY_TINT_FOR_CREATOR(int colorId);
	BOOL IS_PED_LIPSTICK_TINT_FOR_CREATOR(int colorId);
	BOOL IS_PED_BLUSH_TINT_FOR_CREATOR(int colorId);
	BOOL IS_PED_HAIR_TINT_FOR_BARBER(int colorID);
	int GET_DEFAULT_SECONDARY_TINT_FOR_BARBER(int colorID);
	BOOL IS_PED_LIPSTICK_TINT_FOR_BARBER(int colorID);
	BOOL IS_PED_BLUSH_TINT_FOR_BARBER(int colorID);
	BOOL IS_PED_BLUSH_FACEPAINT_TINT_FOR_BARBER(int colorId);
	int GET_TINT_INDEX_FOR_LAST_GEN_HAIR_TEXTURE(Hash modelHash, int drawableId, int textureId);
	void SET_PED_MICRO_MORPH(Ped ped, int index, float scale);
	BOOL HAS_PED_HEAD_BLEND_FINISHED(Ped ped);
	void FINALIZE_HEAD_BLEND(Ped ped);
	void SET_HEAD_BLEND_PALETTE_COLOR(Ped ped, int r, int g, int b, int id);
	void DISABLE_HEAD_BLEND_PALETTE_COLOR(Ped ped);
	int GET_PED_HEAD_BLEND_FIRST_INDEX(int type);
	int GET_PED_HEAD_BLEND_NUM_HEADS(int type);
	int SET_PED_PRELOAD_VARIATION_DATA(Ped ped, int slot, int drawableId, int textureId);
	BOOL HAS_PED_PRELOAD_VARIATION_DATA_FINISHED(Ped ped);
	void RELEASE_PED_PRELOAD_VARIATION_DATA(Ped ped);
	int SET_PED_PRELOAD_PROP_DATA(Ped ped, int componentId, int drawableId, int TextureId);
	BOOL HAS_PED_PRELOAD_PROP_DATA_FINISHED(Ped ped);
	void RELEASE_PED_PRELOAD_PROP_DATA(Ped ped);
	int GET_PED_PROP_INDEX(Ped ped, int componentId, Any p2);
	void SET_PED_PROP_INDEX(Ped ped, int componentId, int drawableId, int TextureId, BOOL attach, Any p5);
	void KNOCK_OFF_PED_PROP(Ped ped, BOOL p1, BOOL p2, BOOL p3, BOOL p4);
	void CLEAR_PED_PROP(Ped ped, int propId, Any p2);
	void CLEAR_ALL_PED_PROPS(Ped ped, Any p1);
	void DROP_AMBIENT_PROP(Ped ped);
	int GET_PED_PROP_TEXTURE_INDEX(Ped ped, int componentId);
	void CLEAR_PED_PARACHUTE_PACK_VARIATION(Ped ped);
	void SET_PED_SCUBA_GEAR_VARIATION(Ped ped);
	void CLEAR_PED_SCUBA_GEAR_VARIATION(Ped ped);
	BOOL IS_USING_PED_SCUBA_GEAR_VARIATION(Any p0);
	void SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(Ped ped, BOOL toggle);
	void SET_PED_BOUNDS_ORIENTATION(Ped ped, float p1, float p2, float x, float y, float z);
	void REGISTER_TARGET(Ped ped, Ped target);
	void REGISTER_HATED_TARGETS_AROUND_PED(Ped ped, float radius);
	Ped GET_RANDOM_PED_AT_COORD(float x, float y, float z, float xRadius, float yRadius, float zRadius, int pedType);
	BOOL GET_CLOSEST_PED(float x, float y, float z, float radius, BOOL p4, BOOL p5, Ped* outPed, BOOL p7, BOOL p8, int pedType);
	void SET_SCENARIO_PEDS_TO_BE_RETURNED_BY_NEXT_COMMAND(BOOL value);
	BOOL GET_CAN_PED_BE_GRABBED_BY_SCRIPT(Ped ped, BOOL p1, BOOL p2, BOOL p3, BOOL p4, BOOL p5, BOOL p6, BOOL p7, Any p8);
	void SET_DRIVER_RACING_MODIFIER(Ped driver, float modifier);
	void SET_DRIVER_ABILITY(Ped driver, float ability);
	void SET_DRIVER_AGGRESSIVENESS(Ped driver, float aggressiveness);
	BOOL CAN_PED_RAGDOLL(Ped ped);
	BOOL SET_PED_TO_RAGDOLL(Ped ped, int time1, int time2, int ragdollType, BOOL p4, BOOL p5, BOOL p6);
	BOOL SET_PED_TO_RAGDOLL_WITH_FALL(Ped ped, int time, int p2, int ragdollType, float x, float y, float z, float velocity, float p8, float p9, float p10, float p11, float p12, float p13);
	void SET_PED_RAGDOLL_ON_COLLISION(Ped ped, BOOL toggle);
	BOOL IS_PED_RAGDOLL(Ped ped);
	BOOL IS_PED_RUNNING_RAGDOLL_TASK(Ped ped);
	void SET_PED_RAGDOLL_FORCE_FALL(Ped ped);
	void RESET_PED_RAGDOLL_TIMER(Ped ped);
	void SET_PED_CAN_RAGDOLL(Ped ped, BOOL toggle);
	BOOL IS_PED_RUNNING_MELEE_TASK(Ped ped);
	BOOL IS_PED_RUNNING_MOBILE_PHONE_TASK(Ped ped);
	BOOL IS_MOBILE_PHONE_TO_PED_EAR(Ped ped);
	void SET_RAGDOLL_BLOCKING_FLAGS(Ped ped, int blockingFlag);
	void CLEAR_RAGDOLL_BLOCKING_FLAGS(Ped ped, int blockingFlag);
	void SET_PED_ANGLED_DEFENSIVE_AREA(Ped ped, float p1, float p2, float p3, float p4, float p5, float p6, float p7, BOOL p8, BOOL p9);
	void SET_PED_SPHERE_DEFENSIVE_AREA(Ped ped, float x, float y, float z, float radius, BOOL p5, BOOL p6);
	void SET_PED_DEFENSIVE_SPHERE_ATTACHED_TO_PED(Ped ped, Ped target, float xOffset, float yOffset, float zOffset, float radius, BOOL p6);
	void SET_PED_DEFENSIVE_SPHERE_ATTACHED_TO_VEHICLE(Ped ped, Vehicle target, float xOffset, float yOffset, float zOffset, float radius, BOOL p6);
	void SET_PED_DEFENSIVE_AREA_ATTACHED_TO_PED(Ped ped, Ped attachPed, float p2, float p3, float p4, float p5, float p6, float p7, float p8, BOOL p9, BOOL p10);
	void SET_PED_DEFENSIVE_AREA_DIRECTION(Ped ped, float p1, float p2, float p3, BOOL p4);
	void REMOVE_PED_DEFENSIVE_AREA(Ped ped, BOOL toggle);
	Vector3 GET_PED_DEFENSIVE_AREA_POSITION(Ped ped, BOOL p1);
	BOOL IS_PED_DEFENSIVE_AREA_ACTIVE(Ped ped, BOOL p1);
	void SET_PED_PREFERRED_COVER_SET(Ped ped, Any itemSet);
	void REMOVE_PED_PREFERRED_COVER_SET(Ped ped);
	void REVIVE_INJURED_PED(Ped ped);
	void RESURRECT_PED(Ped ped);
	void SET_PED_NAME_DEBUG(Ped ped, const char* name);
	Vector3 GET_PED_EXTRACTED_DISPLACEMENT(Ped ped, BOOL worldSpace);
	void SET_PED_DIES_WHEN_INJURED(Ped ped, BOOL toggle);
	void SET_PED_ENABLE_WEAPON_BLOCKING(Ped ped, BOOL toggle);
	void SPECIAL_FUNCTION_DO_NOT_USE(Ped ped, BOOL p1);
	void RESET_PED_VISIBLE_DAMAGE(Ped ped);
	void APPLY_PED_BLOOD_DAMAGE_BY_ZONE(Ped ped, Any p1, float p2, float p3, Any p4);
	void APPLY_PED_BLOOD(Ped ped, int boneIndex, float xRot, float yRot, float zRot, const char* woundType);
	void APPLY_PED_BLOOD_BY_ZONE(Ped ped, int p1, float p2, float p3, const char* p4);
	void APPLY_PED_BLOOD_SPECIFIC(Ped ped, int p1, float p2, float p3, float p4, float p5, int p6, float p7, const char* p8);
	void APPLY_PED_DAMAGE_DECAL(Ped ped, int damageZone, float xOffset, float yOffset, float heading, float scale, float alpha, int variation, BOOL fadeIn, const char* decalName);
	void APPLY_PED_DAMAGE_PACK(Ped ped, const char* damagePack, float damage, float mult);
	void CLEAR_PED_BLOOD_DAMAGE(Ped ped);
	void CLEAR_PED_BLOOD_DAMAGE_BY_ZONE(Ped ped, int p1);
	void HIDE_PED_BLOOD_DAMAGE_BY_ZONE(Ped ped, Any p1, BOOL p2);
	void CLEAR_PED_DAMAGE_DECAL_BY_ZONE(Ped ped, int p1, const char* p2);
	int GET_PED_DECORATIONS_STATE(Ped ped);
	void MARK_PED_DECORATIONS_AS_CLONED_FROM_LOCAL_PLAYER(Ped ped, BOOL p1);
	void CLEAR_PED_WETNESS(Ped ped);
	void SET_PED_WETNESS_HEIGHT(Ped ped, float height);
	void SET_PED_WETNESS_ENABLED_THIS_FRAME(Ped ped);
	void SET_PED_WETNESS(Ped ped, float wetLevel);
	void CLEAR_PED_ENV_DIRT(Ped ped);
	void SET_PED_SWEAT(Ped ped, float sweat);
	void ADD_PED_DECORATION_FROM_HASHES(Ped ped, Hash collection, Hash overlay);
	void ADD_PED_DECORATION_FROM_HASHES_IN_CORONA(Ped ped, Hash collection, Hash overlay);
	int GET_PED_DECORATION_ZONE_FROM_HASHES(Hash collection, Hash overlay);
	void CLEAR_PED_DECORATIONS(Ped ped);
	void CLEAR_PED_DECORATIONS_LEAVE_SCARS(Ped ped);
	BOOL WAS_PED_SKELETON_UPDATED(Ped ped);
	Vector3 GET_PED_BONE_COORDS(Ped ped, int boneId, float offsetX, float offsetY, float offsetZ);
	void CREATE_NM_MESSAGE(BOOL startImmediately, int messageId);
	void GIVE_PED_NM_MESSAGE(Ped ped);
	int ADD_SCENARIO_BLOCKING_AREA(float x1, float y1, float z1, float x2, float y2, float z2, BOOL p6, BOOL p7, BOOL p8, BOOL p9);
	void REMOVE_SCENARIO_BLOCKING_AREAS();
	void REMOVE_SCENARIO_BLOCKING_AREA(Any p0, BOOL p1);
	void SET_SCENARIO_PEDS_SPAWN_IN_SPHERE_AREA(float x, float y, float z, float range, int p4);
	BOOL DOES_SCENARIO_BLOCKING_AREA_EXISTS(float x1, float y1, float z1, float x2, float y2, float z2);
	BOOL IS_PED_USING_SCENARIO(Ped ped, const char* scenario);
	BOOL IS_PED_USING_ANY_SCENARIO(Ped ped);
	BOOL SET_PED_PANIC_EXIT_SCENARIO(Any p0, Any p1, Any p2, Any p3);
	void TOGGLE_SCENARIO_PED_COWER_IN_PLACE(Ped ped, BOOL toggle);
	BOOL TRIGGER_PED_SCENARIO_PANICEXITTOFLEE(Any p0, Any p1, Any p2, Any p3);
	BOOL SET_PED_SHOULD_PLAY_DIRECTED_NORMAL_SCENARIO_EXIT(Any p0, Any p1, Any p2, Any p3);
	void SET_PED_SHOULD_PLAY_NORMAL_SCENARIO_EXIT(Ped ped);
	void SET_PED_SHOULD_PLAY_IMMEDIATE_SCENARIO_EXIT(Ped ped);
	BOOL SET_PED_SHOULD_PLAY_FLEE_SCENARIO_EXIT(Ped ped, Any p1, Any p2, Any p3);
	void SET_PED_SHOULD_IGNORE_SCENARIO_EXIT_COLLISION_CHECKS(Ped ped, BOOL p1);
	void SET_PED_SHOULD_IGNORE_SCENARIO_NAV_CHECKS(Any p0, BOOL p1);
	void SET_PED_SHOULD_PROBE_FOR_SCENARIO_EXITS_IN_ONE_FRAME(Any p0, BOOL p1);
	BOOL IS_PED_GESTURING(Any p0);
	void RESET_FACIAL_IDLE_ANIM(Ped ped);
	void PLAY_FACIAL_ANIM(Ped ped, const char* animName, const char* animDict);
	void SET_FACIAL_CLIPSET(Ped ped, const char* animDict);
	void SET_FACIAL_IDLE_ANIM_OVERRIDE(Ped ped, const char* animName, const char* animDict);
	void CLEAR_FACIAL_IDLE_ANIM_OVERRIDE(Ped ped);
	void SET_PED_CAN_PLAY_GESTURE_ANIMS(Ped ped, BOOL toggle);
	void SET_PED_CAN_PLAY_VISEME_ANIMS(Ped ped, BOOL toggle, BOOL p2);
	void SET_PED_IS_IGNORED_BY_AUTO_OPEN_DOORS(Ped ped, BOOL p1);
	void SET_PED_CAN_PLAY_AMBIENT_ANIMS(Ped ped, BOOL toggle);
	void SET_PED_CAN_PLAY_AMBIENT_BASE_ANIMS(Ped ped, BOOL toggle);
	void TRIGGER_IDLE_ANIMATION_ON_PED(Ped ped);
	void SET_PED_CAN_ARM_IK(Ped ped, BOOL toggle);
	void SET_PED_CAN_HEAD_IK(Ped ped, BOOL toggle);
	void SET_PED_CAN_LEG_IK(Ped ped, BOOL toggle);
	void SET_PED_CAN_TORSO_IK(Ped ped, BOOL toggle);
	void SET_PED_CAN_TORSO_REACT_IK(Ped ped, BOOL p1);
	void SET_PED_CAN_TORSO_VEHICLE_IK(Ped ped, BOOL p1);
	void SET_PED_CAN_USE_AUTO_CONVERSATION_LOOKAT(Ped ped, BOOL toggle);
	BOOL IS_PED_HEADTRACKING_PED(Ped ped1, Ped ped2);
	BOOL IS_PED_HEADTRACKING_ENTITY(Ped ped, Entity entity);
	void SET_PED_PRIMARY_LOOKAT(Ped ped, Ped lookAt);
	void SET_PED_CLOTH_PIN_FRAMES(Any p0, Any p1);
	void SET_PED_CLOTH_PACKAGE_INDEX(Any p0, Any p1);
	void SET_PED_CLOTH_PRONE(Any p0, BOOL p1);
	void SET_PED_CONFIG_FLAG(Ped ped, int flagId, BOOL value);
	void SET_PED_RESET_FLAG(Ped ped, int flagId, BOOL doReset);
	BOOL GET_PED_CONFIG_FLAG(Ped ped, int flagId, BOOL p2);
	BOOL GET_PED_RESET_FLAG(Ped ped, int flagId);
	void SET_PED_GROUP_MEMBER_PASSENGER_INDEX(Ped ped, int index);
	void SET_PED_CAN_EVASIVE_DIVE(Ped ped, BOOL toggle);
	BOOL IS_PED_EVASIVE_DIVING(Ped ped, Entity* evadingEntity);
	void SET_PED_SHOOTS_AT_COORD(Ped ped, float x, float y, float z, BOOL toggle);
	void SET_PED_MODEL_IS_SUPPRESSED(Hash modelHash, BOOL toggle);
	void STOP_ANY_PED_MODEL_BEING_SUPPRESSED();
	void SET_PED_CAN_BE_TARGETED_WHEN_INJURED(Ped ped, BOOL toggle);
	void SET_PED_GENERATES_DEAD_BODY_EVENTS(Ped ped, BOOL toggle);
	void BLOCK_PED_FROM_GENERATING_DEAD_BODY_EVENTS_WHEN_DEAD(Ped ped, BOOL toggle);
	void SET_PED_WILL_ONLY_ATTACK_WANTED_PLAYER(Any p0, Any p1);
	void SET_PED_CAN_RAGDOLL_FROM_PLAYER_IMPACT(Ped ped, BOOL toggle);
	void GIVE_PED_HELMET(Ped ped, BOOL cannotRemove, int helmetFlag, int textureIndex);
	void REMOVE_PED_HELMET(Ped ped, BOOL instantly);
	BOOL IS_PED_TAKING_OFF_HELMET(Ped ped);
	void SET_PED_HELMET(Ped ped, BOOL canWearHelmet);
	void SET_PED_HELMET_FLAG(Ped ped, int helmetFlag);
	void SET_PED_HELMET_PROP_INDEX(Ped ped, int propIndex, BOOL p2);
	void SET_PED_HELMET_VISOR_PROP_INDICES(Ped ped, BOOL p1, int p2, int p3);
	BOOL IS_PED_HELMET_VISOR_UP(Ped ped);
	void SET_PED_HELMET_TEXTURE_INDEX(Ped ped, int textureIndex);
	BOOL IS_PED_WEARING_HELMET(Ped ped);
	void CLEAR_PED_STORED_HAT_PROP(Ped ped);
	int GET_PED_HELMET_STORED_HAT_PROP_INDEX(Ped ped);
	int GET_PED_HELMET_STORED_HAT_TEX_INDEX(Ped ped);
	BOOL IS_CURRENT_HEAD_PROP_A_HELMET(Any p0);
	void SET_PED_TO_LOAD_COVER(Ped ped, BOOL toggle);
	void SET_PED_CAN_COWER_IN_COVER(Ped ped, BOOL toggle);
	void SET_PED_CAN_PEEK_IN_COVER(Ped ped, BOOL toggle);
	void SET_PED_PLAYS_HEAD_ON_HORN_ANIM_WHEN_DIES_IN_VEHICLE(Ped ped, BOOL toggle);
	void SET_PED_LEG_IK_MODE(Ped ped, int mode);
	void SET_PED_MOTION_BLUR(Ped ped, BOOL toggle);
	void SET_PED_CAN_SWITCH_WEAPON(Ped ped, BOOL toggle);
	void SET_PED_DIES_INSTANTLY_IN_WATER(Ped ped, BOOL toggle);
	void SET_LADDER_CLIMB_INPUT_STATE(Ped ped, int p1);
	void STOP_PED_WEAPON_FIRING_WHEN_DROPPED(Ped ped);
	void SET_SCRIPTED_ANIM_SEAT_OFFSET(Ped ped, float p1);
	void SET_PED_COMBAT_MOVEMENT(Ped ped, int combatMovement);
	int GET_PED_COMBAT_MOVEMENT(Ped ped);
	void SET_PED_COMBAT_ABILITY(Ped ped, int abilityLevel);
	void SET_PED_COMBAT_RANGE(Ped ped, int combatRange);
	int GET_PED_COMBAT_RANGE(Ped ped);
	void SET_PED_COMBAT_ATTRIBUTES(Ped ped, int attributeId, BOOL enabled);
	void SET_PED_TARGET_LOSS_RESPONSE(Ped ped, int responseType);
	BOOL IS_PED_PERFORMING_MELEE_ACTION(Ped ped);
	BOOL IS_PED_PERFORMING_STEALTH_KILL(Ped ped);
	BOOL IS_PED_PERFORMING_A_COUNTER_ATTACK(Ped ped);
	BOOL IS_PED_BEING_STEALTH_KILLED(Ped ped);
	Ped GET_MELEE_TARGET_FOR_PED(Ped ped);
	BOOL WAS_PED_KILLED_BY_STEALTH(Ped ped);
	BOOL WAS_PED_KILLED_BY_TAKEDOWN(Ped ped);
	BOOL WAS_PED_KNOCKED_OUT(Ped ped);
	void SET_PED_FLEE_ATTRIBUTES(Ped ped, int attributeFlags, BOOL enable);
	void SET_PED_COWER_HASH(Ped ped, const char* p1);
	void SET_PED_STEERS_AROUND_DEAD_BODIES(Ped ped, BOOL toggle);
	void SET_PED_STEERS_AROUND_PEDS(Ped ped, BOOL toggle);
	void SET_PED_STEERS_AROUND_OBJECTS(Ped ped, BOOL toggle);
	void SET_PED_STEERS_AROUND_VEHICLES(Ped ped, BOOL toggle);
	void SET_PED_IS_AVOIDED_BY_OTHERS(Any p0, BOOL p1);
	void SET_PED_INCREASED_AVOIDANCE_RADIUS(Ped ped);
	void SET_PED_BLOCKS_PATHING_WHEN_DEAD(Ped ped, BOOL toggle);
	void SET_PED_NO_TIME_DELAY_BEFORE_SHOT(Any p0);
	BOOL IS_ANY_PED_NEAR_POINT(float x, float y, float z, float radius);
	void FORCE_PED_AI_AND_ANIMATION_UPDATE(Ped ped, BOOL p1, BOOL p2);
	BOOL IS_PED_HEADING_TOWARDS_POSITION(Ped ped, float x, float y, float z, float p4);
	void REQUEST_PED_VISIBILITY_TRACKING(Ped ped);
	void REQUEST_PED_VEHICLE_VISIBILITY_TRACKING(Ped ped, BOOL p1);
	void REQUEST_PED_RESTRICTED_VEHICLE_VISIBILITY_TRACKING(Ped ped, BOOL p1);
	void REQUEST_PED_USE_SMALL_BBOX_VISIBILITY_TRACKING(Ped ped, BOOL p1);
	BOOL IS_TRACKED_PED_VISIBLE(Ped ped);
	int GET_TRACKED_PED_PIXELCOUNT(Ped ped);
	BOOL IS_PED_TRACKED(Ped ped);
	BOOL HAS_PED_RECEIVED_EVENT(Ped ped, int eventId);
	BOOL CAN_PED_SEE_HATED_PED(Ped ped1, Ped ped2);
	BOOL CAN_PED_SHUFFLE_TO_OR_FROM_TURRET_SEAT(Ped ped, int* p1);
	BOOL CAN_PED_SHUFFLE_TO_OR_FROM_EXTRA_SEAT(Ped ped, int* p1);
	int GET_PED_BONE_INDEX(Ped ped, int boneId);
	int GET_PED_RAGDOLL_BONE_INDEX(Ped ped, int bone);
	void SET_PED_ENVEFF_SCALE(Ped ped, float value);
	float GET_PED_ENVEFF_SCALE(Ped ped);
	void SET_ENABLE_PED_ENVEFF_SCALE(Ped ped, BOOL toggle);
	void SET_PED_ENVEFF_CPV_ADD(Ped ped, float p1);
	void SET_PED_ENVEFF_COLOR_MODULATOR(Ped ped, int p1, int p2, int p3);
	void SET_PED_EMISSIVE_SCALE(Ped ped, float intensity);
	float GET_PED_EMISSIVE_SCALE(Ped ped);
	BOOL IS_PED_SHADER_READY(Ped ped);
	void SET_PED_ENABLE_CREW_EMBLEM(Ped ped, BOOL toggle);
	void REQUEST_RAGDOLL_BOUNDS_UPDATE(Any p0, Any p1);
	void SET_PED_AO_BLOB_RENDERING(Ped ped, BOOL toggle);
	BOOL IS_PED_SHELTERED(Ped ped);
	int CREATE_SYNCHRONIZED_SCENE(float x, float y, float z, float roll, float pitch, float yaw, int p6);
	int CREATE_SYNCHRONIZED_SCENE_AT_MAP_OBJECT(float x, float y, float z, float radius, Hash object);
	BOOL IS_SYNCHRONIZED_SCENE_RUNNING(int sceneId);
	void SET_SYNCHRONIZED_SCENE_ORIGIN(int sceneID, float x, float y, float z, float roll, float pitch, float yaw, BOOL p7);
	void SET_SYNCHRONIZED_SCENE_PHASE(int sceneID, float phase);
	float GET_SYNCHRONIZED_SCENE_PHASE(int sceneID);
	void SET_SYNCHRONIZED_SCENE_RATE(int sceneID, float rate);
	float GET_SYNCHRONIZED_SCENE_RATE(int sceneID);
	void SET_SYNCHRONIZED_SCENE_LOOPED(int sceneID, BOOL toggle);
	BOOL IS_SYNCHRONIZED_SCENE_LOOPED(int sceneID);
	void SET_SYNCHRONIZED_SCENE_HOLD_LAST_FRAME(int sceneID, BOOL toggle);
	BOOL IS_SYNCHRONIZED_SCENE_HOLD_LAST_FRAME(int sceneID);
	void ATTACH_SYNCHRONIZED_SCENE_TO_ENTITY(int sceneID, Entity entity, int boneIndex);
	void DETACH_SYNCHRONIZED_SCENE(int sceneID);
	void TAKE_OWNERSHIP_OF_SYNCHRONIZED_SCENE(int scene);
	BOOL FORCE_PED_MOTION_STATE(Ped ped, Hash motionStateHash, BOOL p2, int p3, BOOL p4);
	BOOL GET_PED_CURRENT_MOVE_BLEND_RATIO(Ped ped, float* speedX, float* speedY);
	void SET_PED_MAX_MOVE_BLEND_RATIO(Ped ped, float value);
	void SET_PED_MIN_MOVE_BLEND_RATIO(Ped ped, float value);
	void SET_PED_MOVE_RATE_OVERRIDE(Ped ped, float value);
	void SET_PED_MOVE_RATE_IN_WATER_OVERRIDE(Ped ped, float p1);
	BOOL PED_HAS_SEXINESS_FLAG_SET(Ped ped, int sexinessFlag);
	int GET_PED_NEARBY_VEHICLES(Ped ped, Any* sizeAndVehs);
	int GET_PED_NEARBY_PEDS(Ped ped, Any* sizeAndPeds, int ignore);
	BOOL HAVE_ALL_STREAMING_REQUESTS_COMPLETED(Ped ped);
	BOOL IS_PED_USING_ACTION_MODE(Ped ped);
	void SET_PED_USING_ACTION_MODE(Ped ped, BOOL p1, int p2, const char* action);
	void SET_MOVEMENT_MODE_OVERRIDE(Ped ped, const char* name);
	void SET_PED_CAPSULE(Ped ped, float value);
	int REGISTER_PEDHEADSHOT(Ped ped);
	int REGISTER_PEDHEADSHOT_HIRES(Ped ped);
	int REGISTER_PEDHEADSHOT_TRANSPARENT(Ped ped);
	void UNREGISTER_PEDHEADSHOT(int id);
	BOOL IS_PEDHEADSHOT_VALID(int id);
	BOOL IS_PEDHEADSHOT_READY(int id);
	const char* GET_PEDHEADSHOT_TXD_STRING(int id);
	BOOL REQUEST_PEDHEADSHOT_IMG_UPLOAD(int id);
	void RELEASE_PEDHEADSHOT_IMG_UPLOAD(int id);
	BOOL IS_PEDHEADSHOT_IMG_UPLOAD_AVAILABLE();
	BOOL HAS_PEDHEADSHOT_IMG_UPLOAD_FAILED();
	BOOL HAS_PEDHEADSHOT_IMG_UPLOAD_SUCCEEDED();
	void SET_PED_HEATSCALE_OVERRIDE(Ped ped, float heatScale);
	void DISABLE_PED_HEATSCALE_OVERRIDE(Ped ped);
	void SPAWNPOINTS_START_SEARCH(float p0, float p1, float p2, float p3, float p4, int interiorFlags, float scale, int duration);
	void SPAWNPOINTS_START_SEARCH_IN_ANGLED_AREA(float x1, float y1, float z1, float x2, float y2, float z2, float width, int interiorFlags, float scale, int duration);
	void SPAWNPOINTS_CANCEL_SEARCH();
	BOOL SPAWNPOINTS_IS_SEARCH_ACTIVE();
	BOOL SPAWNPOINTS_IS_SEARCH_COMPLETE();
	BOOL SPAWNPOINTS_IS_SEARCH_FAILED();
	int SPAWNPOINTS_GET_NUM_SEARCH_RESULTS();
	void SPAWNPOINTS_GET_SEARCH_RESULT(int randomInt, float* x, float* y, float* z);
	void SPAWNPOINTS_GET_SEARCH_RESULT_FLAGS(int p0, int* p1);
	void SET_IK_TARGET(Ped ped, int ikIndex, Entity entityLookAt, int boneLookAt, float offsetX, float offsetY, float offsetZ, Any p7, int blendInDuration, int blendOutDuration);
	void FORCE_INSTANT_LEG_IK_SETUP(Ped ped);
	void REQUEST_ACTION_MODE_ASSET(const char* asset);
	BOOL HAS_ACTION_MODE_ASSET_LOADED(const char* asset);
	void REMOVE_ACTION_MODE_ASSET(const char* asset);
	void REQUEST_STEALTH_MODE_ASSET(const char* asset);
	BOOL HAS_STEALTH_MODE_ASSET_LOADED(const char* asset);
	void REMOVE_STEALTH_MODE_ASSET(const char* asset);
	void SET_PED_LOD_MULTIPLIER(Ped ped, float multiplier);
	void SET_PED_CAN_LOSE_PROPS_ON_DAMAGE(Ped ped, BOOL toggle, int p2);
	void SET_FORCE_FOOTSTEP_UPDATE(Ped ped, BOOL toggle);
	void SET_FORCE_STEP_TYPE(Ped ped, BOOL p1, int type, int p3);
	BOOL IS_ANY_HOSTILE_PED_NEAR_POINT(Ped ped, float x, float y, float z, float radius);
	void SET_PED_CAN_PLAY_IN_CAR_IDLES(Ped ped, BOOL toggle);
	BOOL IS_TARGET_PED_IN_PERCEPTION_AREA(Ped ped, Ped targetPed, float p2, float p3, float p4, float p5);
	void SET_POP_CONTROL_SPHERE_THIS_FRAME(float x, float y, float z, float min, float max);
	void FORCE_ZERO_MASS_IN_COLLISIONS(Ped ped);
	void SET_DISABLE_HIGH_FALL_DEATH(Ped ped, BOOL toggle);
	void SET_PED_PHONE_PALETTE_IDX(Any p0, Any p1);
	void SET_PED_STEER_BIAS(Ped ped, float value);
	BOOL IS_PED_SWITCHING_WEAPON(Ped Ped);
	void SET_PED_TREATED_AS_FRIENDLY(Any p0, Any p1, Any p2);
	void SET_DISABLE_PED_MAP_COLLISION(Ped ped);
	void ENABLE_MP_LIGHT(Ped ped, BOOL toggle);
	BOOL GET_MP_LIGHT_ENABLED(Ped ped);
	void CLEAR_COVER_POINT_FOR_PED(Ped ped);
	void SET_ALLOW_STUNT_JUMP_CAMERA(Ped ped, BOOL toggle);
}

namespace PHYSICS
{
	int ADD_ROPE(float x, float y, float z, float rotX, float rotY, float rotZ, float length, int ropeType, float maxLength, float minLength, float windingSpeed, BOOL p11, BOOL p12, BOOL rigid, float p14, BOOL breakWhenShot, Any* unkPtr);
	void DELETE_ROPE(int* ropeId);
	void DELETE_CHILD_ROPE(int ropeId);
	BOOL DOES_ROPE_EXIST(int* ropeId);
	void ROPE_DRAW_ENABLED(int* ropeId, BOOL p1);
	void ROPE_DRAW_SHADOW_ENABLED(int* ropeId, BOOL toggle);
	void LOAD_ROPE_DATA(int ropeId, const char* rope_preset);
	void PIN_ROPE_VERTEX(int ropeId, int vertex, float x, float y, float z);
	void UNPIN_ROPE_VERTEX(int ropeId, int vertex);
	int GET_ROPE_VERTEX_COUNT(int ropeId);
	void ATTACH_ENTITIES_TO_ROPE(int ropeId, Entity ent1, Entity ent2, float ent1_x, float ent1_y, float ent1_z, float ent2_x, float ent2_y, float ent2_z, float length, BOOL p10, BOOL p11, Any* p12, Any* p13);
	void ATTACH_ROPE_TO_ENTITY(int ropeId, Entity entity, float x, float y, float z, BOOL p5);
	void DETACH_ROPE_FROM_ENTITY(int ropeId, Entity entity);
	void ROPE_SET_UPDATE_PINVERTS(int ropeId);
	void ROPE_SET_UPDATE_ORDER(int ropeId, Any p1);
	void ROPE_SET_SMOOTH_REELIN(int ropeId, BOOL p1);
	BOOL IS_ROPE_ATTACHED_AT_BOTH_ENDS(int* ropeId);
	Vector3 GET_ROPE_LAST_VERTEX_COORD(int ropeId);
	Vector3 GET_ROPE_VERTEX_COORD(int ropeId, int vertex);
	void START_ROPE_WINDING(int ropeId);
	void STOP_ROPE_WINDING(int ropeId);
	void START_ROPE_UNWINDING_FRONT(int ropeId);
	void STOP_ROPE_UNWINDING_FRONT(int ropeId);
	void ROPE_CONVERT_TO_SIMPLE(int ropeId);
	void ROPE_LOAD_TEXTURES();
	BOOL ROPE_ARE_TEXTURES_LOADED();
	void ROPE_UNLOAD_TEXTURES();
	BOOL DOES_SCRIPT_OWN_ROPE(int ropeId);
	void ROPE_ATTACH_VIRTUAL_BOUND_GEOM(int ropeId, int p1, float p2, float p3, float p4, float p5, float p6, float p7, float p8, float p9, float p10, float p11, float p12, float p13);
	void ROPE_CHANGE_SCRIPT_OWNER(Any p0, BOOL p1, BOOL p2);
	void ROPE_SET_REFFRAMEVELOCITY_COLLIDERORDER(int ropeId, int p1);
	float ROPE_GET_DISTANCE_BETWEEN_ENDS(int ropeId);
	void ROPE_FORCE_LENGTH(int ropeId, float length);
	void ROPE_RESET_LENGTH(int ropeId, float length);
	void APPLY_IMPULSE_TO_CLOTH(float posX, float posY, float posZ, float vecX, float vecY, float vecZ, float impulse);
	void SET_DAMPING(Entity entity, int vertex, float value);
	void ACTIVATE_PHYSICS(Entity entity);
	void SET_CGOFFSET(Entity entity, float x, float y, float z);
	Vector3 GET_CGOFFSET(Entity entity);
	void SET_CG_AT_BOUNDCENTER(Entity entity);
	void BREAK_ENTITY_GLASS(Entity entity, float p1, float p2, float p3, float p4, float p5, float p6, float p7, float p8, Any p9, BOOL p10);
	BOOL GET_IS_ENTITY_A_FRAG(Object object);
	void SET_DISABLE_BREAKING(Object object, BOOL toggle);
	void RESET_DISABLE_BREAKING(Object object);
	void SET_DISABLE_FRAG_DAMAGE(Object object, BOOL toggle);
	void SET_USE_KINEMATIC_PHYSICS(Entity entity, BOOL toggle);
	void SET_IN_STUNT_MODE(BOOL p0);
	void SET_IN_ARENA_MODE(BOOL toggle);
}

namespace PLAYER
{
	Ped GET_PLAYER_PED(Player player);
	Ped GET_PLAYER_PED_SCRIPT_INDEX(Player player);
	void SET_PLAYER_MODEL(Player player, Hash model);
	void CHANGE_PLAYER_PED(Player player, Ped ped, BOOL p2, BOOL resetDamage);
	void GET_PLAYER_RGB_COLOUR(Player player, int* r, int* g, int* b);
	int GET_NUMBER_OF_PLAYERS();
	int GET_PLAYER_TEAM(Player player);
	void SET_PLAYER_TEAM(Player player, int team);
	int GET_NUMBER_OF_PLAYERS_IN_TEAM(int team);
	const char* GET_PLAYER_NAME(Player player);
	float GET_WANTED_LEVEL_RADIUS(Player player);
	Vector3 GET_PLAYER_WANTED_CENTRE_POSITION(Player player);
	void SET_PLAYER_WANTED_CENTRE_POSITION(Player player, Vector3* position, BOOL p2, BOOL p3);
	int GET_WANTED_LEVEL_THRESHOLD(int wantedLevel);
	void SET_PLAYER_WANTED_LEVEL(Player player, int wantedLevel, BOOL disableNoMission);
	void SET_PLAYER_WANTED_LEVEL_NO_DROP(Player player, int wantedLevel, BOOL p2);
	void SET_PLAYER_WANTED_LEVEL_NOW(Player player, BOOL p1);
	BOOL ARE_PLAYER_FLASHING_STARS_ABOUT_TO_DROP(Player player);
	BOOL ARE_PLAYER_STARS_GREYED_OUT(Player player);
	BOOL IS_WANTED_AND_HAS_BEEN_SEEN_BY_COPS(Player player);
	void SET_DISPATCH_COPS_FOR_PLAYER(Player player, BOOL toggle);
	BOOL IS_PLAYER_WANTED_LEVEL_GREATER(Player player, int wantedLevel);
	void CLEAR_PLAYER_WANTED_LEVEL(Player player);
	BOOL IS_PLAYER_DEAD(Player player);
	BOOL IS_PLAYER_PRESSING_HORN(Player player);
	void SET_PLAYER_CONTROL(Player player, BOOL bHasControl, int flags);
	int GET_PLAYER_WANTED_LEVEL(Player player);
	void SET_MAX_WANTED_LEVEL(int maxWantedLevel);
	void SET_POLICE_RADAR_BLIPS(BOOL toggle);
	void SET_POLICE_IGNORE_PLAYER(Player player, BOOL toggle);
	BOOL IS_PLAYER_PLAYING(Player player);
	void SET_EVERYONE_IGNORE_PLAYER(Player player, BOOL toggle);
	void SET_ALL_RANDOM_PEDS_FLEE(Player player, BOOL toggle);
	void SET_ALL_RANDOM_PEDS_FLEE_THIS_FRAME(Player player);
	void SET_ALL_NEUTRAL_RANDOM_PEDS_FLEE(Player player, BOOL toggle);
	void SET_ALL_NEUTRAL_RANDOM_PEDS_FLEE_THIS_FRAME(Player player);
	void SET_LAW_PEDS_CAN_ATTACK_NON_WANTED_PLAYER_THIS_FRAME(Player player);
	void SET_IGNORE_LOW_PRIORITY_SHOCKING_EVENTS(Player player, BOOL toggle);
	void SET_WANTED_LEVEL_MULTIPLIER(float multiplier);
	void SET_WANTED_LEVEL_DIFFICULTY(Player player, float difficulty);
	void RESET_WANTED_LEVEL_DIFFICULTY(Player player);
	int GET_WANTED_LEVEL_TIME_TO_ESCAPE();
	void SET_WANTED_LEVEL_HIDDEN_ESCAPE_TIME(Player player, int wantedLevel, int lossTime);
	void RESET_WANTED_LEVEL_HIDDEN_ESCAPE_TIME(Player player);
	void START_FIRING_AMNESTY(int duration);
	void REPORT_CRIME(Player player, int crimeType, int wantedLvlThresh);
	void SUPPRESS_CRIME_THIS_FRAME(Player player, int crimeType);
	void UPDATE_WANTED_POSITION_THIS_FRAME(Player player);
	void SUPPRESS_LOSING_WANTED_LEVEL_IF_HIDDEN_THIS_FRAME(Player player);
	void ALLOW_EVASION_HUD_IF_DISABLING_HIDDEN_EVASION_THIS_FRAME(Player player, Any p1);
	void FORCE_START_HIDDEN_EVASION(Player player);
	void SUPPRESS_WITNESSES_CALLING_POLICE_THIS_FRAME(Player player);
	void REPORT_POLICE_SPOTTED_PLAYER(Player player);
	void SET_LAW_RESPONSE_DELAY_OVERRIDE(float p0);
	void RESET_LAW_RESPONSE_DELAY_OVERRIDE();
	BOOL CAN_PLAYER_START_MISSION(Player player);
	BOOL IS_PLAYER_READY_FOR_CUTSCENE(Player player);
	BOOL IS_PLAYER_TARGETTING_ENTITY(Player player, Entity entity);
	BOOL GET_PLAYER_TARGET_ENTITY(Player player, Entity* entity);
	BOOL IS_PLAYER_FREE_AIMING(Player player);
	BOOL IS_PLAYER_FREE_AIMING_AT_ENTITY(Player player, Entity entity);
	BOOL GET_ENTITY_PLAYER_IS_FREE_AIMING_AT(Player player, Entity* entity);
	void SET_PLAYER_LOCKON_RANGE_OVERRIDE(Player player, float range);
	void SET_PLAYER_CAN_DO_DRIVE_BY(Player player, BOOL toggle);
	void SET_PLAYER_CAN_BE_HASSLED_BY_GANGS(Player player, BOOL toggle);
	void SET_PLAYER_CAN_USE_COVER(Player player, BOOL toggle);
	int GET_MAX_WANTED_LEVEL();
	BOOL IS_PLAYER_TARGETTING_ANYTHING(Player player);
	void SET_PLAYER_SPRINT(Player player, BOOL toggle);
	void RESET_PLAYER_STAMINA(Player player);
	void RESTORE_PLAYER_STAMINA(Player player, float p1);
	float GET_PLAYER_SPRINT_STAMINA_REMAINING(Player player);
	float GET_PLAYER_SPRINT_TIME_REMAINING(Player player);
	float GET_PLAYER_UNDERWATER_TIME_REMAINING(Player player);
	float SET_PLAYER_UNDERWATER_BREATH_PERCENT_REMAINING(Player player, float time);
	int GET_PLAYER_GROUP(Player player);
	int GET_PLAYER_MAX_ARMOUR(Player player);
	BOOL IS_PLAYER_CONTROL_ON(Player player);
	BOOL GET_ARE_CAMERA_CONTROLS_DISABLED();
	BOOL IS_PLAYER_SCRIPT_CONTROL_ON(Player player);
	BOOL IS_PLAYER_CLIMBING(Player player);
	BOOL IS_PLAYER_BEING_ARRESTED(Player player, BOOL atArresting);
	void RESET_PLAYER_ARREST_STATE(Player player);
	Vehicle GET_PLAYERS_LAST_VEHICLE();
	Player GET_PLAYER_INDEX();
	Player INT_TO_PLAYERINDEX(int value);
	int INT_TO_PARTICIPANTINDEX(int value);
	int GET_TIME_SINCE_PLAYER_HIT_VEHICLE(Player player);
	int GET_TIME_SINCE_PLAYER_HIT_PED(Player player);
	int GET_TIME_SINCE_PLAYER_DROVE_ON_PAVEMENT(Player player);
	int GET_TIME_SINCE_PLAYER_DROVE_AGAINST_TRAFFIC(Player player);
	BOOL IS_PLAYER_FREE_FOR_AMBIENT_TASK(Player player);
	Player PLAYER_ID();
	Ped PLAYER_PED_ID();
	int NETWORK_PLAYER_ID_TO_INT();
	BOOL HAS_FORCE_CLEANUP_OCCURRED(int cleanupFlags);
	void FORCE_CLEANUP(int cleanupFlags);
	void FORCE_CLEANUP_FOR_ALL_THREADS_WITH_THIS_NAME(const char* name, int cleanupFlags);
	void FORCE_CLEANUP_FOR_THREAD_WITH_THIS_ID(int id, int cleanupFlags);
	int GET_CAUSE_OF_MOST_RECENT_FORCE_CLEANUP();
	void SET_PLAYER_MAY_ONLY_ENTER_THIS_VEHICLE(Player player, Vehicle vehicle);
	void SET_PLAYER_MAY_NOT_ENTER_ANY_VEHICLE(Player player);
	BOOL GIVE_ACHIEVEMENT_TO_PLAYER(int achievementId);
	BOOL SET_ACHIEVEMENT_PROGRESS(int achievementId, int progress);
	int GET_ACHIEVEMENT_PROGRESS(int achievementId);
	BOOL HAS_ACHIEVEMENT_BEEN_PASSED(int achievementId);
	BOOL IS_PLAYER_ONLINE();
	BOOL IS_PLAYER_LOGGING_IN_NP();
	void DISPLAY_SYSTEM_SIGNIN_UI(BOOL p0);
	BOOL IS_SYSTEM_UI_BEING_DISPLAYED();
	void SET_PLAYER_INVINCIBLE(Player player, BOOL toggle);
	BOOL GET_PLAYER_INVINCIBLE(Player player);
	BOOL GET_PLAYER_DEBUG_INVINCIBLE(Player player);
	void SET_PLAYER_INVINCIBLE_BUT_HAS_REACTIONS(Player player, BOOL toggle);
	void SET_PLAYER_CAN_COLLECT_DROPPED_MONEY(Player player, BOOL p1);
	void REMOVE_PLAYER_HELMET(Player player, BOOL p2);
	void GIVE_PLAYER_RAGDOLL_CONTROL(Player player, BOOL toggle);
	void SET_PLAYER_LOCKON(Player player, BOOL toggle);
	void SET_PLAYER_TARGETING_MODE(int targetMode);
	void SET_PLAYER_TARGET_LEVEL(int targetLevel);
	BOOL GET_IS_USING_FPS_THIRD_PERSON_COVER();
	BOOL GET_IS_USING_HOOD_CAMERA();
	void CLEAR_PLAYER_HAS_DAMAGED_AT_LEAST_ONE_PED(Player player);
	BOOL HAS_PLAYER_DAMAGED_AT_LEAST_ONE_PED(Player player);
	void CLEAR_PLAYER_HAS_DAMAGED_AT_LEAST_ONE_NON_ANIMAL_PED(Player player);
	BOOL HAS_PLAYER_DAMAGED_AT_LEAST_ONE_NON_ANIMAL_PED(Player player);
	void SET_AIR_DRAG_MULTIPLIER_FOR_PLAYERS_VEHICLE(Player player, float multiplier);
	void SET_SWIM_MULTIPLIER_FOR_PLAYER(Player player, float multiplier);
	void SET_RUN_SPRINT_MULTIPLIER_FOR_PLAYER(Player player, float multiplier);
	int GET_TIME_SINCE_LAST_ARREST();
	int GET_TIME_SINCE_LAST_DEATH();
	void ASSISTED_MOVEMENT_CLOSE_ROUTE();
	void ASSISTED_MOVEMENT_FLUSH_ROUTE();
	void SET_PLAYER_FORCED_AIM(Player player, BOOL toggle);
	void SET_PLAYER_FORCED_ZOOM(Player player, BOOL toggle);
	void SET_PLAYER_FORCE_SKIP_AIM_INTRO(Player player, BOOL toggle);
	void DISABLE_PLAYER_FIRING(Player player, BOOL toggle);
	void DISABLE_PLAYER_THROW_GRENADE_WHILE_USING_GUN();
	void SET_DISABLE_AMBIENT_MELEE_MOVE(Player player, BOOL toggle);
	void SET_PLAYER_MAX_ARMOUR(Player player, int value);
	void SPECIAL_ABILITY_ACTIVATE(Player player, int p1);
	void SET_SPECIAL_ABILITY_MP(Player player, int p1, Any p2);
	void SPECIAL_ABILITY_DEACTIVATE_MP(Player player, int p1);
	void SPECIAL_ABILITY_DEACTIVATE(Player player, Any p1);
	void SPECIAL_ABILITY_DEACTIVATE_FAST(Player player, Any p1);
	void SPECIAL_ABILITY_RESET(Player player, Any p1);
	void SPECIAL_ABILITY_CHARGE_ON_MISSION_FAILED(Player player, Any p1);
	void SPECIAL_ABILITY_CHARGE_SMALL(Player player, BOOL p1, BOOL p2, Any p3);
	void SPECIAL_ABILITY_CHARGE_MEDIUM(Player player, BOOL p1, BOOL p2, Any p3);
	void SPECIAL_ABILITY_CHARGE_LARGE(Player player, BOOL p1, BOOL p2, Any p3);
	void SPECIAL_ABILITY_CHARGE_CONTINUOUS(Player player, Ped p1, Any p2);
	void SPECIAL_ABILITY_CHARGE_ABSOLUTE(Player player, int p1, BOOL p2, Any p3);
	void SPECIAL_ABILITY_CHARGE_NORMALIZED(Player player, float normalizedValue, BOOL p2, Any p3);
	void SPECIAL_ABILITY_FILL_METER(Player player, BOOL p1, Any p2);
	void SPECIAL_ABILITY_DEPLETE_METER(Player player, BOOL p1, Any p2);
	void SPECIAL_ABILITY_LOCK(Hash playerModel, Any p1);
	void SPECIAL_ABILITY_UNLOCK(Hash playerModel, Any p1);
	BOOL IS_SPECIAL_ABILITY_UNLOCKED(Hash playerModel);
	BOOL IS_SPECIAL_ABILITY_ACTIVE(Player player, Any p1);
	BOOL IS_SPECIAL_ABILITY_METER_FULL(Player player, Any p1);
	void ENABLE_SPECIAL_ABILITY(Player player, BOOL toggle, Any p2);
	BOOL IS_SPECIAL_ABILITY_ENABLED(Player player, Any p1);
	void SET_SPECIAL_ABILITY_MULTIPLIER(float multiplier);
	void UPDATE_SPECIAL_ABILITY_FROM_STAT(Player player, Any p1);
	BOOL GET_IS_PLAYER_DRIVING_ON_HIGHWAY(Player player);
	BOOL GET_IS_PLAYER_DRIVING_WRECKLESS(Player player, int p1);
	BOOL GET_IS_MOPPING_AREA_FREE_IN_FRONT_OF_PLAYER(Player player, float p1);
	void START_PLAYER_TELEPORT(Player player, float x, float y, float z, float heading, BOOL p5, BOOL findCollisionLand, BOOL p7);
	BOOL UPDATE_PLAYER_TELEPORT(Player player);
	void STOP_PLAYER_TELEPORT();
	BOOL IS_PLAYER_TELEPORT_ACTIVE();
	float GET_PLAYER_CURRENT_STEALTH_NOISE(Player player);
	void SET_PLAYER_HEALTH_RECHARGE_MULTIPLIER(Player player, float regenRate);
	float GET_PLAYER_HEALTH_RECHARGE_MAX_PERCENT(Player player);
	void SET_PLAYER_HEALTH_RECHARGE_MAX_PERCENT(Player player, float limit);
	void DISABLE_PLAYER_HEALTH_RECHARGE(Player player);
	void SET_PLAYER_FALL_DISTANCE_TO_TRIGGER_RAGDOLL_OVERRIDE(Player player, float p1);
	void SET_PLAYER_WEAPON_DAMAGE_MODIFIER(Player player, float modifier);
	void SET_PLAYER_WEAPON_DEFENSE_MODIFIER(Player player, float modifier);
	void SET_PLAYER_WEAPON_MINIGUN_DEFENSE_MODIFIER(Player player, float modifier);
	void SET_PLAYER_MELEE_WEAPON_DAMAGE_MODIFIER(Player player, float modifier, BOOL p2);
	void SET_PLAYER_MELEE_WEAPON_DEFENSE_MODIFIER(Player player, float modifier);
	void SET_PLAYER_VEHICLE_DAMAGE_MODIFIER(Player player, float modifier);
	void SET_PLAYER_VEHICLE_DEFENSE_MODIFIER(Player player, float modifier);
	void SET_PLAYER_MAX_EXPLOSIVE_DAMAGE(Player player, float p1);
	void SET_PLAYER_EXPLOSIVE_DAMAGE_MODIFIER(Player player, Any p1);
	void SET_PLAYER_WEAPON_TAKEDOWN_DEFENSE_MODIFIER(Player player, float p1);
	void SET_PLAYER_PARACHUTE_TINT_INDEX(Player player, int tintIndex);
	void GET_PLAYER_PARACHUTE_TINT_INDEX(Player player, int* tintIndex);
	void SET_PLAYER_RESERVE_PARACHUTE_TINT_INDEX(Player player, int index);
	void GET_PLAYER_RESERVE_PARACHUTE_TINT_INDEX(Player player, int* index);
	void SET_PLAYER_PARACHUTE_PACK_TINT_INDEX(Player player, int tintIndex);
	void GET_PLAYER_PARACHUTE_PACK_TINT_INDEX(Player player, int* tintIndex);
	void SET_PLAYER_HAS_RESERVE_PARACHUTE(Player player);
	BOOL GET_PLAYER_HAS_RESERVE_PARACHUTE(Player player);
	void SET_PLAYER_CAN_LEAVE_PARACHUTE_SMOKE_TRAIL(Player player, BOOL enabled);
	void SET_PLAYER_PARACHUTE_SMOKE_TRAIL_COLOR(Player player, int r, int g, int b);
	void GET_PLAYER_PARACHUTE_SMOKE_TRAIL_COLOR(Player player, int* r, int* g, int* b);
	void SET_PLAYER_PHONE_PALETTE_IDX(Player player, int flags);
	void SET_PLAYER_NOISE_MULTIPLIER(Player player, float multiplier);
	void SET_PLAYER_SNEAKING_NOISE_MULTIPLIER(Player player, float multiplier);
	BOOL CAN_PED_HEAR_PLAYER(Player player, Ped ped);
	void SIMULATE_PLAYER_INPUT_GAIT(Player player, float amount, int gaitType, float speed, BOOL p4, BOOL p5, Any p6);
	void RESET_PLAYER_INPUT_GAIT(Player player);
	void SET_AUTO_GIVE_PARACHUTE_WHEN_ENTER_PLANE(Player player, BOOL toggle);
	void SET_AUTO_GIVE_SCUBA_GEAR_WHEN_EXIT_VEHICLE(Player player, BOOL toggle);
	void SET_PLAYER_STEALTH_PERCEPTION_MODIFIER(Player player, float value);
	BOOL IS_REMOTE_PLAYER_IN_NON_CLONED_VEHICLE(Player player);
	void INCREASE_PLAYER_JUMP_SUPPRESSION_RANGE(Player player);
	void SET_PLAYER_SIMULATE_AIMING(Player player, BOOL toggle);
	void SET_PLAYER_CLOTH_PIN_FRAMES(Player player, int p1);
	void SET_PLAYER_CLOTH_PACKAGE_INDEX(int index);
	void SET_PLAYER_CLOTH_LOCK_COUNTER(int value);
	void PLAYER_ATTACH_VIRTUAL_BOUND(float p0, float p1, float p2, float p3, float p4, float p5, float p6, float p7);
	void PLAYER_DETACH_VIRTUAL_BOUND();
	BOOL HAS_PLAYER_BEEN_SPOTTED_IN_STOLEN_VEHICLE(Player player);
	BOOL IS_PLAYER_BATTLE_AWARE(Player player);
	BOOL GET_PLAYER_RECEIVED_BATTLE_EVENT_RECENTLY(Player player, int p1, BOOL p2);
	void EXTEND_WORLD_BOUNDARY_FOR_PLAYER(float x, float y, float z);
	void RESET_WORLD_BOUNDARY_FOR_PLAYER();
	BOOL IS_PLAYER_RIDING_TRAIN(Player player);
	BOOL HAS_PLAYER_LEFT_THE_WORLD(Player player);
	void SET_PLAYER_LEAVE_PED_BEHIND(Player player, BOOL toggle);
	void SET_PLAYER_PARACHUTE_VARIATION_OVERRIDE(Player player, int p1, Any p2, Any p3, BOOL p4);
	void CLEAR_PLAYER_PARACHUTE_VARIATION_OVERRIDE(Player player);
	void SET_PLAYER_PARACHUTE_MODEL_OVERRIDE(Player player, Hash model);
	void SET_PLAYER_RESERVE_PARACHUTE_MODEL_OVERRIDE(Player player, Hash model);
	Hash GET_PLAYER_PARACHUTE_MODEL_OVERRIDE(Player player);
	Hash GET_PLAYER_RESERVE_PARACHUTE_MODEL_OVERRIDE(Player player);
	void CLEAR_PLAYER_PARACHUTE_MODEL_OVERRIDE(Player player);
	void CLEAR_PLAYER_RESERVE_PARACHUTE_MODEL_OVERRIDE(Player player);
	void SET_PLAYER_PARACHUTE_PACK_MODEL_OVERRIDE(Player player, Hash model);
	void CLEAR_PLAYER_PARACHUTE_PACK_MODEL_OVERRIDE(Player player);
	void DISABLE_PLAYER_VEHICLE_REWARDS(Player player);
	void SET_PLAYER_SPECTATED_VEHICLE_RADIO_OVERRIDE(BOOL p0);
	void SET_PLAYER_BLUETOOTH_STATE(Player player, BOOL state);
	BOOL IS_PLAYER_BLUETOOTH_ENABLE(Player player);
	void DISABLE_CAMERA_VIEW_MODE_CYCLE(Player player);
	int GET_PLAYER_FAKE_WANTED_LEVEL(Player player);
	void SET_PLAYER_CAN_DAMAGE_PLAYER(Player player1, Player player2, BOOL toggle);
	void SET_APPLY_WAYPOINT_OF_PLAYER(Player player, int hudColor);
	BOOL IS_PLAYER_VEHICLE_WEAPON_TOGGLED_TO_NON_HOMING(Any p0);
	void SET_PLAYER_VEHICLE_WEAPON_TO_NON_HOMING(Any p0);
	void SET_PLAYER_HOMING_DISABLED_FOR_ALL_VEHICLE_WEAPONS(Any p0, Any p1);
	void ADD_PLAYER_TARGETABLE_ENTITY(Player player, Entity entity);
	void REMOVE_PLAYER_TARGETABLE_ENTITY(Player player, Entity entity);
	void SET_PLAYER_PREVIOUS_VARIATION_DATA(Player player, int p1, int p2, Any p3, Any p4, Any p5);
	void REMOVE_SCRIPT_FIRE_POSITION();
	void SET_SCRIPT_FIRE_POSITION(float coordX, float coordY, float coordZ);
}

namespace RECORDING
{
	void REPLAY_START_EVENT(int p0);
	void REPLAY_STOP_EVENT();
	void REPLAY_CANCEL_EVENT();
	void REPLAY_RECORD_BACK_FOR_TIME(float p0, float p1, int p2);
	void REPLAY_CHECK_FOR_EVENT_THIS_FRAME(const char* missionNameLabel, Any p1);
	void REPLAY_PREVENT_RECORDING_THIS_FRAME();
	void REPLAY_RESET_EVENT_INFO();
	void REPLAY_DISABLE_CAMERA_MOVEMENT_THIS_FRAME();
	void RECORD_GREATEST_MOMENT(int p0, int p1, int p2);
	void START_REPLAY_RECORDING(int mode);
	void STOP_REPLAY_RECORDING();
	void CANCEL_REPLAY_RECORDING();
	BOOL SAVE_REPLAY_RECORDING();
	BOOL IS_REPLAY_RECORDING();
	BOOL IS_REPLAY_INITIALIZED();
	BOOL IS_REPLAY_AVAILABLE();
	BOOL IS_REPLAY_RECORD_SPACE_AVAILABLE(BOOL p0);
}

namespace REPLAY
{
	void REGISTER_EFFECT_FOR_REPLAY_EDITOR(const char* p0, BOOL p1);
	BOOL REPLAY_SYSTEM_HAS_REQUESTED_A_SCRIPT_CLEANUP();
	void SET_SCRIPTS_HAVE_CLEANED_UP_FOR_REPLAY_SYSTEM();
	void SET_REPLAY_SYSTEM_PAUSED_FOR_SAVE(BOOL p0);
	void REPLAY_CONTROL_SHUTDOWN();
	void ACTIVATE_ROCKSTAR_EDITOR(int p0);
}

namespace SAVEMIGRATION
{
	BOOL SAVEMIGRATION_IS_MP_ENABLED();
	BOOL SAVEMIGRATION_MP_REQUEST_ACCOUNTS();
	int SAVEMIGRATION_MP_GET_ACCOUNTS_STATUS();
	int SAVEMIGRATION_MP_NUM_ACCOUNTS();
	BOOL SAVEMIGRATION_MP_GET_ACCOUNT(int p0, Any* p1);
	BOOL SAVEMIGRATION_MP_REQUEST_STATUS();
	int SAVEMIGRATION_MP_GET_STATUS();
}

namespace SCRIPT
{
	void REQUEST_SCRIPT(const char* scriptName);
	void SET_SCRIPT_AS_NO_LONGER_NEEDED(const char* scriptName);
	BOOL HAS_SCRIPT_LOADED(const char* scriptName);
	BOOL DOES_SCRIPT_EXIST(const char* scriptName);
	void REQUEST_SCRIPT_WITH_NAME_HASH(Hash scriptHash);
	void SET_SCRIPT_WITH_NAME_HASH_AS_NO_LONGER_NEEDED(Hash scriptHash);
	BOOL HAS_SCRIPT_WITH_NAME_HASH_LOADED(Hash scriptHash);
	BOOL DOES_SCRIPT_WITH_NAME_HASH_EXIST(Hash scriptHash);
	void TERMINATE_THREAD(int threadId);
	BOOL IS_THREAD_ACTIVE(int threadId);
	const char* GET_NAME_OF_SCRIPT_WITH_THIS_ID(int threadId);
	void SCRIPT_THREAD_ITERATOR_RESET();
	int SCRIPT_THREAD_ITERATOR_GET_NEXT_THREAD_ID();
	int GET_ID_OF_THIS_THREAD();
	void TERMINATE_THIS_THREAD();
	int GET_NUMBER_OF_THREADS_RUNNING_THE_SCRIPT_WITH_THIS_HASH(Hash scriptHash);
	const char* GET_THIS_SCRIPT_NAME();
	Hash GET_HASH_OF_THIS_SCRIPT_NAME();
	int GET_NUMBER_OF_EVENTS(int eventGroup);
	BOOL GET_EVENT_EXISTS(int eventGroup, int eventIndex);
	int GET_EVENT_AT_INDEX(int eventGroup, int eventIndex);
	BOOL GET_EVENT_DATA(int eventGroup, int eventIndex, Any* eventData, int eventDataSize);
	void TRIGGER_SCRIPT_EVENT(int eventGroup, Any* eventData, int eventDataSize, int playerBits);
	void SHUTDOWN_LOADING_SCREEN();
	void SET_NO_LOADING_SCREEN(BOOL toggle);
	BOOL GET_NO_LOADING_SCREEN();
	void COMMIT_TO_LOADINGSCREEN_SELCTION();
	BOOL BG_IS_EXITFLAG_SET();
	void BG_SET_EXITFLAG_RESPONSE();
	void BG_START_CONTEXT_HASH(Hash contextHash);
	void BG_END_CONTEXT_HASH(Hash contextHash);
	void BG_START_CONTEXT(const char* contextName);
	void BG_END_CONTEXT(const char* contextName);
	BOOL BG_DOES_LAUNCH_PARAM_EXIST(int scriptIndex, const char* p1);
	int BG_GET_LAUNCH_PARAM_VALUE(int scriptIndex, const char* p1);
	int BG_GET_SCRIPT_ID_FROM_NAME_HASH(Hash p0);
	void SEND_TU_SCRIPT_EVENT(int eventGroup, Any* eventData, int eventDataSize, int playerBits);
}

namespace SECURITY
{
	void REGISTER_SCRIPT_VARIABLE(Any* variable);
	void UNREGISTER_SCRIPT_VARIABLE(Any* variable);
	void FORCE_CHECK_SCRIPT_VARIABLES();
}

namespace SHAPETEST
{
	int START_SHAPE_TEST_LOS_PROBE(float x1, float y1, float z1, float x2, float y2, float z2, int flags, Entity entity, int p8);
	int START_EXPENSIVE_SYNCHRONOUS_SHAPE_TEST_LOS_PROBE(float x1, float y1, float z1, float x2, float y2, float z2, int flags, Entity entity, int p8);
	int START_SHAPE_TEST_BOUNDING_BOX(Entity entity, int flags1, int flags2);
	int START_SHAPE_TEST_BOX(float x, float y, float z, float dimX, float dimY, float dimZ, float rotX, float rotY, float rotZ, Any p9, int flags, Entity entity, Any p12);
	int START_SHAPE_TEST_BOUND(Entity entity, int flags1, int flags2);
	int START_SHAPE_TEST_CAPSULE(float x1, float y1, float z1, float x2, float y2, float z2, float radius, int flags, Entity entity, int p9);
	int START_SHAPE_TEST_SWEPT_SPHERE(float x1, float y1, float z1, float x2, float y2, float z2, float radius, int flags, Entity entity, Any p9);
	int START_SHAPE_TEST_MOUSE_CURSOR_LOS_PROBE(Vector3* pVec1, Vector3* pVec2, int flag, Entity entity, int flag2);
	int GET_SHAPE_TEST_RESULT(int shapeTestHandle, BOOL* hit, Vector3* endCoords, Vector3* surfaceNormal, Entity* entityHit);
	int GET_SHAPE_TEST_RESULT_INCLUDING_MATERIAL(int shapeTestHandle, BOOL* hit, Vector3* endCoords, Vector3* surfaceNormal, Hash* materialHash, Entity* entityHit);
	void RELEASE_SCRIPT_GUID_FROM_ENTITY(Entity entityHit);
}

namespace SOCIALCLUB
{
	int SC_INBOX_GET_TOTAL_NUM_MESSAGES();
	Hash SC_INBOX_GET_MESSAGE_TYPE_AT_INDEX(int msgIndex);
	BOOL SC_INBOX_GET_MESSAGE_IS_READ_AT_INDEX(int msgIndex);
	BOOL SC_INBOX_SET_MESSAGE_AS_READ_AT_INDEX(int msgIndex);
	BOOL SC_INBOX_MESSAGE_GET_DATA_INT(int p0, const char* context, int* out);
	BOOL SC_INBOX_MESSAGE_GET_DATA_BOOL(int p0, const char* p1);
	BOOL SC_INBOX_MESSAGE_GET_DATA_STRING(int p0, const char* context, char* out);
	BOOL SC_INBOX_MESSAGE_DO_APPLY(int p0);
	const char* SC_INBOX_MESSAGE_GET_RAW_TYPE_AT_INDEX(int p0);
	void SC_INBOX_MESSAGE_PUSH_GAMER_T0_RECIP_LIST(Any* gamerHandle);
	void SC_INBOX_SEND_UGCSTATUPDATE_TO_RECIP_LIST(Any* data);
	BOOL SC_INBOX_MESSAGE_GET_UGCDATA(int p0, Any* p1);
	BOOL SC_INBOX_SEND_BOUNTY_TO_RECIP_LIST(Any* data);
	BOOL SC_INBOX_GET_BOUNTY_DATA_AT_INDEX(int index, Any* outData);
	void SC_EMAIL_RETRIEVE_EMAILS(int offset, int limit);
	int SC_EMAIL_GET_RETRIEVAL_STATUS();
	int SC_EMAIL_GET_NUM_RETRIEVED_EMAILS();
	BOOL SC_EMAIL_GET_EMAIL_AT_INDEX(int p0, Any* p1);
	void SC_EMAIL_DELETE_EMAILS(Any* p0, Any p1);
	void SC_EMAIL_MESSAGE_PUSH_GAMER_TO_RECIP_LIST(Any* gamerHandle);
	void SC_EMAIL_MESSAGE_CLEAR_RECIP_LIST();
	void SC_EMAIL_SEND_EMAIL(const char* p0);
	BOOL SC_EMAIL_SET_CURRENT_EMAIL_TAG(Any p0);
	void SC_CACHE_NEW_ROCKSTAR_MSGS(BOOL toggle);
	BOOL SC_HAS_NEW_ROCKSTAR_MSG();
	const char* SC_GET_NEW_ROCKSTAR_MSG();
	BOOL SC_PRESENCE_ATTR_SET_INT(Hash attrHash, int value);
	BOOL SC_PRESENCE_ATTR_SET_FLOAT(Hash attrHash, float value);
	BOOL SC_PRESENCE_ATTR_SET_STRING(Hash attrHash, const char* value);
	BOOL SC_PRESENCE_SET_ACTIVITY_RATING(Any p0, float p1);
	BOOL SC_GAMERDATA_GET_INT(const char* name, int* value);
	BOOL SC_GAMERDATA_GET_FLOAT(const char* name, float* value);
	BOOL SC_GAMERDATA_GET_BOOL(const char* name);
	BOOL SC_GAMERDATA_GET_STRING(const char* name, char* value);
	BOOL SC_GAMERDATA_GET_ACTIVE_XP_BONUS(float* value);
	BOOL SC_PROFANITY_CHECK_STRING(const char* string, int* token);
	BOOL SC_PROFANITY_CHECK_STRING_UGC(const char* string, int* token);
	BOOL SC_PROFANITY_GET_CHECK_IS_VALID(int token);
	BOOL SC_PROFANITY_GET_CHECK_IS_PENDING(int token);
	BOOL SC_PROFANITY_GET_STRING_PASSED(int token);
	int SC_PROFANITY_GET_STRING_STATUS(int token);
	BOOL SC_LICENSEPLATE_CHECK_STRING(const char* p0, int* p1);
	BOOL SC_LICENSEPLATE_GET_CHECK_IS_VALID(Any p0);
	BOOL SC_LICENSEPLATE_GET_CHECK_IS_PENDING(Any p0);
	int SC_LICENSEPLATE_GET_COUNT(int token);
	const char* SC_LICENSEPLATE_GET_PLATE(int token, int plateIndex);
	const char* SC_LICENSEPLATE_GET_PLATE_DATA(int token, int plateIndex);
	BOOL SC_LICENSEPLATE_SET_PLATE_DATA(const char* oldPlateText, const char* newPlateText, Any* plateData);
	BOOL SC_LICENSEPLATE_ADD(const char* plateText, Any* plateData, int* token);
	BOOL SC_LICENSEPLATE_GET_ADD_IS_PENDING(int token);
	int SC_LICENSEPLATE_GET_ADD_STATUS(int token);
	BOOL SC_LICENSEPLATE_ISVALID(const char* plateText, int* token);
	BOOL SC_LICENSEPLATE_GET_ISVALID_IS_PENDING(int token);
	int SC_LICENSEPLATE_GET_ISVALID_STATUS(int token);
	BOOL SC_COMMUNITY_EVENT_IS_ACTIVE();
	int SC_COMMUNITY_EVENT_GET_EVENT_ID();
	BOOL SC_COMMUNITY_EVENT_GET_EXTRA_DATA_INT(const char* p0, int* p1);
	BOOL SC_COMMUNITY_EVENT_GET_EXTRA_DATA_FLOAT(const char* p0, float* p1);
	BOOL SC_COMMUNITY_EVENT_GET_EXTRA_DATA_STRING(const char* p0, char* p1);
	BOOL SC_COMMUNITY_EVENT_GET_DISPLAY_NAME(char* p0);
	BOOL SC_COMMUNITY_EVENT_IS_ACTIVE_FOR_TYPE(const char* p0);
	int SC_COMMUNITY_EVENT_GET_EVENT_ID_FOR_TYPE(const char* p0);
	BOOL SC_COMMUNITY_EVENT_GET_EXTRA_DATA_INT_FOR_TYPE(const char* p0, int* p1, const char* p2);
	BOOL SC_COMMUNITY_EVENT_GET_EXTRA_DATA_FLOAT_FOR_TYPE(const char* p0, float* p1, const char* p2);
	BOOL SC_COMMUNITY_EVENT_GET_EXTRA_DATA_STRING_FOR_TYPE(const char* p0, char* p1, const char* p2);
	BOOL SC_COMMUNITY_EVENT_GET_DISPLAY_NAME_FOR_TYPE(char* p0, const char* p1);
	BOOL SC_COMMUNITY_EVENT_IS_ACTIVE_BY_ID(int p0);
	BOOL SC_COMMUNITY_EVENT_GET_EXTRA_DATA_INT_BY_ID(int p0, const char* p1, int* p2);
	BOOL SC_COMMUNITY_EVENT_GET_EXTRA_DATA_FLOAT_BY_ID(int p0, const char* p1, float* p2);
	BOOL SC_COMMUNITY_EVENT_GET_EXTRA_DATA_STRING_BY_ID(int p0, const char* p1, char* p2);
	BOOL SC_COMMUNITY_EVENT_GET_DISPLAY_NAME_BY_ID(int p0, char* p1);
	BOOL SC_TRANSITION_NEWS_SHOW(Any p0);
	BOOL SC_TRANSITION_NEWS_SHOW_TIMED(Any p0, Any p1);
	BOOL SC_TRANSITION_NEWS_SHOW_NEXT_ITEM();
	BOOL SC_TRANSITION_NEWS_HAS_EXTRA_DATA_TU();
	BOOL SC_TRANSITION_NEWS_GET_EXTRA_DATA_INT_TU(const char* p0, int* p1);
	void SC_TRANSITION_NEWS_END();
	BOOL SC_PAUSE_NEWS_INIT_STARTER_PACK(Any p0);
	BOOL SC_PAUSE_NEWS_GET_PENDING_STORY(Any p0);
	void SC_PAUSE_NEWS_SHUTDOWN();
	const char* SC_ACCOUNT_INFO_GET_NICKNAME();
	BOOL SC_ACHIEVEMENT_INFO_STATUS(int* p0);
	BOOL SC_HAS_ACHIEVEMENT_BEEN_PASSED(int achievementId);
}

namespace STATS
{
	BOOL STAT_CLEAR_SLOT_FOR_RELOAD(int statSlot);
	BOOL STAT_LOAD(int statSlot);
	BOOL STAT_SAVE(int p0, BOOL p1, int p2, BOOL p3);
	void STAT_SET_OPEN_SAVETYPE_IN_JOB(int p0);
	BOOL STAT_LOAD_PENDING(int statSlot);
	BOOL STAT_SAVE_PENDING();
	BOOL STAT_SAVE_PENDING_OR_REQUESTED();
	BOOL STAT_DELETE_SLOT(int p0);
	BOOL STAT_SLOT_IS_LOADED(int statSlot);
	BOOL STAT_CLOUD_SLOT_LOAD_FAILED(int p0);
	int STAT_CLOUD_SLOT_LOAD_FAILED_CODE(Any p0);
	void STAT_SET_BLOCK_SAVES(BOOL toggle);
	BOOL STAT_GET_BLOCK_SAVES();
	BOOL STAT_CLOUD_SLOT_SAVE_FAILED(Any p0);
	void STAT_CLEAR_PENDING_SAVES(Any p0);
	BOOL STAT_LOAD_DIRTY_READ_DETECTED();
	void STAT_CLEAR_DIRTY_READ_DETECTED();
	BOOL STAT_GET_LOAD_SAFE_TO_PROGRESS_TO_MP_FROM_SP();
	Hash GET_STAT_HASH_FOR_CHARACTER_STAT_(int dataType, int statIndex, int charSlot);
	BOOL STAT_SET_INT(Hash statName, int value, BOOL save);
	BOOL STAT_SET_FLOAT(Hash statName, float value, BOOL save);
	BOOL STAT_SET_BOOL(Hash statName, BOOL value, BOOL save);
	BOOL STAT_SET_GXT_LABEL(Hash statName, const char* value, BOOL save);
	BOOL STAT_SET_DATE(Hash statName, Any* value, int numFields, BOOL save);
	BOOL STAT_SET_STRING(Hash statName, const char* value, BOOL save);
	BOOL STAT_SET_POS(Hash statName, float x, float y, float z, BOOL save);
	BOOL STAT_SET_MASKED_INT(Hash statName, int p1, int p2, int p3, BOOL save);
	BOOL STAT_SET_USER_ID(Hash statName, const char* value, BOOL save);
	BOOL STAT_SET_CURRENT_POSIX_TIME(Hash statName, BOOL p1);
	BOOL STAT_GET_INT(Hash statHash, int* outValue, int p2);
	BOOL STAT_GET_FLOAT(Hash statHash, float* outValue, Any p2);
	BOOL STAT_GET_BOOL(Hash statHash, BOOL* outValue, Any p2);
	BOOL STAT_GET_DATE(Hash statHash, Any* outValue, int numFields, Any p3);
	const char* STAT_GET_STRING(Hash statHash, int p1);
	BOOL STAT_GET_POS(Hash statName, float* outX, float* outY, float* outZ, Any p4);
	BOOL STAT_GET_MASKED_INT(Hash statHash, int* outValue, int p2, int p3, Any p4);
	const char* STAT_GET_USER_ID(Hash statHash);
	const char* STAT_GET_LICENSE_PLATE(Hash statName);
	BOOL STAT_SET_LICENSE_PLATE(Hash statName, const char* str);
	void STAT_INCREMENT(Hash statName, float value);
	BOOL STAT_COMMUNITY_START_SYNCH();
	BOOL STAT_COMMUNITY_SYNCH_IS_PENDING();
	BOOL STAT_COMMUNITY_GET_HISTORY(Hash statName, int p1, float* outValue);
	void STAT_RESET_ALL_ONLINE_CHARACTER_STATS(int p0);
	void STAT_LOCAL_RESET_ALL_ONLINE_CHARACTER_STATS(int p0);
	int STAT_GET_NUMBER_OF_DAYS(Hash statName);
	int STAT_GET_NUMBER_OF_HOURS(Hash statName);
	int STAT_GET_NUMBER_OF_MINUTES(Hash statName);
	int STAT_GET_NUMBER_OF_SECONDS(Hash statName);
	void STAT_SET_PROFILE_SETTING_VALUE(int profileSetting, int value);
	void STATS_COMPLETED_CHARACTER_CREATION(Any p0);
	int PACKED_STAT_GET_INT_STAT_INDEX(int p0);
	Hash GET_PACKED_INT_STAT_KEY(int index, BOOL spStat, BOOL charStat, int character);
	Hash GET_PACKED_TU_INT_STAT_KEY(int index, BOOL spStat, BOOL charStat, int character);
	Hash GET_PACKED_NG_INT_STAT_KEY(int index, BOOL spStat, BOOL charStat, int character, const char* section);
	BOOL GET_PACKED_STAT_BOOL_CODE(int index, int characterSlot);
	int GET_PACKED_STAT_INT_CODE(int index, int characterSlot);
	void SET_PACKED_STAT_BOOL_CODE(int index, BOOL value, int characterSlot);
	void SET_PACKED_STAT_INT_CODE(int index, int value, int characterSlot);
	void PLAYSTATS_BACKGROUND_SCRIPT_ACTION(const char* action, int value);
	void PLAYSTATS_FLOW_LOW_(float posX, float posY, float posZ, const char* p3, Any p4, int amount);
	void PLAYSTATS_NPC_INVITE(const char* p0);
	void PLAYSTATS_AWARD_XP(int amount, Hash type, Hash category);
	void PLAYSTATS_RANK_UP(int rank);
	void PLAYSTATS_STARTED_SESSION_IN_OFFLINEMODE();
	void PLAYSTATS_ACTIVITY_DONE(int p0, int activityId);
	void PLAYSTATS_LEAVE_JOB_CHAIN(Any p0, Any p1, Any p2, Any p3, Any p4);
	void PLAYSTATS_MISSION_STARTED(const char* p0, Any p1, Any p2, BOOL p3);
	void PLAYSTATS_MISSION_OVER(const char* p0, Any p1, Any p2, BOOL p3, BOOL p4, BOOL p5);
	void PLAYSTATS_MISSION_CHECKPOINT(const char* p0, Any p1, Any p2, Any p3);
	void PLAYSTATS_RANDOM_MISSION_DONE(const char* name, Any p1, Any p2, Any p3);
	void PLAYSTATS_ROS_BET(int amount, int act, Player player, float cm);
	void PLAYSTATS_RACE_CHECKPOINT(Vehicle p0, Any p1, int p2, int p3, Any p4);
	BOOL PLAYSTATS_CREATE_MATCH_HISTORY_ID_2(int* playerAccountId, int* posixTime);
	void PLAYSTATS_MATCH_STARTED(Any p0, Any p1, Any p2);
	void PLAYSTATS_SHOP_ITEM(Any p0, Any p1, Any p2, Any p3, Any p4);
	void PLAYSTATS_CRATE_DROP_MISSION_DONE(Any p0, Any p1, Any p2, Any p3, Any p4, Any p5, Any p6, Any p7);
	void PLAYSTATS_CRATE_CREATED(float p0, float p1, float p2);
	void PLAYSTATS_HOLD_UP_MISSION_DONE(Any p0, Any p1, Any p2, Any p3);
	void PLAYSTATS_IMPORT_EXPORT_MISSION_DONE(Any p0, Any p1, Any p2, Any p3);
	void PLAYSTATS_RACE_TO_POINT_MISSION_DONE(int p0, Any p1, Any p2, Any p3);
	void PLAYSTATS_ACQUIRED_HIDDEN_PACKAGE(Any p0);
	void PLAYSTATS_WEBSITE_VISITED(Hash scaleformHash, int p1);
	void PLAYSTATS_FRIEND_ACTIVITY(int p0, BOOL p1);
	void PLAYSTATS_ODDJOB_DONE(int totalTimeMs, int p1, BOOL p2);
	void PLAYSTATS_PROP_CHANGE(Ped p0, int p1, int p2, int p3);
	void PLAYSTATS_CLOTH_CHANGE(Ped p0, Any p1, Any p2, Any p3, Any p4);
	void PLAYSTATS_WEAPON_MODE_CHANGE(Hash weaponHash, Hash componentHashTo, Hash componentHashFrom);
	void PLAYSTATS_CHEAT_APPLIED(const char* cheat);
	void PLAYSTATS_JOB_ACTIVITY_END(Any* p0, Any* p1, Any* p2, Any* p3);
	void PLAYSTATS_JOB_BEND(Any* p0, Any* p1, Any* p2, Any* p3);
	void PLAYSTATS_JOB_LTS_END(Any* p0, Any* p1, Any* p2, Any* p3);
	void PLAYSTATS_JOB_LTS_ROUND_END(Any* p0, Any* p1, Any* p2, Any* p3);
	void PLAYSTATS_QUICKFIX_TOOL(int element, const char* item);
	void PLAYSTATS_IDLE_KICK(int msStoodIdle);
	void PLAYSTATS_SET_JOIN_TYPE(int joinType);
	void PLAYSTATS_HEIST_SAVE_CHEAT(Hash hash, int p1);
	void PLAYSTATS_APPEND_DIRECTOR_METRIC(Any* p0);
	void PLAYSTATS_AWARD_BAD_SPORT(int id);
	void PLAYSTATS_PEGASUS_AS_PERSONAL_AIRCRAFT(Hash modelHash);
	void PLAYSTATS_SHOPMENU_NAV_(Any p0, Any p1, Any p2);
	void PLAYSTATS_FM_EVENT_CHALLENGES(Any p0);
	void PLAYSTATS_FM_EVENT_VEHICLETARGET(Any p0);
	void PLAYSTATS_FM_EVENT_URBANWARFARE(Any p0);
	void PLAYSTATS_FM_EVENT_CHECKPOINTCOLLECTION(Any p0);
	void PLAYSTATS_FM_EVENT_ATOB(Any p0);
	void PLAYSTATS_FM_EVENT_PENNEDIN(Any p0);
	void PLAYSTATS_FM_EVENT_PASSTHEPARCEL(Any p0);
	void PLAYSTATS_FM_EVENT_HOTPROPERTY(Any p0);
	void PLAYSTATS_FM_EVENT_DEADDROP(Any p0);
	void PLAYSTATS_FM_EVENT_KINGOFTHECASTLE(Any p0);
	void PLAYSTATS_FM_EVENT_CRIMINALDAMAGE(Any p0);
	void PLAYSTATS_FM_EVENT_COMPETITIVEURBANWARFARE(Any p0);
	void PLAYSTATS_FM_EVENT_HUNTBEAST(Any p0);
	void PLAYSTATS_PIMENU_HIDE_OPTIONS(Any* data);
	int LEADERBOARDS_GET_NUMBER_OF_COLUMNS(int p0, Any p1);
	int LEADERBOARDS_GET_COLUMN_ID(int p0, int p1, int p2);
	int LEADERBOARDS_GET_COLUMN_TYPE(int p0, Any p1, Any p2);
	int LEADERBOARDS_READ_CLEAR_ALL();
	int LEADERBOARDS_READ_CLEAR(Any p0, Any p1, Any p2);
	BOOL LEADERBOARDS_READ_PENDING(Any p0, Any p1, Any p2);
	BOOL LEADERBOARDS_READ_ANY_PENDING();
	BOOL LEADERBOARDS_READ_SUCCESSFUL(Any p0, Any p1, Any p2);
	BOOL LEADERBOARDS2_READ_FRIENDS_BY_ROW(Any* p0, Any* p1, Any p2, BOOL p3, Any p4, Any p5);
	BOOL LEADERBOARDS2_READ_BY_HANDLE(Any* p0, Any* p1);
	BOOL LEADERBOARDS2_READ_BY_ROW(Any* p0, Any* p1, Any p2, Any* p3, Any p4, Any* p5, Any p6);
	BOOL LEADERBOARDS2_READ_BY_RANK(Any* p0, Any p1, Any p2);
	BOOL LEADERBOARDS2_READ_BY_RADIUS(Any* p0, Any p1, Any* p2);
	BOOL LEADERBOARDS2_READ_BY_SCORE_INT(Any* p0, Any p1, Any p2);
	BOOL LEADERBOARDS2_READ_BY_SCORE_FLOAT(Any* p0, float p1, Any p2);
	BOOL LEADERBOARDS2_READ_RANK_PREDICTION(Any* p0, Any* p1, Any* p2);
	BOOL LEADERBOARDS2_READ_BY_PLAFORM(Any* p0, const char* gamerHandleCsv, const char* platformName);
	BOOL LEADERBOARDS2_READ_GET_ROW_DATA_START(Any* p0);
	void LEADERBOARDS2_READ_GET_ROW_DATA_END();
	BOOL LEADERBOARDS2_READ_GET_ROW_DATA_INFO(Any p0, Any* p1);
	int LEADERBOARDS2_READ_GET_ROW_DATA_INT(Any p0, Any p1);
	float LEADERBOARDS2_READ_GET_ROW_DATA_FLOAT(Any p0, Any p1);
	BOOL LEADERBOARDS2_WRITE_DATA(Any* p0);
	void LEADERBOARDS_WRITE_ADD_COLUMN(Any p0, Any p1, float p2);
	void LEADERBOARDS_WRITE_ADD_COLUMN_LONG(Any p0, Any p1, Any p2);
	BOOL LEADERBOARDS_CACHE_DATA_ROW(Any* p0);
	void LEADERBOARDS_CLEAR_CACHE_DATA();
	void LEADERBOARDS_CLEAR_CACHE_DATA_ID(Any p0);
	BOOL LEADERBOARDS_GET_CACHE_EXISTS(Any p0);
	int LEADERBOARDS_GET_CACHE_TIME(Any p0);
	int LEADERBOARDS_GET_CACHE_NUMBER_OF_ROWS(Any p0);
	BOOL LEADERBOARDS_GET_CACHE_DATA_ROW(Any p0, Any p1, Any* p2);
	void PRESENCE_EVENT_UPDATESTAT_INT(Hash statHash, int value, int p2);
	void PRESENCE_EVENT_UPDATESTAT_FLOAT(Hash statHash, float value, int p2);
	void PRESENCE_EVENT_UPDATESTAT_INT_WITH_STRING(Hash statHash, int value, int p2, const char* string);
	BOOL GET_PLAYER_HAS_DRIVEN_ALL_VEHICLES();
	void SET_HAS_POSTED_ALL_VEHICLES_DRIVEN();
	void SET_PROFILE_SETTING_PROLOGUE_COMPLETE();
	void SET_PROFILE_SETTING_SP_CHOP_MISSION_COMPLETE();
	void SET_PROFILE_SETTING_CREATOR_RACES_DONE(int value);
	void SET_PROFILE_SETTING_CREATOR_DM_DONE(int value);
	void SET_PROFILE_SETTING_CREATOR_CTF_DONE(int value);
	void SET_JOB_ACTIVITY_ID_STARTED(Any p0, int characterSlot);
	void SET_FREEMODE_PROLOGUE_DONE(Any p0, int characterSlot);
	void SET_FREEMODE_STRAND_PROGRESSION_STATUS(int profileSetting, int settingValue);
	void STAT_NETWORK_INCREMENT_ON_SUICIDE(Any p0, float p1);
	void STAT_SET_CHEAT_IS_ACTIVE();
	BOOL LEADERBOARDS2_WRITE_DATA_FOR_EVENT_TYPE(Any* p0, Any* p1);
	void FORCE_CLOUD_MP_STATS_DOWNLOAD_AND_OVERWRITE_LOCAL_SAVE();
	void STAT_MIGRATE_CLEAR_FOR_RESTART();
	BOOL STAT_MIGRATE_SAVEGAME_START(const char* platformName);
	int STAT_MIGRATE_SAVEGAME_GET_STATUS();
	BOOL STAT_MIGRATE_CHECK_ALREADY_DONE();
	BOOL STAT_MIGRATE_CHECK_START();
	int STAT_MIGRATE_CHECK_GET_IS_PLATFORM_AVAILABLE(int p0);
	int STAT_MIGRATE_CHECK_GET_PLATFORM_STATUS(int p0, Any* p1);
	int STAT_GET_SAVE_MIGRATION_STATUS(Any* data);
	BOOL STAT_SAVE_MIGRATION_CANCEL_PENDING_OPERATION();
	int STAT_GET_CANCEL_SAVE_MIGRATION_STATUS();
	BOOL STAT_SAVE_MIGRATION_CONSUME_CONTENT(Hash contentId, const char* srcPlatform, const char* srcGamerHandle);
	int STAT_GET_SAVE_MIGRATION_CONSUME_CONTENT_STATUS(int* p0);
	void STAT_ENABLE_STATS_TRACKING();
	void STAT_DISABLE_STATS_TRACKING();
	BOOL STAT_IS_STATS_TRACKING_ENABLED();
	BOOL STAT_START_RECORD_STAT(int statType, int valueType);
	BOOL STAT_STOP_RECORD_STAT();
	BOOL STAT_GET_RECORDED_VALUE(float* value);
	BOOL STAT_IS_RECORDING_STAT();
	int STAT_GET_CURRENT_NEAR_MISS_NOCRASH_PRECISE();
	float STAT_GET_CURRENT_REAR_WHEEL_DISTANCE();
	float STAT_GET_CURRENT_FRONT_WHEEL_DISTANCE();
	float STAT_GET_CURRENT_JUMP_DISTANCE();
	float STAT_GET_CURRENT_DRIVE_NOCRASH_DISTANCE();
	float STAT_GET_CURRENT_SPEED();
	float STAT_GET_CURRENT_DRIVING_REVERSE_DISTANCE();
	float STAT_GET_CURRENT_SKYDIVING_DISTANCE();
	float STAT_GET_CHALLENGE_FLYING_DIST();
	BOOL STAT_GET_FLYING_ALTITUDE(float* outValue);
	BOOL STAT_IS_PLAYER_VEHICLE_ABOVE_OCEAN();
	float STAT_GET_VEHICLE_BAIL_DISTANCE();
	BOOL STAT_ROLLBACK_SAVE_MIGRATION();
	void SET_HAS_SPECIALEDITION_CONTENT(int value);
	void SET_SAVE_MIGRATION_TRANSACTION_ID_WARNING(int transactionId);
	void GET_BOSS_GOON_UUID(int characterSlot, Any p1, Any p2);
	void PLAYSTATS_BW_BOSSONBOSSDEATHMATCH(Any p0);
	void PLAYSTATS_BW_YATCHATTACK(Any p0);
	void PLAYSTATS_BW_HUNT_THE_BOSS(Any p0);
	void PLAYSTATS_BW_SIGHTSEER(Any p0);
	void PLAYSTATS_BW_ASSAULT(Any p0);
	void PLAYSTATS_BW_BELLY_OF_THE_BEAST(Any p0);
	void PLAYSTATS_BW_HEAD_HUNTER(Any p0);
	void PLAYSTATS_BW_FRAGILE_GOODS(Any p0);
	void PLAYSTATS_BW_AIR_FREIGHT(Any p0);
	void PLAYSTATS_BC_CAR_JACKING(Any p0);
	void PLAYSTATS_BC_SMASH_AND_GRAB(Any p0);
	void PLAYSTATS_BC_PROTECTION_RACKET(Any p0);
	void PLAYSTATS_BC_MOST_WANTED(Any p0);
	void PLAYSTATS_BC_FINDERS_KEEPERS(Any p0);
	void PLAYSTATS_BC_POINT_TO_POINT(Any p0);
	void PLAYSTATS_BC_CASHING(Any p0);
	void PLAYSTATS_BC_SALVAGE(Any p0);
	void PLAYSTATS_SPENT_PI_CUSTOM_LOADOUT(int amount);
	void PLAYSTATS_BUY_CONTRABAND_MISSION(Any* data);
	void PLAYSTATS_SELL_CONTRABAND_MISSION(Any* data);
	void PLAYSTATS_DEFEND_CONTRABAND_MISSION(Any* data);
	void PLAYSTATS_RECOVER_CONTRABAND_MISSION(Any* data);
	void PLAYSTATS_HIT_CONTRABAND_DESTROY_LIMIT(Any p0);
	void START_BEING_BOSS(Any p0, Any p1);
	void START_BEING_GOON(Any p0, Any p1, Any p2);
	void END_BEING_BOSS(Any p0, Any p1, Any p2);
	void END_BEING_GOON(Any p0, Any p1, Any p2, Any p3, Any p4);
	void HIRED_LIMO(Any p0, Any p1);
	void ORDER_BOSS_VEHICLE(Any p0, Any p1, Hash vehicleHash);
	void CHANGE_UNIFORM(Any p0, Any p1, Any p2);
	void CHANGE_GOON_LOOKING_FOR_WORK(Any p0);
	void SEND_METRIC_GHOSTING_TO_PLAYER(Any p0);
	void SEND_METRIC_VIP_POACH(Any p0, Any p1, Any p2);
	void SEND_METRIC_PUNISH_BODYGUARD(Any p0);
	void PLAYSTATS_START_TRACKING_STUNTS();
	void PLAYSTATS_STOP_TRACKING_STUNTS();
	void PLAYSTATS_MISSION_ENDED(Any p0);
	void PLAYSTATS_IMPEXP_MISSION_ENDED(Any p0);
	void PLAYSTATS_CHANGE_MC_ROLE(Any p0, Any p1, Any p2, Any p3, int role, int p5, Any p6);
	void PLAYSTATS_CHANGE_MC_OUTFIT(Any p0, Any p1, Any p2, Any p3, Any p4);
	void PLAYSTATS_SWITCH_MC_EMBLEM(Any p0, Any p1, Any p2, Any p3, Any p4);
	void PLAYSTATS_MC_REQUEST_BIKE(Any p0, Any p1, Any p2, Any p3, Any p4);
	void PLAYSTATS_MC_KILLED_RIVAL_MC_MEMBER(Any p0, Any p1, Any p2, Any p3, Any p4);
	void PLAYSTATS_ABANDONED_MC(Any p0, Any p1, Any p2, Any p3, Any p4);
	void PLAYSTATS_EARNED_MC_POINTS(Any p0, Any p1, Any p2, Any p3, Any p4, Any p5);
	void PLAYSTATS_MC_FORMATION_ENDS(Any p0, Any p1, Any p2, Any p3, Any p4, Any p5, Any p6);
	void PLAYSTATS_MC_CLUBHOUSE_ACTIVITY(Any p0, Any p1, Any p2, Any p3, Any p4, Any p5, Any p6, Any p7);
	void PLAYSTATS_RIVAL_BEHAVIOR(Any p0, Any p1, Any p2, Any p3, Any p4, Any p5, Any p6, Any p7, Any p8, Any p9);
	void PLAYSTATS_COPY_RANK_INTO_NEW_SLOT(Any p0, Any p1, Any p2, Any p3, Any p4, Any p5, Any p6);
	void PLAYSTATS_DUPE_DETECTED(Any* data);
	void PLAYSTATS_BAN_ALERT(int p0);
	void PLAYSTATS_GUNRUNNING_MISSION_ENDED(Any* data);
	void PLAYSTATS_GUNRUNNING_RND(Any p0);
	void PLAYSTATS_BUSINESS_BATTLE_ENDED(Any p0);
	void PLAYSTATS_WAREHOUSE_MISSION_ENDED(Any p0);
	void PLAYSTATS_NIGHTCLUB_MISSION_ENDED(Any p0);
	void PLAYSTATS_DJ_USAGE(Any p0, Any p1);
	void PLAYSTATS_MINIGAME_USAGE(Any p0, Any p1, Any p2);
	void PLAYSTATS_STONE_HATCHET_ENDED(Any* data);
	void PLAYSTATS_SMUGGLER_MISSION_ENDED(Any* data);
	void PLAYSTATS_FM_HEIST_PREP_ENDED(Any* data);
	void PLAYSTATS_INSTANCED_HEIST_ENDED(Any* data, Any p1, Any p2, Any p3);
	void PLAYSTATS_DAR_CHECKPOINT(Any* data);
	void PLAYSTATS_ENTER_SESSION_PACK(Any* data);
	void PLAYSTATS_DRONE_USAGE(int p0, int p1, int p2);
	void PLAYSTATS_SPIN_WHEEL(int p0, int p1, int p2, int p3);
	void PLAYSTATS_ARENA_WARS_SPECTATOR(int p0, int p1, int p2, int p3, int p4);
	void PLAYSTATS_ARENA_WARS_ENDED(Any* data);
	void PLAYSTATS_SWITCH_PASSIVE_MODE(BOOL p0, int p1, int p2, int p3);
	void PLAYSTATS_COLLECTIBLE_PICKED_UP(int p0, Hash objectHash, Any p2, Any p3, int moneyAmount, int rpAmount, int chipsAmount, Any p7, int p8, Any p9, Any p10);
	void PLAYSTATS_CASINO_STORY_MISSION_ENDED(Any p0, Any p1);
	void PLAYSTATS_CASINO_CHIP(Any p0);
	void PLAYSTATS_CASINO_ROULETTE(Any p0);
	void PLAYSTATS_CASINO_BLACKJACK(Any p0);
	void PLAYSTATS_CASINO_THREE_CARD_POKER(Any p0);
	void PLAYSTATS_CASINO_SLOT_MACHINE(Any p0);
	void PLAYSTATS_CASINO_INSIDE_TRACK(Any p0);
	void PLAYSTATS_CASINO_LUCKY_SEVEN(Any p0);
	void PLAYSTATS_CASINO_ROULETTE_LIGHT(Any p0);
	void PLAYSTATS_CASINO_BLACKJACK_LIGHT(Any p0);
	void PLAYSTATS_CASINO_THREE_CARD_POKER_LIGHT(Any p0);
	void PLAYSTATS_CASINO_SLOT_MACHINE_LIGHT(Any p0);
	void PLAYSTATS_CASINO_INSIDE_TRACK_LIGHT(Any p0);
	void PLAYSTATS_ARCADE_GAME(Any p0, Any p1, Any p2, Any p3, Any p4, Any p5, Any p6);
	void PLAYSTATS_ARCADE_LOVE_MATCH(Any p0, Any p1);
	void PLAYSTATS_FREEMODE_CASINO_MISSION_ENDED(Any* data);
	void PLAYSTATS_HEIST3_DRONE(Any p0);
	void PLAYSTATS_HEIST3_HACK(Any p0, Any p1, Any p2, Any p3, Any p4, Any p5);
	void PLAYSTATS_NPC_PHONE(Any p0, Any p1, Any p2, Any p3, Any p4, Any p5, Any p6, Any p7, Any p8, Any p9, Any p10, Any p11, Any p12);
	void PLAYSTATS_ARCADE_CABINET(Any p0);
	void PLAYSTATS_HEIST3_FINALE(Any p0);
	void PLAYSTATS_HEIST3_PREP(Any p0);
	void PLAYSTATS_MASTER_CONTROL(Any p0, Any p1, Any p2, Any p3);
	void PLAYSTATS_QUIT_MODE(Any p0, Any p1, Any p2, Any p3, Any p4);
	void PLAYSTATS_MISSION_VOTE(Any p0);
	void PLAYSTATS_NJVS_VOTE(Any p0);
	void PLAYSTATS_KILL_YOURSELF();
	void PLAYSTATS_FM_MISSION_END(Any p0, Any p1, Any p2);
	void PLAYSTATS_HEIST4_PREP(Any p0);
	void PLAYSTATS_HEIST4_FINALE(Any p0);
	void PLAYSTATS_HEIST4_HACK(Any p0, Any p1, Any p2, Any p3, Any p4);
	void PLAYSTATS_SUB_WEAP(Any p0, Any p1, Any p2, Any p3);
	void PLAYSTATS_FAST_TRVL(Any p0, Any p1, Any p2, Any p3, Any p4, Any p5, Any p6, Any p7, Any p8, Any p9, Any p10);
	void PLAYSTATS_HUB_ENTRY(Any p0);
	void PLAYSTATS_DJ_MISSION_ENDED(Any p0);
	void PLAYSTATS_ROBBERY_PREP(Any p0);
	void PLAYSTATS_ROBBERY_FINALE(Any p0);
	void PLAYSTATS_EXTRA_EVENT(Any p0);
	void PLAYSTATS_CARCLUB_POINTS(Any p0);
	void PLAYSTATS_CARCLUB_CHALLENGE(Any p0, Any p1, Any p2, Any p3);
	void PLAYSTATS_CARCLUB_PRIZE(int p0, Hash vehicleModel);
	void PLAYSTATS_AWARD_NAV(Any p0, Any p1, Any p2, Any p3);
	void PLAYSTATS_INST_MISSION_END(Any p0);
	void PLAYSTATS_HUB_EXIT(Any p0);
	void PLAYSTATS_VEH_DEL(int bossId1, int bossId2, int bossType, int vehicleID, int reason);
	void PLAYSTATS_INVENTORY(Any p0);
	void PLAYSTATS_ACID_MISSION_END_(Any p0);
	void PLAYSTATS_ACID_RND_(Any p0);
	void PLAYSTATS_IDLE_(Any p0, Any p1, Any p2);
	void PLAYSTATS_PLAYER_STYLE_(Any p0);
	void PLAYSTATS_RANDOM_EVENT_(Any p0);
	void PLAYSTATS_ATTRITION_STAGE_END_(Any p0);
	void PLAYSTATS_SHOWROOM_NAV_(Any p0, Any p1, Hash entity);
	void PLAYSTATS_SHOWROOM_OVERVIEW_(Any* data);
}

namespace STREAMING
{
	void LOAD_ALL_OBJECTS_NOW();
	void LOAD_SCENE(float x, float y, float z);
	BOOL NETWORK_UPDATE_LOAD_SCENE();
	BOOL IS_NETWORK_LOADING_SCENE();
	void SET_INTERIOR_ACTIVE(int interiorID, BOOL toggle);
	void REQUEST_MODEL(Hash model);
	void REQUEST_MENU_PED_MODEL(Hash model);
	BOOL HAS_MODEL_LOADED(Hash model);
	void REQUEST_MODELS_IN_ROOM(Interior interior, const char* roomName);
	void SET_MODEL_AS_NO_LONGER_NEEDED(Hash model);
	BOOL IS_MODEL_IN_CDIMAGE(Hash model);
	BOOL IS_MODEL_VALID(Hash model);
	BOOL IS_MODEL_A_PED(Hash model);
	BOOL IS_MODEL_A_VEHICLE(Hash model);
	void REQUEST_COLLISION_AT_COORD(float x, float y, float z);
	void REQUEST_COLLISION_FOR_MODEL(Hash model);
	BOOL HAS_COLLISION_FOR_MODEL_LOADED(Hash model);
	void REQUEST_ADDITIONAL_COLLISION_AT_COORD(float x, float y, float z);
	BOOL DOES_ANIM_DICT_EXIST(const char* animDict);
	void REQUEST_ANIM_DICT(const char* animDict);
	BOOL HAS_ANIM_DICT_LOADED(const char* animDict);
	void REMOVE_ANIM_DICT(const char* animDict);
	void REQUEST_ANIM_SET(const char* animSet);
	BOOL HAS_ANIM_SET_LOADED(const char* animSet);
	void REMOVE_ANIM_SET(const char* animSet);
	void REQUEST_CLIP_SET(const char* clipSet);
	BOOL HAS_CLIP_SET_LOADED(const char* clipSet);
	void REMOVE_CLIP_SET(const char* clipSet);
	void REQUEST_IPL(const char* iplName);
	void REMOVE_IPL(const char* iplName);
	BOOL IS_IPL_ACTIVE(const char* iplName);
	void SET_STREAMING(BOOL toggle);
	void LOAD_GLOBAL_WATER_FILE(int waterType);
	int GET_GLOBAL_WATER_FILE();
	void SET_GAME_PAUSES_FOR_STREAMING(BOOL toggle);
	void SET_REDUCE_PED_MODEL_BUDGET(BOOL toggle);
	void SET_REDUCE_VEHICLE_MODEL_BUDGET(BOOL toggle);
	void SET_DITCH_POLICE_MODELS(BOOL toggle);
	int GET_NUMBER_OF_STREAMING_REQUESTS();
	void REQUEST_PTFX_ASSET();
	BOOL HAS_PTFX_ASSET_LOADED();
	void REMOVE_PTFX_ASSET();
	void REQUEST_NAMED_PTFX_ASSET(const char* fxName);
	BOOL HAS_NAMED_PTFX_ASSET_LOADED(const char* fxName);
	void REMOVE_NAMED_PTFX_ASSET(const char* fxName);
	void SET_VEHICLE_POPULATION_BUDGET(int p0);
	void SET_PED_POPULATION_BUDGET(int p0);
	void CLEAR_FOCUS();
	void SET_FOCUS_POS_AND_VEL(float x, float y, float z, float offsetX, float offsetY, float offsetZ);
	void SET_FOCUS_ENTITY(Entity entity);
	BOOL IS_ENTITY_FOCUS(Entity entity);
	void SET_RESTORE_FOCUS_ENTITY(Entity p0);
	void SET_MAPDATACULLBOX_ENABLED(const char* name, BOOL toggle);
	void SET_ALL_MAPDATA_CULLED(Any p0);
	int STREAMVOL_CREATE_SPHERE(float x, float y, float z, float rad, Any p4, Any p5);
	int STREAMVOL_CREATE_FRUSTUM(float p0, float p1, float p2, float p3, float p4, float p5, float p6, Any p7, Any p8);
	int STREAMVOL_CREATE_LINE(float p0, float p1, float p2, float p3, float p4, float p5, Any p6);
	void STREAMVOL_DELETE(Any unused);
	BOOL STREAMVOL_HAS_LOADED(Any unused);
	BOOL STREAMVOL_IS_VALID(Any unused);
	BOOL IS_STREAMVOL_ACTIVE();
	BOOL NEW_LOAD_SCENE_START(float posX, float posY, float posZ, float offsetX, float offsetY, float offsetZ, float radius, int p7);
	BOOL NEW_LOAD_SCENE_START_SPHERE(float x, float y, float z, float radius, Any p4);
	void NEW_LOAD_SCENE_STOP();
	BOOL IS_NEW_LOAD_SCENE_ACTIVE();
	BOOL IS_NEW_LOAD_SCENE_LOADED();
	BOOL IS_SAFE_TO_START_PLAYER_SWITCH();
	void START_PLAYER_SWITCH(Ped from, Ped to, int flags, int switchType);
	void STOP_PLAYER_SWITCH();
	BOOL IS_PLAYER_SWITCH_IN_PROGRESS();
	int GET_PLAYER_SWITCH_TYPE();
	int GET_IDEAL_PLAYER_SWITCH_TYPE(float x1, float y1, float z1, float x2, float y2, float z2);
	int GET_PLAYER_SWITCH_STATE();
	int GET_PLAYER_SHORT_SWITCH_STATE();
	void SET_PLAYER_SHORT_SWITCH_STYLE(int p0);
	int GET_PLAYER_SWITCH_JUMP_CUT_INDEX();
	void SET_PLAYER_SWITCH_OUTRO(float cameraCoordX, float cameraCoordY, float cameraCoordZ, float camRotationX, float camRotationY, float camRotationZ, float camFov, float camFarClip, int rotationOrder);
	void SET_PLAYER_SWITCH_ESTABLISHING_SHOT(const char* name);
	void ALLOW_PLAYER_SWITCH_PAN();
	void ALLOW_PLAYER_SWITCH_OUTRO();
	void ALLOW_PLAYER_SWITCH_ASCENT();
	void ALLOW_PLAYER_SWITCH_DESCENT();
	BOOL IS_SWITCH_READY_FOR_DESCENT();
	void ENABLE_SWITCH_PAUSE_BEFORE_DESCENT();
	void DISABLE_SWITCH_OUTRO_FX();
	void SWITCH_TO_MULTI_FIRSTPART(Ped ped, int flags, int switchType);
	void SWITCH_TO_MULTI_SECONDPART(Ped ped);
	BOOL IS_SWITCH_TO_MULTI_FIRSTPART_FINISHED();
	int GET_PLAYER_SWITCH_INTERP_OUT_DURATION();
	int GET_PLAYER_SWITCH_INTERP_OUT_CURRENT_TIME();
	BOOL IS_SWITCH_SKIPPING_DESCENT();
	void SET_SCENE_STREAMING_TRACKS_CAM_POS_THIS_FRAME();
	float GET_LODSCALE();
	void OVERRIDE_LODSCALE_THIS_FRAME(float scaling);
	void REMAP_LODSCALE_RANGE_THIS_FRAME(float p0, float p1, float p2, float p3);
	void SUPPRESS_HD_MAP_STREAMING_THIS_FRAME();
	void SET_RENDER_HD_ONLY(BOOL toggle);
	void FORCE_ALLOW_TIME_BASED_FADING_THIS_FRAME();
	void IPL_GROUP_SWAP_START(const char* iplName1, const char* iplName2);
	void IPL_GROUP_SWAP_CANCEL();
	BOOL IPL_GROUP_SWAP_IS_READY();
	void IPL_GROUP_SWAP_FINISH();
	BOOL IPL_GROUP_SWAP_IS_ACTIVE();
	void PREFETCH_SRL(const char* srl);
	BOOL IS_SRL_LOADED();
	void BEGIN_SRL();
	void END_SRL();
	void SET_SRL_TIME(float p0);
	void SET_SRL_POST_CUTSCENE_CAMERA(Any p0, Any p1, Any p2, Any p3, Any p4, Any p5);
	void SET_SRL_READAHEAD_TIMES(Any p0, Any p1, Any p2, Any p3);
	void SET_SRL_LONG_JUMP_MODE(BOOL p0);
	void SET_SRL_FORCE_PRESTREAM(Any p0);
	void SET_HD_AREA(float x, float y, float z, float radius);
	void CLEAR_HD_AREA();
	void INIT_CREATOR_BUDGET();
	void SHUTDOWN_CREATOR_BUDGET();
	BOOL ADD_MODEL_TO_CREATOR_BUDGET(Hash modelHash);
	void REMOVE_MODEL_FROM_CREATOR_BUDGET(Hash modelHash);
	float GET_USED_CREATOR_BUDGET();
	void SET_ISLAND_ENABLED(const char* name, BOOL toggle);
}

namespace TASK
{
	void TASK_PAUSE(Ped ped, int ms);
	void TASK_STAND_STILL(Ped ped, int time);
	void TASK_JUMP(Ped ped, BOOL usePlayerLaunchForce, BOOL doSuperJump, BOOL useFullSuperJumpForce);
	void TASK_COWER(Ped ped, int duration);
	void TASK_HANDS_UP(Ped ped, int duration, Ped facingPed, int timeToFacePed, int flags);
	void UPDATE_TASK_HANDS_UP_DURATION(Ped ped, int duration);
	void TASK_OPEN_VEHICLE_DOOR(Ped ped, Vehicle vehicle, int timeOut, int seat, float speed);
	void TASK_ENTER_VEHICLE(Ped ped, Vehicle vehicle, int timeout, int seat, float speed, int flag, const char* overrideEntryClipsetName);
	void TASK_LEAVE_VEHICLE(Ped ped, Vehicle vehicle, int flags);
	void TASK_GET_OFF_BOAT(Ped ped, Vehicle boat);
	void TASK_SKY_DIVE(Ped ped, BOOL instant);
	void TASK_PARACHUTE(Ped ped, BOOL giveParachuteItem, BOOL instant);
	void TASK_PARACHUTE_TO_TARGET(Ped ped, float x, float y, float z);
	void SET_PARACHUTE_TASK_TARGET(Ped ped, float x, float y, float z);
	void SET_PARACHUTE_TASK_THRUST(Ped ped, float thrust);
	void TASK_RAPPEL_FROM_HELI(Ped ped, float minHeightAboveGround);
	void TASK_VEHICLE_DRIVE_TO_COORD(Ped ped, Vehicle vehicle, float x, float y, float z, float speed, Any p6, Hash vehicleModel, int drivingMode, float stopRange, float straightLineDistance);
	void TASK_VEHICLE_DRIVE_TO_COORD_LONGRANGE(Ped ped, Vehicle vehicle, float x, float y, float z, float speed, int driveMode, float stopRange);
	void TASK_VEHICLE_DRIVE_WANDER(Ped ped, Vehicle vehicle, float speed, int drivingStyle);
	void TASK_FOLLOW_TO_OFFSET_OF_ENTITY(Ped ped, Entity entity, float offsetX, float offsetY, float offsetZ, float movementSpeed, int timeout, float stoppingRange, BOOL persistFollowing);
	void TASK_GO_STRAIGHT_TO_COORD(Ped ped, float x, float y, float z, float speed, int timeout, float targetHeading, float distanceToSlide);
	void TASK_GO_STRAIGHT_TO_COORD_RELATIVE_TO_ENTITY(Ped ped, Entity entity, float x, float y, float z, float moveBlendRatio, int time);
	void TASK_ACHIEVE_HEADING(Ped ped, float heading, int timeout);
	void TASK_FLUSH_ROUTE();
	void TASK_EXTEND_ROUTE(float x, float y, float z);
	void TASK_FOLLOW_POINT_ROUTE(Ped ped, float speed, int mode);
	void TASK_GO_TO_ENTITY(Entity entity, Entity target, int duration, float distance, float moveBlendRatio, float slowDownDistance, int flags);
	void TASK_SMART_FLEE_COORD(Ped ped, float x, float y, float z, float distance, int time, BOOL preferPavements, BOOL quitIfOutOfRange);
	void TASK_SMART_FLEE_PED(Ped ped, Ped fleeTarget, float safeDistance, int fleeTime, BOOL preferPavements, BOOL updateToNearestHatedPed);
	void TASK_REACT_AND_FLEE_PED(Ped ped, Ped fleeTarget);
	void TASK_SHOCKING_EVENT_REACT(Ped ped, int eventHandle);
	void TASK_WANDER_IN_AREA(Ped ped, float x, float y, float z, float radius, float minimalLength, float timeBetweenWalks);
	void TASK_WANDER_STANDARD(Ped ped, float heading, int flags);
	void TASK_WANDER_SPECIFIC(Ped ped, const char* conditionalAnimGroupStr, const char* conditionalAnimStr, float heading);
	void TASK_VEHICLE_PARK(Ped ped, Vehicle vehicle, float x, float y, float z, float heading, int mode, float radius, BOOL keepEngineOn);
	void TASK_STEALTH_KILL(Ped killer, Ped target, Hash stealthKillActionResultHash, float desiredMoveBlendRatio, int stealthFlags);
	void TASK_PLANT_BOMB(Ped ped, float x, float y, float z, float heading);
	void TASK_FOLLOW_NAV_MESH_TO_COORD(Ped ped, float x, float y, float z, float moveBlendRatio, int time, float targetRadius, int flags, float targetHeading);
	void TASK_FOLLOW_NAV_MESH_TO_COORD_ADVANCED(Ped ped, float x, float y, float z, float moveBlendRatio, int time, float targetRadius, int flags, float slideToCoordHeading, float maxSlopeNavigable, float clampMaxSearchDistance, float targetHeading);
	void SET_PED_PATH_CAN_USE_CLIMBOVERS(Ped ped, BOOL Toggle);
	void SET_PED_PATH_CAN_USE_LADDERS(Ped ped, BOOL Toggle);
	void SET_PED_PATH_CAN_DROP_FROM_HEIGHT(Ped ped, BOOL Toggle);
	void SET_PED_PATH_CLIMB_COST_MODIFIER(Ped ped, float modifier);
	void SET_PED_PATH_MAY_ENTER_WATER(Ped ped, BOOL mayEnterWater);
	void SET_PED_PATH_PREFER_TO_AVOID_WATER(Ped ped, BOOL avoidWater);
	void SET_PED_PATH_AVOID_FIRE(Ped ped, BOOL avoidFire);
	void SET_GLOBAL_MIN_BIRD_FLIGHT_HEIGHT(float height);
	int GET_NAVMESH_ROUTE_DISTANCE_REMAINING(Ped ped, float* distanceRemaining, BOOL* isPathReady);
	int GET_NAVMESH_ROUTE_RESULT(Ped ped);
	BOOL IS_CONTROLLED_VEHICLE_UNABLE_TO_GET_TO_ROAD(Ped ped);
	void TASK_GO_TO_COORD_ANY_MEANS(Ped ped, float x, float y, float z, float moveBlendRatio, Vehicle vehicle, BOOL useLongRangeVehiclePathing, int drivingFlags, float maxRangeToShootTargets);
	void TASK_GO_TO_COORD_ANY_MEANS_EXTRA_PARAMS(Ped ped, float x, float y, float z, float moveBlendRatio, Vehicle vehicle, BOOL useLongRangeVehiclePathing, int drivingFlags, float maxRangeToShootTargets, float extraVehToTargetDistToPreferVehicle, float driveStraightLineDistance, int extraFlags, float warpTimerMS);
	void TASK_GO_TO_COORD_ANY_MEANS_EXTRA_PARAMS_WITH_CRUISE_SPEED(Ped ped, float x, float y, float z, float moveBlendRatio, Vehicle vehicle, BOOL useLongRangeVehiclePathing, int drivingFlags, float maxRangeToShootTargets, float extraVehToTargetDistToPreferVehicle, float driveStraightLineDistance, int extraFlags, float cruiseSpeed, float targetArriveDist);
	void TASK_PLAY_ANIM(Ped ped, const char* animDictionary, const char* animationName, float blendInSpeed, float blendOutSpeed, int duration, int flag, float playbackRate, BOOL lockX, BOOL lockY, BOOL lockZ);
	void TASK_PLAY_ANIM_ADVANCED(Ped ped, const char* animDict, const char* animName, float posX, float posY, float posZ, float rotX, float rotY, float rotZ, float animEnterSpeed, float animExitSpeed, int duration, Any flag, float animTime, int rotOrder, int ikFlags);
	void STOP_ANIM_TASK(Entity entity, const char* animDictionary, const char* animationName, float blendDelta);
	void TASK_SCRIPTED_ANIMATION(Ped ped, int* priorityLowData, int* priorityMidData, int* priorityHighData, float blendInDelta, float blendOutDelta);
	void PLAY_ENTITY_SCRIPTED_ANIM(Entity entity, int* priorityLowData, int* priorityMidData, int* priorityHighData, float blendInDelta, float blendOutDelta);
	void STOP_ANIM_PLAYBACK(Entity entity, int priority, BOOL secondary);
	void SET_ANIM_WEIGHT(Entity entity, float weight, int priority, int index, BOOL secondary);
	void SET_ANIM_PHASE(Entity entity, float phase, int priority, BOOL secondary);
	void SET_ANIM_RATE(Entity entity, float rate, int priority, BOOL secondary);
	void SET_ANIM_LOOPED(Entity entity, BOOL looped, int priority, BOOL secondary);
	void TASK_PLAY_PHONE_GESTURE_ANIMATION(Ped ped, const char* animDict, const char* animation, const char* boneMaskType, float blendInDuration, float blendOutDuration, BOOL isLooping, BOOL holdLastFrame);
	void TASK_STOP_PHONE_GESTURE_ANIMATION(Ped ped, float blendOutOverride);
	BOOL IS_PLAYING_PHONE_GESTURE_ANIM(Ped ped);
	float GET_PHONE_GESTURE_ANIM_CURRENT_TIME(Ped ped);
	float GET_PHONE_GESTURE_ANIM_TOTAL_TIME(Ped ped);
	void TASK_VEHICLE_PLAY_ANIM(Vehicle vehicle, const char* animationSet, const char* animationName);
	void TASK_LOOK_AT_COORD(Entity entity, float x, float y, float z, int duration, int flags, int priority);
	void TASK_LOOK_AT_ENTITY(Ped ped, Entity lookAt, int duration, int flags, int priority);
	void TASK_CLEAR_LOOK_AT(Ped ped);
	void OPEN_SEQUENCE_TASK(int* taskSequenceId);
	void CLOSE_SEQUENCE_TASK(int taskSequenceId);
	void TASK_PERFORM_SEQUENCE(Ped ped, int taskSequenceId);
	void TASK_PERFORM_SEQUENCE_LOCALLY(Ped ped, int taskSequenceId);
	void CLEAR_SEQUENCE_TASK(int* taskSequenceId);
	void SET_SEQUENCE_TO_REPEAT(int taskSequenceId, BOOL repeat);
	int GET_SEQUENCE_PROGRESS(Ped ped);
	BOOL GET_IS_TASK_ACTIVE(Ped ped, int taskIndex);
	int GET_SCRIPT_TASK_STATUS(Ped ped, Hash taskHash);
	int GET_ACTIVE_VEHICLE_MISSION_TYPE(Vehicle vehicle);
	void TASK_LEAVE_ANY_VEHICLE(Ped ped, int delayTime, int flags);
	void TASK_AIM_GUN_SCRIPTED(Ped ped, Hash scriptTask, BOOL disableBlockingClip, BOOL instantBlendToAim);
	void TASK_AIM_GUN_SCRIPTED_WITH_TARGET(Ped ped, Ped target, float x, float y, float z, int gunTaskType, BOOL disableBlockingClip, BOOL forceAim);
	void UPDATE_TASK_AIM_GUN_SCRIPTED_TARGET(Ped ped, Ped target, float x, float y, float z, BOOL disableBlockingClip);
	const char* GET_CLIP_SET_FOR_SCRIPTED_GUN_TASK(int gunTaskType);
	void TASK_AIM_GUN_AT_ENTITY(Ped ped, Entity entity, int duration, BOOL instantBlendToAim);
	void TASK_TURN_PED_TO_FACE_ENTITY(Ped ped, Entity entity, int duration);
	void TASK_AIM_GUN_AT_COORD(Ped ped, float x, float y, float z, int time, BOOL instantBlendToAim, BOOL playAnimIntro);
	void TASK_SHOOT_AT_COORD(Ped ped, float x, float y, float z, int duration, Hash firingPattern);
	void TASK_SHUFFLE_TO_NEXT_VEHICLE_SEAT(Ped ped, Vehicle vehicle, BOOL useAlternateShuffle);
	void CLEAR_PED_TASKS(Ped ped);
	void CLEAR_PED_SECONDARY_TASK(Ped ped);
	void TASK_EVERYONE_LEAVE_VEHICLE(Vehicle vehicle);
	void TASK_GOTO_ENTITY_OFFSET(Ped ped, Entity entity, int time, float seekRadius, float seekAngleDeg, float moveBlendRatio, int gotoEntityOffsetFlags);
	void TASK_GOTO_ENTITY_OFFSET_XY(Ped ped, Entity entity, int duration, float targetRadius, float offsetX, float offsetY, float moveBlendRatio, int gotoEntityOffsetFlags);
	void TASK_TURN_PED_TO_FACE_COORD(Ped ped, float x, float y, float z, int duration);
	void TASK_VEHICLE_TEMP_ACTION(Ped driver, Vehicle vehicle, int action, int time);
	void TASK_VEHICLE_MISSION(Ped driver, Vehicle vehicle, Vehicle vehicleTarget, int missionType, float cruiseSpeed, int drivingStyle, float targetReached, float straightLineDistance, BOOL DriveAgainstTraffic);
	void TASK_VEHICLE_MISSION_PED_TARGET(Ped ped, Vehicle vehicle, Ped pedTarget, int missionType, float maxSpeed, int drivingStyle, float minDistance, float straightLineDistance, BOOL DriveAgainstTraffic);
	void TASK_VEHICLE_MISSION_COORS_TARGET(Ped ped, Vehicle vehicle, float x, float y, float z, int mission, float cruiseSpeed, int drivingStyle, float targetReached, float straightLineDistance, BOOL DriveAgainstTraffic);
	void TASK_VEHICLE_ESCORT(Ped ped, Vehicle vehicle, Vehicle targetVehicle, int mode, float speed, int drivingStyle, float minDistance, int minHeightAboveTerrain, float noRoadsDistance);
	void TASK_VEHICLE_FOLLOW(Ped driver, Vehicle vehicle, Entity targetEntity, float speed, int drivingStyle, int minDistance);
	void TASK_VEHICLE_CHASE(Ped driver, Entity targetEnt);
	void TASK_VEHICLE_HELI_PROTECT(Ped pilot, Vehicle vehicle, Entity entityToFollow, float targetSpeed, int drivingFlags, float radius, int altitude, int heliFlags);
	void SET_TASK_VEHICLE_CHASE_BEHAVIOR_FLAG(Ped ped, int flag, BOOL set);
	void SET_TASK_VEHICLE_CHASE_IDEAL_PURSUIT_DISTANCE(Ped ped, float distance);
	void TASK_HELI_CHASE(Ped pilot, Entity entityToFollow, float x, float y, float z);
	void TASK_PLANE_CHASE(Ped pilot, Entity entityToFollow, float x, float y, float z);
	void TASK_PLANE_LAND(Ped pilot, Vehicle plane, float runwayStartX, float runwayStartY, float runwayStartZ, float runwayEndX, float runwayEndY, float runwayEndZ);
	void CLEAR_DEFAULT_PRIMARY_TASK(Ped ped);
	void CLEAR_PRIMARY_VEHICLE_TASK(Vehicle vehicle);
	void CLEAR_VEHICLE_CRASH_TASK(Vehicle vehicle);
	void TASK_PLANE_GOTO_PRECISE_VTOL(Ped ped, Vehicle vehicle, float x, float y, float z, int flightHeight, int minHeightAboveTerrain, BOOL useDesiredOrientation, float desiredOrientation, BOOL autopilot);
	void TASK_SUBMARINE_GOTO_AND_STOP(Ped ped, Vehicle submarine, float x, float y, float z, BOOL autopilot);
	void TASK_HELI_MISSION(Ped pilot, Vehicle aircraft, Vehicle targetVehicle, Ped targetPed, float destinationX, float destinationY, float destinationZ, int missionFlag, float maxSpeed, float radius, float targetHeading, int maxHeight, int minHeight, float slowDownDistance, int behaviorFlags);
	void TASK_HELI_ESCORT_HELI(Ped pilot, Vehicle heli1, Vehicle heli2, float offsetX, float offsetY, float offsetZ);
	void TASK_PLANE_MISSION(Ped pilot, Vehicle aircraft, Vehicle targetVehicle, Ped targetPed, float destinationX, float destinationY, float destinationZ, int missionFlag, float angularDrag, float targetReached, float targetHeading, float maxZ, float minZ, BOOL precise);
	void TASK_PLANE_TAXI(Ped pilot, Vehicle aircraft, float x, float y, float z, float cruiseSpeed, float targetReached);
	void TASK_BOAT_MISSION(Ped pedDriver, Vehicle vehicle, Vehicle targetVehicle, Ped targetPed, float x, float y, float z, int mission, float maxSpeed, int drivingStyle, float targetReached, Any boatFlags);
	void TASK_DRIVE_BY(Ped driverPed, Ped targetPed, Vehicle targetVehicle, float targetX, float targetY, float targetZ, float distanceToShoot, int pedAccuracy, BOOL pushUnderneathDrivingTaskIfDriving, Hash firingPattern);
	void SET_DRIVEBY_TASK_TARGET(Ped shootingPed, Ped targetPed, Vehicle targetVehicle, float x, float y, float z);
	void CLEAR_DRIVEBY_TASK_UNDERNEATH_DRIVING_TASK(Ped ped);
	BOOL IS_DRIVEBY_TASK_UNDERNEATH_DRIVING_TASK(Ped ped);
	BOOL CONTROL_MOUNTED_WEAPON(Ped ped);
	void SET_MOUNTED_WEAPON_TARGET(Ped shootingPed, Ped targetPed, Vehicle targetVehicle, float x, float y, float z, int taskMode, BOOL ignoreTargetVehDeadCheck);
	BOOL IS_MOUNTED_WEAPON_TASK_UNDERNEATH_DRIVING_TASK(Ped ped);
	void TASK_USE_MOBILE_PHONE(Ped ped, BOOL usePhone, int desiredPhoneMode);
	void TASK_USE_MOBILE_PHONE_TIMED(Ped ped, int duration);
	void TASK_CHAT_TO_PED(Ped ped, Ped target, int flags, float goToLocationX, float goToLocationY, float goToLocationZ, float headingDegs, float idleTime);
	void TASK_WARP_PED_INTO_VEHICLE(Ped ped, Vehicle vehicle, int seat);
	void TASK_SHOOT_AT_ENTITY(Entity entity, Entity target, int duration, Hash firingPattern);
	void TASK_CLIMB(Ped ped, BOOL usePlayerLaunchForce);
	void TASK_CLIMB_LADDER(Ped ped, BOOL fast);
	void TASK_RAPPEL_DOWN_WALL_USING_CLIPSET_OVERRIDE(Ped ped, float x1, float y1, float z1, float x2, float y2, float z2, float minZ, int ropeHandle, const char* clipSet, Any p10);
	int GET_TASK_RAPPEL_DOWN_WALL_STATE(Ped ped);
	void CLEAR_PED_TASKS_IMMEDIATELY(Ped ped);
	void TASK_PERFORM_SEQUENCE_FROM_PROGRESS(Ped ped, int taskIndex, int progress1, int progress2);
	void SET_NEXT_DESIRED_MOVE_STATE(float nextMoveState);
	void SET_PED_DESIRED_MOVE_BLEND_RATIO(Ped ped, float newMoveBlendRatio);
	float GET_PED_DESIRED_MOVE_BLEND_RATIO(Ped ped);
	void TASK_GOTO_ENTITY_AIMING(Ped ped, Entity target, float distanceToStopAt, float StartAimingDist);
	void TASK_SET_DECISION_MAKER(Ped ped, Hash decisionMakerId);
	void TASK_SET_SPHERE_DEFENSIVE_AREA(Ped ped, float x, float y, float z, float radius);
	void TASK_CLEAR_DEFENSIVE_AREA(Ped ped);
	void TASK_PED_SLIDE_TO_COORD(Ped ped, float x, float y, float z, float heading, float speed);
	void TASK_PED_SLIDE_TO_COORD_HDG_RATE(Ped ped, float x, float y, float z, float heading, float speed, float headingChangeRate);
	ScrHandle ADD_COVER_POINT(float x, float y, float z, float direction, int usage, int height, int arc, BOOL isPriority);
	void REMOVE_COVER_POINT(ScrHandle coverpoint);
	BOOL DOES_SCRIPTED_COVER_POINT_EXIST_AT_COORDS(float x, float y, float z);
	Vector3 GET_SCRIPTED_COVER_POINT_COORDS(ScrHandle coverpoint);
	void ADD_SCRIPTED_COVER_AREA(float x, float y, float z, float radius);
	void TASK_COMBAT_PED(Ped ped, Ped targetPed, int combatFlags, int threatResponseFlags);
	void TASK_COMBAT_PED_TIMED(Ped ped, Ped target, int time, int flags);
	void TASK_SEEK_COVER_FROM_POS(Ped ped, float x, float y, float z, int duration, BOOL allowPeekingAndFiring);
	void TASK_SEEK_COVER_FROM_PED(Ped ped, Ped target, int duration, BOOL allowPeekingAndFiring);
	void TASK_SEEK_COVER_TO_COVER_POINT(Ped ped, ScrHandle coverpoint, float x, float y, float z, int time, BOOL allowPeekingAndFiring);
	void TASK_SEEK_COVER_TO_COORDS(Ped ped, float x1, float y1, float z1, float x2, float y2, float z2, int timeout, BOOL shortRoute);
	void TASK_PUT_PED_DIRECTLY_INTO_COVER(Ped ped, float x, float y, float z, int time, BOOL allowPeekingAndFiring, float blendInDuration, BOOL forceInitialFacingDirection, BOOL forceFaceLeft, int identifier, BOOL doEntry);
	void TASK_WARP_PED_DIRECTLY_INTO_COVER(Ped ped, int time, BOOL allowPeekingAndFiring, BOOL forceInitialFacingDirection, BOOL forceFaceLeft, int identifier);
	void TASK_EXIT_COVER(Ped ped, int exitType, float x, float y, float z);
	void TASK_PUT_PED_DIRECTLY_INTO_MELEE(Ped ped, Ped meleeTarget, float blendInDuration, float timeInMelee, float strafePhaseSync, int aiCombatFlags);
	void TASK_TOGGLE_DUCK(Ped ped, int toggleType);
	void TASK_GUARD_CURRENT_POSITION(Ped ped, float maxPatrolProximity, float defensiveAreaRadius, BOOL setDefensiveArea);
	void TASK_GUARD_ASSIGNED_DEFENSIVE_AREA(Ped ped, float x, float y, float z, float heading, float maxPatrolProximity, int timer);
	void TASK_GUARD_SPHERE_DEFENSIVE_AREA(Ped ped, float defendPositionX, float defendPositionY, float defendPositionZ, float heading, float maxPatrolProximity, int time, float x, float y, float z, float defensiveAreaRadius);
	void TASK_STAND_GUARD(Ped ped, float x, float y, float z, float heading, const char* scenarioName);
	void SET_DRIVE_TASK_CRUISE_SPEED(Ped driver, float cruiseSpeed);
	void SET_DRIVE_TASK_MAX_CRUISE_SPEED(Ped ped, float speed);
	void SET_DRIVE_TASK_DRIVING_STYLE(Ped ped, int drivingStyle);
	void ADD_COVER_BLOCKING_AREA(float startX, float startY, float startZ, float endX, float endY, float endZ, BOOL blockObjects, BOOL blockVehicles, BOOL blockMap, BOOL blockPlayer);
	void REMOVE_ALL_COVER_BLOCKING_AREAS();
	void REMOVE_COVER_BLOCKING_AREAS_AT_POSITION(float x, float y, float z);
	void REMOVE_SPECIFIC_COVER_BLOCKING_AREAS(float startX, float startY, float startZ, float endX, float endY, float endZ, BOOL blockObjects, BOOL blockVehicles, BOOL blockMap, BOOL blockPlayer);
	void TASK_START_SCENARIO_IN_PLACE(Ped ped, const char* scenarioName, int unkDelay, BOOL playEnterAnim);
	void TASK_START_SCENARIO_AT_POSITION(Ped ped, const char* scenarioName, float x, float y, float z, float heading, int duration, BOOL sittingScenario, BOOL teleport);
	void TASK_USE_NEAREST_SCENARIO_TO_COORD(Ped ped, float x, float y, float z, float distance, int duration);
	void TASK_USE_NEAREST_SCENARIO_TO_COORD_WARP(Ped ped, float x, float y, float z, float radius, int timeToLeave);
	void TASK_USE_NEAREST_SCENARIO_CHAIN_TO_COORD(Ped ped, float x, float y, float z, float maxRange, int timeToLeave);
	void TASK_USE_NEAREST_SCENARIO_CHAIN_TO_COORD_WARP(Ped ped, float x, float y, float z, float radius, int timeToLeave);
	BOOL DOES_SCENARIO_EXIST_IN_AREA(float x, float y, float z, float radius, BOOL mustBeFree);
	BOOL DOES_SCENARIO_OF_TYPE_EXIST_IN_AREA(float x, float y, float z, const char* scenarioName, float radius, BOOL mustBeFree);
	BOOL IS_SCENARIO_OCCUPIED(float x, float y, float z, float maxRange, BOOL onlyUsersActuallyAtScenario);
	BOOL PED_HAS_USE_SCENARIO_TASK(Ped ped);
	void PLAY_ANIM_ON_RUNNING_SCENARIO(Ped ped, const char* animDict, const char* animName);
	BOOL DOES_SCENARIO_GROUP_EXIST(const char* scenarioGroup);
	BOOL IS_SCENARIO_GROUP_ENABLED(const char* scenarioGroup);
	void SET_SCENARIO_GROUP_ENABLED(const char* scenarioGroup, BOOL enabled);
	void RESET_SCENARIO_GROUPS_ENABLED();
	void SET_EXCLUSIVE_SCENARIO_GROUP(const char* scenarioGroup);
	void RESET_EXCLUSIVE_SCENARIO_GROUP();
	BOOL IS_SCENARIO_TYPE_ENABLED(const char* scenarioType);
	void SET_SCENARIO_TYPE_ENABLED(const char* scenarioType, BOOL toggle);
	void RESET_SCENARIO_TYPES_ENABLED();
	BOOL IS_PED_ACTIVE_IN_SCENARIO(Ped ped);
	BOOL IS_PED_PLAYING_BASE_CLIP_IN_SCENARIO(Ped ped);
	void SET_PED_CAN_PLAY_AMBIENT_IDLES(Ped ped, BOOL blockIdleClips, BOOL removeIdleClipIfPlaying);
	void TASK_COMBAT_HATED_TARGETS_IN_AREA(Ped ped, float x, float y, float z, float radius, int combatFlags);
	void TASK_COMBAT_HATED_TARGETS_AROUND_PED(Ped ped, float radius, int combatFlags);
	void TASK_COMBAT_HATED_TARGETS_AROUND_PED_TIMED(Ped ped, float radius, int time, int combatFlags);
	void TASK_THROW_PROJECTILE(Ped ped, float x, float y, float z, int ignoreCollisionEntityIndex, BOOL createInvincibleProjectile);
	void TASK_SWAP_WEAPON(Ped ped, BOOL drawWeapon);
	void TASK_RELOAD_WEAPON(Ped ped, BOOL drawWeapon);
	BOOL IS_PED_GETTING_UP(Ped ped);
	void TASK_WRITHE(Ped ped, Ped target, int minFireLoops, int startState, BOOL forceShootOnGround, int shootFromGroundTimer);
	BOOL IS_PED_IN_WRITHE(Ped ped);
	void OPEN_PATROL_ROUTE(const char* patrolRoute);
	void CLOSE_PATROL_ROUTE();
	void ADD_PATROL_ROUTE_NODE(int nodeId, const char* nodeType, float posX, float posY, float posZ, float headingX, float headingY, float headingZ, int duration);
	void ADD_PATROL_ROUTE_LINK(int nodeId1, int nodeId2);
	void CREATE_PATROL_ROUTE();
	void DELETE_PATROL_ROUTE(const char* patrolRoute);
	BOOL GET_PATROL_TASK_INFO(Ped ped, int* timeLeftAtNode, int* nodeId);
	void TASK_PATROL(Ped ped, const char* patrolRouteName, int alertState, BOOL canChatToPeds, BOOL useHeadLookAt);
	void TASK_STAY_IN_COVER(Ped ped);
	void ADD_VEHICLE_SUBTASK_ATTACK_COORD(Ped ped, float x, float y, float z);
	void ADD_VEHICLE_SUBTASK_ATTACK_PED(Ped ped, Ped target);
	void TASK_VEHICLE_SHOOT_AT_PED(Ped ped, Ped target, float fireTolerance);
	void TASK_VEHICLE_AIM_AT_PED(Ped ped, Ped target);
	void TASK_VEHICLE_SHOOT_AT_COORD(Ped ped, float x, float y, float z, float fireTolerance);
	void TASK_VEHICLE_AIM_AT_COORD(Ped ped, float x, float y, float z);
	void TASK_VEHICLE_GOTO_NAVMESH(Ped ped, Vehicle vehicle, float x, float y, float z, float speed, int behaviorFlag, float stoppingRange);
	void TASK_GO_TO_COORD_WHILE_AIMING_AT_COORD(Ped ped, float x, float y, float z, float aimAtX, float aimAtY, float aimAtZ, float moveBlendRatio, BOOL shoot, float targetRadius, float slowDistance, BOOL useNavMesh, int navFlags, BOOL instantBlendToAim, Hash firingPattern);
	void TASK_GO_TO_COORD_WHILE_AIMING_AT_ENTITY(Ped ped, float x, float y, float z, Entity aimAtID, float moveBlendRatio, BOOL shoot, float targetRadius, float slowDistance, BOOL useNavMesh, int navFlags, BOOL instantBlendToAim, Hash firingPattern, int time);
	void TASK_GO_TO_COORD_AND_AIM_AT_HATED_ENTITIES_NEAR_COORD(Ped pedHandle, float goToLocationX, float goToLocationY, float goToLocationZ, float focusLocationX, float focusLocationY, float focusLocationZ, float speed, BOOL shootAtEnemies, float distanceToStopAt, float noRoadsDistance, BOOL useNavMesh, int navFlags, int taskFlags, Hash firingPattern);
	void TASK_GO_TO_ENTITY_WHILE_AIMING_AT_COORD(Ped ped, Entity entity, float aimX, float aimY, float aimZ, float moveBlendRatio, BOOL shoot, float targetRadius, float slowDistance, BOOL useNavMesh, BOOL instantBlendToAim, Hash firingPattern);
	void TASK_GO_TO_ENTITY_WHILE_AIMING_AT_ENTITY(Ped ped, Entity entityToWalkTo, Entity entityToAimAt, float speed, BOOL shootatEntity, float targetRadius, float slowDistance, BOOL useNavMesh, BOOL instantBlendToAim, Hash firingPattern);
	void SET_HIGH_FALL_TASK(Ped ped, int minTime, int maxTime, int entryType);
	void REQUEST_WAYPOINT_RECORDING(const char* name);
	BOOL GET_IS_WAYPOINT_RECORDING_LOADED(const char* name);
	void REMOVE_WAYPOINT_RECORDING(const char* name);
	BOOL WAYPOINT_RECORDING_GET_NUM_POINTS(const char* name, int* points);
	BOOL WAYPOINT_RECORDING_GET_COORD(const char* name, int point, Vector3* coord);
	float WAYPOINT_RECORDING_GET_SPEED_AT_POINT(const char* name, int point);
	BOOL WAYPOINT_RECORDING_GET_CLOSEST_WAYPOINT(const char* name, float x, float y, float z, int* point);
	void TASK_FOLLOW_WAYPOINT_RECORDING(Ped ped, const char* name, int p2, int p3, int p4);
	BOOL IS_WAYPOINT_PLAYBACK_GOING_ON_FOR_PED(Ped ped);
	int GET_PED_WAYPOINT_PROGRESS(Ped ped);
	float GET_PED_WAYPOINT_DISTANCE(Any p0);
	BOOL SET_PED_WAYPOINT_ROUTE_OFFSET(Ped ped, float x, float y, float z);
	float GET_WAYPOINT_DISTANCE_ALONG_ROUTE(const char* name, int point);
	BOOL WAYPOINT_PLAYBACK_GET_IS_PAUSED(Any p0);
	void WAYPOINT_PLAYBACK_PAUSE(Any p0, BOOL p1, BOOL p2);
	void WAYPOINT_PLAYBACK_RESUME(Any p0, BOOL p1, Any p2, Any p3);
	void WAYPOINT_PLAYBACK_OVERRIDE_SPEED(Any p0, float p1, BOOL p2);
	void WAYPOINT_PLAYBACK_USE_DEFAULT_SPEED(Any p0);
	void USE_WAYPOINT_RECORDING_AS_ASSISTED_MOVEMENT_ROUTE(const char* name, BOOL p1, float p2, float p3);
	void WAYPOINT_PLAYBACK_START_AIMING_AT_PED(Ped ped, Ped target, BOOL p2);
	void WAYPOINT_PLAYBACK_START_AIMING_AT_COORD(Ped ped, float x, float y, float z, BOOL p4);
	void WAYPOINT_PLAYBACK_START_SHOOTING_AT_PED(Ped ped, Ped ped2, BOOL p2, BOOL p3);
	void WAYPOINT_PLAYBACK_START_SHOOTING_AT_COORD(Ped ped, float x, float y, float z, BOOL p4, Hash firingPattern);
	void WAYPOINT_PLAYBACK_STOP_AIMING_OR_SHOOTING(Ped ped);
	void ASSISTED_MOVEMENT_REQUEST_ROUTE(const char* route);
	void ASSISTED_MOVEMENT_REMOVE_ROUTE(const char* route);
	BOOL ASSISTED_MOVEMENT_IS_ROUTE_LOADED(const char* route);
	void ASSISTED_MOVEMENT_SET_ROUTE_PROPERTIES(const char* route, int props);
	void ASSISTED_MOVEMENT_OVERRIDE_LOAD_DISTANCE_THIS_FRAME(float dist);
	void TASK_VEHICLE_FOLLOW_WAYPOINT_RECORDING(Ped ped, Vehicle vehicle, const char* WPRecording, int p3, int p4, int p5, int p6, float p7, BOOL p8, float p9);
	BOOL IS_WAYPOINT_PLAYBACK_GOING_ON_FOR_VEHICLE(Vehicle vehicle);
	int GET_VEHICLE_WAYPOINT_PROGRESS(Vehicle vehicle);
	int GET_VEHICLE_WAYPOINT_TARGET_POINT(Vehicle vehicle);
	void VEHICLE_WAYPOINT_PLAYBACK_PAUSE(Vehicle vehicle);
	void VEHICLE_WAYPOINT_PLAYBACK_RESUME(Vehicle vehicle);
	void VEHICLE_WAYPOINT_PLAYBACK_USE_DEFAULT_SPEED(Vehicle vehicle);
	void VEHICLE_WAYPOINT_PLAYBACK_OVERRIDE_SPEED(Vehicle vehicle, float speed);
	void TASK_SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(Ped ped, BOOL toggle);
	void TASK_FORCE_MOTION_STATE(Ped ped, Hash state, BOOL forceRestart);
	void TASK_MOVE_NETWORK_BY_NAME(Ped ped, const char* task, float multiplier, BOOL allowOverrideCloneUpdate, const char* animDict, int flags);
	void TASK_MOVE_NETWORK_ADVANCED_BY_NAME(Ped ped, const char* network, float x, float y, float z, float rotX, float rotY, float rotZ, int rotOrder, float blendDuration, BOOL allowOverrideCloneUpdate, const char* animDict, int flags);
	void TASK_MOVE_NETWORK_BY_NAME_WITH_INIT_PARAMS(Ped ped, const char* network, int* initialParameters, float blendDuration, BOOL allowOverrideCloneUpdate, const char* animDict, int flags);
	void TASK_MOVE_NETWORK_ADVANCED_BY_NAME_WITH_INIT_PARAMS(Ped ped, const char* network, int* initialParameters, float x, float y, float z, float rotX, float rotY, float rotZ, int rotOrder, float blendDuration, BOOL allowOverrideCloneUpdate, const char* dictionary, int flags);
	BOOL IS_TASK_MOVE_NETWORK_ACTIVE(Ped ped);
	BOOL IS_TASK_MOVE_NETWORK_READY_FOR_TRANSITION(Ped ped);
	BOOL REQUEST_TASK_MOVE_NETWORK_STATE_TRANSITION(Ped ped, const char* name);
	BOOL SET_EXPECTED_CLONE_NEXT_TASK_MOVE_NETWORK_STATE(Ped ped, const char* state);
	const char* GET_TASK_MOVE_NETWORK_STATE(Ped ped);
	void SET_TASK_MOVE_NETWORK_ANIM_SET(Ped ped, Hash clipSet, Hash variableClipSet);
	void SET_TASK_MOVE_NETWORK_SIGNAL_FLOAT(Ped ped, const char* signalName, float value);
	void SET_TASK_MOVE_NETWORK_SIGNAL_LOCAL_FLOAT(Ped ped, const char* signalName, float value);
	void SET_TASK_MOVE_NETWORK_SIGNAL_FLOAT_LERP_RATE(Ped ped, const char* signalName, float value);
	void SET_TASK_MOVE_NETWORK_SIGNAL_BOOL(Ped ped, const char* signalName, BOOL value);
	float GET_TASK_MOVE_NETWORK_SIGNAL_FLOAT(Ped ped, const char* signalName);
	BOOL GET_TASK_MOVE_NETWORK_SIGNAL_BOOL(Ped ped, const char* signalName);
	BOOL GET_TASK_MOVE_NETWORK_EVENT(Ped ped, const char* eventName);
	BOOL SET_TASK_MOVE_NETWORK_ENABLE_COLLISION_ON_NETWORK_CLONE_WHEN_FIXED(Ped ped, BOOL enable);
	BOOL IS_MOVE_BLEND_RATIO_STILL(Ped ped);
	BOOL IS_MOVE_BLEND_RATIO_WALKING(Ped ped);
	BOOL IS_MOVE_BLEND_RATIO_RUNNING(Ped ped);
	BOOL IS_MOVE_BLEND_RATIO_SPRINTING(Ped ped);
	BOOL IS_PED_STILL(Ped ped);
	BOOL IS_PED_WALKING(Ped ped);
	BOOL IS_PED_RUNNING(Ped ped);
	BOOL IS_PED_SPRINTING(Ped ped);
	BOOL IS_PED_STRAFING(Ped ped);
	void TASK_SYNCHRONIZED_SCENE(Ped ped, int scene, const char* animDictionary, const char* animationName, float blendIn, float blendOut, int flags, int ragdollBlockingFlags, float moverBlendDelta, int ikFlags);
	void TASK_AGITATED_ACTION_CONFRONT_RESPONSE(Ped ped, Ped ped2);
	void TASK_SWEEP_AIM_ENTITY(Ped ped, const char* animDict, const char* lowAnimName, const char* medAnimName, const char* hiAnimName, int runtime, Entity targetEntity, float turnRate, float blendInDuration);
	void UPDATE_TASK_SWEEP_AIM_ENTITY(Ped ped, Entity entity);
	void TASK_SWEEP_AIM_POSITION(Ped ped, const char* animDict, const char* lowAnimName, const char* medAnimName, const char* hiAnimName, int runtime, float x, float y, float z, float turnRate, float blendInDuration);
	void UPDATE_TASK_SWEEP_AIM_POSITION(Ped ped, float x, float y, float z);
	void TASK_ARREST_PED(Ped ped, Ped target);
	BOOL IS_PED_RUNNING_ARREST_TASK(Ped ped);
	BOOL IS_PED_BEING_ARRESTED(Ped ped);
	void UNCUFF_PED(Ped ped);
	BOOL IS_PED_CUFFED(Ped ped);
}

namespace VEHICLE
{
	Vehicle CREATE_VEHICLE(Hash modelHash, float x, float y, float z, float heading, BOOL isNetwork, BOOL bScriptHostVeh, BOOL p7);
	void DELETE_VEHICLE(Vehicle* vehicle);
	void SET_VEHICLE_ALLOW_HOMING_MISSLE_LOCKON(Vehicle vehicle, BOOL toggle, BOOL p2);
	void SET_VEHICLE_ALLOW_HOMING_MISSLE_LOCKON_SYNCED(Vehicle vehicle, BOOL canBeLockedOn, BOOL p2);
	void SET_VEHICLE_ALLOW_NO_PASSENGERS_LOCKON(Vehicle veh, BOOL toggle);
	int GET_VEHICLE_HOMING_LOCKON_STATE(Vehicle vehicle);
	int GET_VEHICLE_HOMING_LOCKEDONTO_STATE(Any p0);
	void SET_VEHICLE_HOMING_LOCKEDONTO_STATE(Any p0, Any p1);
	BOOL IS_VEHICLE_MODEL(Vehicle vehicle, Hash model);
	BOOL DOES_SCRIPT_VEHICLE_GENERATOR_EXIST(int vehicleGenerator);
	int CREATE_SCRIPT_VEHICLE_GENERATOR(float x, float y, float z, float heading, float p4, float p5, Hash modelHash, int p7, int p8, int p9, int p10, BOOL p11, BOOL p12, BOOL p13, BOOL p14, BOOL p15, int p16);
	void DELETE_SCRIPT_VEHICLE_GENERATOR(int vehicleGenerator);
	void SET_SCRIPT_VEHICLE_GENERATOR(int vehicleGenerator, BOOL enabled);
	void SET_ALL_VEHICLE_GENERATORS_ACTIVE_IN_AREA(float x1, float y1, float z1, float x2, float y2, float z2, BOOL toggle, BOOL p7);
	void SET_ALL_VEHICLE_GENERATORS_ACTIVE();
	void SET_ALL_LOW_PRIORITY_VEHICLE_GENERATORS_ACTIVE(BOOL active);
	void SET_VEHICLE_GENERATOR_AREA_OF_INTEREST(float x, float y, float z, float radius);
	void CLEAR_VEHICLE_GENERATOR_AREA_OF_INTEREST();
	BOOL SET_VEHICLE_ON_GROUND_PROPERLY(Vehicle vehicle, float p1);
	BOOL SET_VEHICLE_USE_CUTSCENE_WHEEL_COMPRESSION(Vehicle p0, BOOL p1, BOOL p2, BOOL p3);
	BOOL IS_VEHICLE_STUCK_ON_ROOF(Vehicle vehicle);
	void ADD_VEHICLE_UPSIDEDOWN_CHECK(Vehicle vehicle);
	void REMOVE_VEHICLE_UPSIDEDOWN_CHECK(Vehicle vehicle);
	BOOL IS_VEHICLE_STOPPED(Vehicle vehicle);
	int GET_VEHICLE_NUMBER_OF_PASSENGERS(Vehicle vehicle, BOOL includeDriver, BOOL includeDeadOccupants);
	int GET_VEHICLE_MAX_NUMBER_OF_PASSENGERS(Vehicle vehicle);
	int GET_VEHICLE_MODEL_NUMBER_OF_SEATS(Hash modelHash);
	BOOL IS_SEAT_WARP_ONLY(Vehicle vehicle, int seatIndex);
	BOOL IS_TURRET_SEAT(Vehicle vehicle, int seatIndex);
	BOOL DOES_VEHICLE_ALLOW_RAPPEL(Vehicle vehicle);
	void SET_VEHICLE_DENSITY_MULTIPLIER_THIS_FRAME(float multiplier);
	void SET_RANDOM_VEHICLE_DENSITY_MULTIPLIER_THIS_FRAME(float multiplier);
	void SET_PARKED_VEHICLE_DENSITY_MULTIPLIER_THIS_FRAME(float multiplier);
	void SET_DISABLE_RANDOM_TRAINS_THIS_FRAME(BOOL toggle);
	void SET_AMBIENT_VEHICLE_RANGE_MULTIPLIER_THIS_FRAME(float value);
	void SET_FAR_DRAW_VEHICLES(BOOL toggle);
	void SET_NUMBER_OF_PARKED_VEHICLES(int value);
	void SET_VEHICLE_DOORS_LOCKED(Vehicle vehicle, int doorLockStatus);
	void SET_VEHICLE_INDIVIDUAL_DOORS_LOCKED(Vehicle vehicle, int doorId, int doorLockStatus);
	void SET_VEHICLE_HAS_MUTED_SIRENS(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_DOORS_LOCKED_FOR_PLAYER(Vehicle vehicle, Player player, BOOL toggle);
	BOOL GET_VEHICLE_DOORS_LOCKED_FOR_PLAYER(Vehicle vehicle, Player player);
	void SET_VEHICLE_DOORS_LOCKED_FOR_ALL_PLAYERS(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_DOORS_LOCKED_FOR_NON_SCRIPT_PLAYERS(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_DOORS_LOCKED_FOR_TEAM(Vehicle vehicle, int team, BOOL toggle);
	void SET_VEHICLE_DOORS_LOCKED_FOR_ALL_TEAMS(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_DONT_TERMINATE_TASK_WHEN_ACHIEVED(Vehicle vehicle);
	void EXPLODE_VEHICLE(Vehicle vehicle, BOOL isAudible, BOOL isInvisible);
	void SET_VEHICLE_OUT_OF_CONTROL(Vehicle vehicle, BOOL killDriver, BOOL explodeOnImpact);
	void SET_VEHICLE_TIMED_EXPLOSION(Vehicle vehicle, Ped ped, BOOL toggle);
	void ADD_VEHICLE_PHONE_EXPLOSIVE_DEVICE(Vehicle vehicle);
	void CLEAR_VEHICLE_PHONE_EXPLOSIVE_DEVICE();
	BOOL HAS_VEHICLE_PHONE_EXPLOSIVE_DEVICE();
	void DETONATE_VEHICLE_PHONE_EXPLOSIVE_DEVICE();
	BOOL HAVE_VEHICLE_REAR_DOORS_BEEN_BLOWN_OPEN_BY_STICKYBOMB(Vehicle vehicle);
	void SET_TAXI_LIGHTS(Vehicle vehicle, BOOL state);
	BOOL IS_TAXI_LIGHT_ON(Vehicle vehicle);
	BOOL IS_VEHICLE_IN_GARAGE_AREA(const char* garageName, Vehicle vehicle);
	void SET_VEHICLE_COLOURS(Vehicle vehicle, int colorPrimary, int colorSecondary);
	void SET_VEHICLE_FULLBEAM(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_IS_RACING(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_CUSTOM_PRIMARY_COLOUR(Vehicle vehicle, int r, int g, int b);
	void GET_VEHICLE_CUSTOM_PRIMARY_COLOUR(Vehicle vehicle, int* r, int* g, int* b);
	void CLEAR_VEHICLE_CUSTOM_PRIMARY_COLOUR(Vehicle vehicle);
	BOOL GET_IS_VEHICLE_PRIMARY_COLOUR_CUSTOM(Vehicle vehicle);
	void SET_VEHICLE_CUSTOM_SECONDARY_COLOUR(Vehicle vehicle, int r, int g, int b);
	void GET_VEHICLE_CUSTOM_SECONDARY_COLOUR(Vehicle vehicle, int* r, int* g, int* b);
	void CLEAR_VEHICLE_CUSTOM_SECONDARY_COLOUR(Vehicle vehicle);
	BOOL GET_IS_VEHICLE_SECONDARY_COLOUR_CUSTOM(Vehicle vehicle);
	void SET_VEHICLE_ENVEFF_SCALE(Vehicle vehicle, float fade);
	float GET_VEHICLE_ENVEFF_SCALE(Vehicle vehicle);
	void SET_CAN_RESPRAY_VEHICLE(Vehicle vehicle, BOOL state);
	void SET_GOON_BOSS_VEHICLE(Vehicle vehicle, BOOL toggle);
	void SET_OPEN_REAR_DOORS_ON_EXPLOSION(Vehicle vehicle, BOOL toggle);
	void FORCE_SUBMARINE_SURFACE_MODE(Vehicle vehicle, BOOL toggle);
	void FORCE_SUBMARINE_NEURTAL_BUOYANCY(Any p0, Any p1);
	void SET_SUBMARINE_CRUSH_DEPTHS(Vehicle vehicle, BOOL p1, float depth1, float depth2, float depth3);
	BOOL GET_SUBMARINE_IS_UNDER_DESIGN_DEPTH(Vehicle submarine);
	int GET_SUBMARINE_NUMBER_OF_AIR_LEAKS(Vehicle submarine);
	void SET_BOAT_IGNORE_LAND_PROBES(Any p0, Any p1);
	void SET_BOUNDS_AFFECT_WATER_PROBES_(Vehicle vehicle, BOOL toggle);
	void SET_BOAT_ANCHOR(Vehicle vehicle, BOOL toggle);
	BOOL CAN_ANCHOR_BOAT_HERE(Vehicle vehicle);
	BOOL CAN_ANCHOR_BOAT_HERE_IGNORE_PLAYERS(Vehicle vehicle);
	void SET_BOAT_REMAINS_ANCHORED_WHILE_PLAYER_IS_DRIVER(Vehicle vehicle, BOOL toggle);
	void SET_FORCE_LOW_LOD_ANCHOR_MODE(Vehicle vehicle, BOOL p1);
	void SET_BOAT_LOW_LOD_ANCHOR_DISTANCE(Vehicle vehicle, float value);
	BOOL IS_BOAT_ANCHORED(Vehicle vehicle);
	void SET_BOAT_SINKS_WHEN_WRECKED(Vehicle vehicle, BOOL toggle);
	void SET_BOAT_WRECKED(Vehicle vehicle);
	void SET_VEHICLE_SIREN(Vehicle vehicle, BOOL toggle);
	BOOL IS_VEHICLE_SIREN_ON(Vehicle vehicle);
	BOOL IS_VEHICLE_SIREN_AUDIO_ON(Vehicle vehicle);
	void SET_VEHICLE_STRONG(Vehicle vehicle, BOOL toggle);
	void REMOVE_VEHICLE_STUCK_CHECK(Vehicle vehicle);
	void GET_VEHICLE_COLOURS(Vehicle vehicle, int* colorPrimary, int* colorSecondary);
	BOOL IS_VEHICLE_SEAT_FREE(Vehicle vehicle, int seatIndex, BOOL isTaskRunning);
	Ped GET_PED_IN_VEHICLE_SEAT(Vehicle vehicle, int seatIndex, BOOL p2);
	Ped GET_LAST_PED_IN_VEHICLE_SEAT(Vehicle vehicle, int seatIndex);
	BOOL GET_VEHICLE_LIGHTS_STATE(Vehicle vehicle, BOOL* lightsOn, BOOL* highbeamsOn);
	BOOL IS_VEHICLE_TYRE_BURST(Vehicle vehicle, int wheelID, BOOL completely);
	void SET_VEHICLE_FORWARD_SPEED(Vehicle vehicle, float speed);
	void SET_VEHICLE_FORWARD_SPEED_XY(Vehicle vehicle, float speed);
	void BRING_VEHICLE_TO_HALT(Vehicle vehicle, float distance, int duration, BOOL p3);
	void SET_VEHICLE_STEER_FOR_BUILDINGS(Vehicle vehicle, Any p1);
	void SET_VEHICLE_CAUSES_SWERVING(Vehicle vehicle, BOOL toggle);
	void SET_IGNORE_PLANES_SMALL_PITCH_CHANGE(Any p0, Any p1);
	void STOP_BRINGING_VEHICLE_TO_HALT(Vehicle vehicle);
	BOOL IS_VEHICLE_BEING_BROUGHT_TO_HALT(Vehicle vehicle);
	void LOWER_FORKLIFT_FORKS(Vehicle forklift);
	void SET_FORKLIFT_FORK_HEIGHT(Vehicle vehicle, float height);
	BOOL IS_ENTITY_ATTACHED_TO_HANDLER_FRAME(Vehicle vehicle, Entity entity);
	BOOL IS_ANY_ENTITY_ATTACHED_TO_HANDLER_FRAME(Vehicle vehicle);
	Vehicle FIND_HANDLER_VEHICLE_CONTAINER_IS_ATTACHED_TO(Entity entity);
	BOOL IS_HANDLER_FRAME_LINED_UP_WITH_CONTAINER(Vehicle vehicle, Entity entity);
	void ATTACH_CONTAINER_TO_HANDLER_FRAME_WHEN_LINED_UP(Vehicle vehicle, Entity entity);
	void DETACH_CONTAINER_FROM_HANDLER_FRAME(Vehicle vehicle);
	void SET_VEHICLE_DISABLE_HEIGHT_MAP_AVOIDANCE(Vehicle vehicle, BOOL p1);
	void SET_BOAT_DISABLE_AVOIDANCE(Vehicle vehicle, BOOL p1);
	BOOL IS_HELI_LANDING_AREA_BLOCKED(Vehicle vehicle);
	void SET_SHORT_SLOWDOWN_FOR_LANDING(Vehicle vehicle);
	void SET_HELI_TURBULENCE_SCALAR(Vehicle vehicle, float p1);
	void SET_CAR_BOOT_OPEN(Vehicle vehicle);
	void SET_VEHICLE_TYRE_BURST(Vehicle vehicle, int index, BOOL onRim, float p3);
	void SET_VEHICLE_DOORS_SHUT(Vehicle vehicle, BOOL closeInstantly);
	void SET_VEHICLE_TYRES_CAN_BURST(Vehicle vehicle, BOOL toggle);
	BOOL GET_VEHICLE_TYRES_CAN_BURST(Vehicle vehicle);
	void SET_VEHICLE_WHEELS_CAN_BREAK(Vehicle vehicle, BOOL enabled);
	void SET_VEHICLE_DOOR_OPEN(Vehicle vehicle, int doorId, BOOL loose, BOOL openInstantly);
	void SET_VEHICLE_DOOR_AUTO_LOCK(Vehicle vehicle, int doorId, BOOL toggle);
	void SET_FLEEING_VEHICLES_USE_SWITCHED_OFF_NODES(Any p0);
	void REMOVE_VEHICLE_WINDOW(Vehicle vehicle, int windowIndex);
	void ROLL_DOWN_WINDOWS(Vehicle vehicle);
	void ROLL_DOWN_WINDOW(Vehicle vehicle, int windowIndex);
	void ROLL_UP_WINDOW(Vehicle vehicle, int windowIndex);
	void SMASH_VEHICLE_WINDOW(Vehicle vehicle, int windowIndex);
	void FIX_VEHICLE_WINDOW(Vehicle vehicle, int windowIndex);
	void POP_OUT_VEHICLE_WINDSCREEN(Vehicle vehicle);
	void POP_OFF_VEHICLE_ROOF_WITH_IMPULSE(Vehicle vehicle, float x, float y, float z);
	void SET_VEHICLE_LIGHTS(Vehicle vehicle, int state);
	void SET_VEHICLE_USE_PLAYER_LIGHT_SETTINGS(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_HEADLIGHT_SHADOWS(Vehicle vehicle, int p1);
	void SET_VEHICLE_ALARM(Vehicle vehicle, BOOL state);
	void START_VEHICLE_ALARM(Vehicle vehicle);
	BOOL IS_VEHICLE_ALARM_ACTIVATED(Vehicle vehicle);
	void SET_VEHICLE_INTERIORLIGHT(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_FORCE_INTERIORLIGHT(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_LIGHT_MULTIPLIER(Vehicle vehicle, float multiplier);
	void ATTACH_VEHICLE_TO_TRAILER(Vehicle vehicle, Vehicle trailer, float radius);
	void ATTACH_VEHICLE_ON_TO_TRAILER(Vehicle vehicle, Vehicle trailer, float offsetX, float offsetY, float offsetZ, float coordsX, float coordsY, float coordsZ, float rotationX, float rotationY, float rotationZ, float disableCollisions);
	void STABILISE_ENTITY_ATTACHED_TO_HELI(Vehicle vehicle, Entity entity, float p2);
	void DETACH_VEHICLE_FROM_TRAILER(Vehicle vehicle);
	BOOL IS_VEHICLE_ATTACHED_TO_TRAILER(Vehicle vehicle);
	void SET_TRAILER_INVERSE_MASS_SCALE(Vehicle vehicle, float p1);
	void SET_TRAILER_LEGS_RAISED(Vehicle vehicle);
	void SET_TRAILER_LEGS_LOWERED(Vehicle vehicle);
	void SET_VEHICLE_TYRE_FIXED(Vehicle vehicle, int tyreIndex);
	void SET_VEHICLE_NUMBER_PLATE_TEXT(Vehicle vehicle, const char* plateText);
	const char* GET_VEHICLE_NUMBER_PLATE_TEXT(Vehicle vehicle);
	int GET_NUMBER_OF_VEHICLE_NUMBER_PLATES();
	void SET_VEHICLE_NUMBER_PLATE_TEXT_INDEX(Vehicle vehicle, int plateIndex);
	int GET_VEHICLE_NUMBER_PLATE_TEXT_INDEX(Vehicle vehicle);
	void SET_RANDOM_TRAINS(BOOL toggle);
	Vehicle CREATE_MISSION_TRAIN(int variation, float x, float y, float z, BOOL direction, Any p5, Any p6);
	void SWITCH_TRAIN_TRACK(int trackId, BOOL state);
	void SET_TRAIN_TRACK_SPAWN_FREQUENCY(int trackIndex, int frequency);
	void ALLOW_TRAIN_TO_BE_REMOVED_BY_POPULATION(Any p0);
	void DELETE_ALL_TRAINS();
	void SET_TRAIN_SPEED(Vehicle train, float speed);
	void SET_TRAIN_CRUISE_SPEED(Vehicle train, float speed);
	void SET_RANDOM_BOATS(BOOL toggle);
	void SET_RANDOM_BOATS_MP(BOOL toggle);
	void SET_GARBAGE_TRUCKS(BOOL toggle);
	BOOL DOES_VEHICLE_HAVE_STUCK_VEHICLE_CHECK(Vehicle vehicle);
	int GET_VEHICLE_RECORDING_ID(int recording, const char* script);
	void REQUEST_VEHICLE_RECORDING(int recording, const char* script);
	BOOL HAS_VEHICLE_RECORDING_BEEN_LOADED(int recording, const char* script);
	void REMOVE_VEHICLE_RECORDING(int recording, const char* script);
	Vector3 GET_POSITION_OF_VEHICLE_RECORDING_ID_AT_TIME(int id, float time);
	Vector3 GET_POSITION_OF_VEHICLE_RECORDING_AT_TIME(int recording, float time, const char* script);
	Vector3 GET_ROTATION_OF_VEHICLE_RECORDING_ID_AT_TIME(int id, float time);
	Vector3 GET_ROTATION_OF_VEHICLE_RECORDING_AT_TIME(int recording, float time, const char* script);
	float GET_TOTAL_DURATION_OF_VEHICLE_RECORDING_ID(int id);
	float GET_TOTAL_DURATION_OF_VEHICLE_RECORDING(int recording, const char* script);
	float GET_POSITION_IN_RECORDING(Vehicle vehicle);
	float GET_TIME_POSITION_IN_RECORDING(Vehicle vehicle);
	void START_PLAYBACK_RECORDED_VEHICLE(Vehicle vehicle, int recording, const char* script, BOOL p3);
	void START_PLAYBACK_RECORDED_VEHICLE_WITH_FLAGS(Vehicle vehicle, int recording, const char* script, int flags, int time, int drivingStyle);
	void FORCE_PLAYBACK_RECORDED_VEHICLE_UPDATE(Vehicle vehicle, BOOL p1);
	void STOP_PLAYBACK_RECORDED_VEHICLE(Vehicle vehicle);
	void PAUSE_PLAYBACK_RECORDED_VEHICLE(Vehicle vehicle);
	void UNPAUSE_PLAYBACK_RECORDED_VEHICLE(Vehicle vehicle);
	BOOL IS_PLAYBACK_GOING_ON_FOR_VEHICLE(Vehicle vehicle);
	BOOL IS_PLAYBACK_USING_AI_GOING_ON_FOR_VEHICLE(Vehicle vehicle);
	int GET_CURRENT_PLAYBACK_FOR_VEHICLE(Vehicle vehicle);
	void SKIP_TO_END_AND_STOP_PLAYBACK_RECORDED_VEHICLE(Vehicle vehicle);
	void SET_PLAYBACK_SPEED(Vehicle vehicle, float speed);
	void START_PLAYBACK_RECORDED_VEHICLE_USING_AI(Vehicle vehicle, int recording, const char* script, float speed, int drivingStyle);
	void SKIP_TIME_IN_PLAYBACK_RECORDED_VEHICLE(Vehicle vehicle, float time);
	void SET_PLAYBACK_TO_USE_AI(Vehicle vehicle, int drivingStyle);
	void SET_PLAYBACK_TO_USE_AI_TRY_TO_REVERT_BACK_LATER(Vehicle vehicle, int time, int drivingStyle, BOOL p3);
	void SET_ADDITIONAL_ROTATION_FOR_RECORDED_VEHICLE_PLAYBACK(Vehicle vehicle, float x, float y, float z, Any p4);
	void SET_POSITION_OFFSET_FOR_RECORDED_VEHICLE_PLAYBACK(Vehicle vehicle, float x, float y, float z);
	void SET_GLOBAL_POSITION_OFFSET_FOR_RECORDED_VEHICLE_PLAYBACK(Vehicle vehicle, float x, float y, float z);
	void SET_SHOULD_LERP_FROM_AI_TO_FULL_RECORDING(Vehicle vehicle, BOOL p1);
	void EXPLODE_VEHICLE_IN_CUTSCENE(Vehicle vehicle, BOOL p1);
	void ADD_VEHICLE_STUCK_CHECK_WITH_WARP(Any p0, float p1, Any p2, BOOL p3, BOOL p4, BOOL p5, Any p6);
	void SET_VEHICLE_MODEL_IS_SUPPRESSED(Hash model, BOOL suppressed);
	Vehicle GET_RANDOM_VEHICLE_IN_SPHERE(float x, float y, float z, float radius, Hash modelHash, int flags);
	Vehicle GET_RANDOM_VEHICLE_FRONT_BUMPER_IN_SPHERE(float p0, float p1, float p2, float p3, int p4, int p5, int p6);
	Vehicle GET_RANDOM_VEHICLE_BACK_BUMPER_IN_SPHERE(float p0, float p1, float p2, float p3, int p4, int p5, int p6);
	Vehicle GET_CLOSEST_VEHICLE(float x, float y, float z, float radius, Hash modelHash, int flags);
	Vehicle GET_TRAIN_CARRIAGE(Vehicle train, int trailerNumber);
	BOOL IS_MISSION_TRAIN(Vehicle train);
	void DELETE_MISSION_TRAIN(Vehicle* train);
	void SET_MISSION_TRAIN_AS_NO_LONGER_NEEDED(Vehicle* train, BOOL p1);
	void SET_MISSION_TRAIN_COORDS(Vehicle train, float x, float y, float z);
	BOOL IS_THIS_MODEL_A_BOAT(Hash model);
	BOOL IS_THIS_MODEL_A_JETSKI(Hash model);
	BOOL IS_THIS_MODEL_A_PLANE(Hash model);
	BOOL IS_THIS_MODEL_A_HELI(Hash model);
	BOOL IS_THIS_MODEL_A_CAR(Hash model);
	BOOL IS_THIS_MODEL_A_TRAIN(Hash model);
	BOOL IS_THIS_MODEL_A_BIKE(Hash model);
	BOOL IS_THIS_MODEL_A_BICYCLE(Hash model);
	BOOL IS_THIS_MODEL_A_QUADBIKE(Hash model);
	BOOL IS_THIS_MODEL_AN_AMPHIBIOUS_CAR(Hash model);
	BOOL IS_THIS_MODEL_AN_AMPHIBIOUS_QUADBIKE(Hash model);
	void SET_HELI_BLADES_FULL_SPEED(Vehicle vehicle);
	void SET_HELI_BLADES_SPEED(Vehicle vehicle, float speed);
	void FORCE_SUB_THROTTLE_FOR_TIME(Vehicle vehicle, float p1, float p2);
	void SET_VEHICLE_CAN_BE_TARGETTED(Vehicle vehicle, BOOL state);
	void SET_DONT_ALLOW_PLAYER_TO_ENTER_VEHICLE_IF_LOCKED_FOR_PLAYER(Vehicle vehicle, BOOL p1);
	void SET_VEHICLE_CAN_BE_VISIBLY_DAMAGED(Vehicle vehicle, BOOL state);
	void SET_VEHICLE_HAS_UNBREAKABLE_LIGHTS(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_RESPECTS_LOCKS_WHEN_HAS_DRIVER(Vehicle vehicle, BOOL p1);
	void SET_VEHICLE_CAN_EJECT_PASSENGERS_IF_LOCKED(Any p0, Any p1);
	float GET_VEHICLE_DIRT_LEVEL(Vehicle vehicle);
	void SET_VEHICLE_DIRT_LEVEL(Vehicle vehicle, float dirtLevel);
	BOOL GET_DOES_VEHICLE_HAVE_DAMAGE_DECALS(Vehicle vehicle);
	BOOL IS_VEHICLE_DOOR_FULLY_OPEN(Vehicle vehicle, int doorId);
	void SET_VEHICLE_ENGINE_ON(Vehicle vehicle, BOOL value, BOOL instantly, BOOL disableAutoStart);
	void SET_VEHICLE_UNDRIVEABLE(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_PROVIDES_COVER(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_DOOR_CONTROL(Vehicle vehicle, int doorId, int speed, float angle);
	void SET_VEHICLE_DOOR_LATCHED(Vehicle vehicle, int doorId, BOOL p2, BOOL p3, BOOL p4);
	float GET_VEHICLE_DOOR_ANGLE_RATIO(Vehicle vehicle, int doorId);
	Ped GET_PED_USING_VEHICLE_DOOR(Vehicle vehicle, int doord);
	void SET_VEHICLE_DOOR_SHUT(Vehicle vehicle, int doorId, BOOL closeInstantly);
	void SET_VEHICLE_DOOR_BROKEN(Vehicle vehicle, int doorId, BOOL deleteDoor);
	void SET_VEHICLE_CAN_BREAK(Vehicle vehicle, BOOL toggle);
	BOOL DOES_VEHICLE_HAVE_ROOF(Vehicle vehicle);
	void SET_VEHICLE_REMOVE_AGGRESSIVE_CARJACK_MISSION(Any p0);
	void SET_VEHICLE_AVOID_PLAYER_VEHICLE_RIOT_VAN_MISSION(Any p0);
	void SET_CARJACK_MISSION_REMOVAL_PARAMETERS(Any p0, Any p1);
	BOOL IS_BIG_VEHICLE(Vehicle vehicle);
	int GET_NUMBER_OF_VEHICLE_COLOURS(Vehicle vehicle);
	void SET_VEHICLE_COLOUR_COMBINATION(Vehicle vehicle, int colorCombination);
	int GET_VEHICLE_COLOUR_COMBINATION(Vehicle vehicle);
	void SET_VEHICLE_XENON_LIGHT_COLOR_INDEX(Vehicle vehicle, int colorIndex);
	int GET_VEHICLE_XENON_LIGHT_COLOR_INDEX(Vehicle vehicle);
	void SET_VEHICLE_IS_CONSIDERED_BY_PLAYER(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_WILL_FORCE_OTHER_VEHICLES_TO_STOP(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_ACT_AS_IF_HAS_SIREN_ON(Vehicle vehicle, BOOL p1);
	void SET_VEHICLE_USE_MORE_RESTRICTIVE_SPAWN_CHECKS(Vehicle vehicle, BOOL p1);
	void SET_VEHICLE_MAY_BE_USED_BY_GOTO_POINT_ANY_MEANS(Vehicle vehicle, BOOL p1);
	void GET_RANDOM_VEHICLE_MODEL_IN_MEMORY(BOOL p0, Hash* modelHash, int* successIndicator);
	int GET_VEHICLE_DOOR_LOCK_STATUS(Vehicle vehicle);
	int GET_VEHICLE_INDIVIDUAL_DOOR_LOCK_STATUS(Vehicle vehicle, int doorId);
	BOOL IS_VEHICLE_DOOR_DAMAGED(Vehicle veh, int doorID);
	void SET_DOOR_ALLOWED_TO_BE_BROKEN_OFF(Vehicle vehicle, int doorId, BOOL isBreakable);
	BOOL IS_VEHICLE_BUMPER_BOUNCING(Vehicle vehicle, BOOL frontBumper);
	BOOL IS_VEHICLE_BUMPER_BROKEN_OFF(Vehicle vehicle, BOOL frontBumper);
	BOOL IS_COP_VEHICLE_IN_AREA_3D(float x1, float x2, float y1, float y2, float z1, float z2);
	BOOL IS_VEHICLE_ON_ALL_WHEELS(Vehicle vehicle);
	int GET_VEHICLE_MODEL_VALUE(Hash vehicleModel);
	Hash GET_VEHICLE_LAYOUT_HASH(Vehicle vehicle);
	Hash GET_IN_VEHICLE_CLIPSET_HASH_FOR_SEAT(Vehicle vehicle, int p1);
	void SET_RENDER_TRAIN_AS_DERAILED(Vehicle train, BOOL toggle);
	void SET_VEHICLE_EXTRA_COLOURS(Vehicle vehicle, int pearlescentColor, int wheelColor);
	void GET_VEHICLE_EXTRA_COLOURS(Vehicle vehicle, int* pearlescentColor, int* wheelColor);
	void SET_VEHICLE_EXTRA_COLOUR_5(Vehicle vehicle, int color);
	void GET_VEHICLE_EXTRA_COLOUR_5(Vehicle vehicle, int* color);
	void SET_VEHICLE_EXTRA_COLOUR_6(Vehicle vehicle, int color);
	void GET_VEHICLE_EXTRA_COLOUR_6(Vehicle vehicle, int* color);
	void STOP_ALL_GARAGE_ACTIVITY();
	void SET_VEHICLE_FIXED(Vehicle vehicle);
	void SET_VEHICLE_DEFORMATION_FIXED(Vehicle vehicle);
	void SET_VEHICLE_CAN_ENGINE_MISSFIRE(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_CAN_LEAK_OIL(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_CAN_LEAK_PETROL(Vehicle vehicle, BOOL toggle);
	void SET_DISABLE_VEHICLE_PETROL_TANK_FIRES(Vehicle vehicle, BOOL toggle);
	void SET_DISABLE_VEHICLE_PETROL_TANK_DAMAGE(Vehicle vehicle, BOOL toggle);
	void SET_DISABLE_VEHICLE_ENGINE_FIRES(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_LIMIT_SPEED_WHEN_PLAYER_INACTIVE(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_STOP_INSTANTLY_WHEN_PLAYER_INACTIVE(Vehicle vehicle, BOOL toggle);
	void SET_DISABLE_PRETEND_OCCUPANTS(Vehicle vehicle, BOOL toggle);
	void REMOVE_VEHICLES_FROM_GENERATORS_IN_AREA(float x1, float y1, float z1, float x2, float y2, float z2, Any p6);
	void SET_VEHICLE_STEER_BIAS(Vehicle vehicle, float value);
	BOOL IS_VEHICLE_EXTRA_TURNED_ON(Vehicle vehicle, int extraId);
	void SET_VEHICLE_EXTRA(Vehicle vehicle, int extraId, BOOL disable);
	BOOL DOES_EXTRA_EXIST(Vehicle vehicle, int extraId);
	BOOL IS_EXTRA_BROKEN_OFF(Vehicle vehicle, int extraId);
	void SET_CONVERTIBLE_ROOF(Vehicle vehicle, BOOL p1);
	void LOWER_CONVERTIBLE_ROOF(Vehicle vehicle, BOOL instantlyLower);
	void RAISE_CONVERTIBLE_ROOF(Vehicle vehicle, BOOL instantlyRaise);
	int GET_CONVERTIBLE_ROOF_STATE(Vehicle vehicle);
	BOOL IS_VEHICLE_A_CONVERTIBLE(Vehicle vehicle, BOOL p1);
	BOOL TRANSFORM_TO_SUBMARINE(Vehicle vehicle, BOOL noAnimation);
	void TRANSFORM_TO_CAR(Vehicle vehicle, BOOL noAnimation);
	BOOL IS_VEHICLE_IN_SUBMARINE_MODE(Vehicle vehicle);
	BOOL IS_VEHICLE_STOPPED_AT_TRAFFIC_LIGHTS(Vehicle vehicle);
	void SET_VEHICLE_DAMAGE(Vehicle vehicle, float xOffset, float yOffset, float zOffset, float damage, float radius, BOOL focusOnModel);
	void SET_VEHICLE_OCCUPANTS_TAKE_EXPLOSIVE_DAMAGE(Vehicle vehicle, BOOL toggle);
	float GET_VEHICLE_ENGINE_HEALTH(Vehicle vehicle);
	void SET_VEHICLE_ENGINE_HEALTH(Vehicle vehicle, float health);
	void SET_PLANE_ENGINE_HEALTH(Vehicle vehicle, float health);
	float GET_VEHICLE_PETROL_TANK_HEALTH(Vehicle vehicle);
	void SET_VEHICLE_PETROL_TANK_HEALTH(Vehicle vehicle, float health);
	BOOL IS_VEHICLE_STUCK_TIMER_UP(Vehicle vehicle, int p1, int ms);
	void RESET_VEHICLE_STUCK_TIMER(Vehicle vehicle, int nullAttributes);
	BOOL IS_VEHICLE_DRIVEABLE(Vehicle vehicle, BOOL isOnFireCheck);
	void SET_VEHICLE_HAS_BEEN_OWNED_BY_PLAYER(Vehicle vehicle, BOOL owned);
	void SET_VEHICLE_NEEDS_TO_BE_HOTWIRED(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_BLIP_THROTTLE_RANDOMLY(Vehicle vehicle, BOOL p1);
	void SET_POLICE_FOCUS_WILL_TRACK_VEHICLE(Vehicle vehicle, BOOL toggle);
	void START_VEHICLE_HORN(Vehicle vehicle, int duration, Hash mode, BOOL forever);
	void SET_VEHICLE_IN_CAR_MOD_SHOP(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_HAS_STRONG_AXLES(Vehicle vehicle, BOOL toggle);
	const char* GET_DISPLAY_NAME_FROM_VEHICLE_MODEL(Hash modelHash);
	const char* GET_MAKE_NAME_FROM_VEHICLE_MODEL(Hash modelHash);
	Vector3 GET_VEHICLE_DEFORMATION_AT_POS(Vehicle vehicle, float offsetX, float offsetY, float offsetZ);
	void SET_VEHICLE_LIVERY(Vehicle vehicle, int livery);
	int GET_VEHICLE_LIVERY(Vehicle vehicle);
	int GET_VEHICLE_LIVERY_COUNT(Vehicle vehicle);
	void SET_VEHICLE_LIVERY2(Vehicle vehicle, int livery);
	int GET_VEHICLE_LIVERY2(Vehicle vehicle);
	int GET_VEHICLE_LIVERY2_COUNT(Vehicle vehicle);
	BOOL IS_VEHICLE_WINDOW_INTACT(Vehicle vehicle, int windowIndex);
	BOOL ARE_ALL_VEHICLE_WINDOWS_INTACT(Vehicle vehicle);
	BOOL ARE_ANY_VEHICLE_SEATS_FREE(Vehicle vehicle);
	void RESET_VEHICLE_WHEELS(Vehicle vehicle, BOOL toggle);
	BOOL IS_HELI_PART_BROKEN(Vehicle vehicle, BOOL p1, BOOL p2, BOOL p3);
	float GET_HELI_MAIN_ROTOR_HEALTH(Vehicle vehicle);
	float GET_HELI_TAIL_ROTOR_HEALTH(Vehicle vehicle);
	float GET_HELI_TAIL_BOOM_HEALTH(Vehicle vehicle);
	void SET_HELI_MAIN_ROTOR_HEALTH(Vehicle vehicle, float health);
	void SET_HELI_TAIL_ROTOR_HEALTH(Vehicle vehicle, float health);
	BOOL SET_HELI_TAIL_BOOM_CAN_BREAK_OFF(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_NAME_DEBUG(Vehicle vehicle, const char* name);
	void SET_VEHICLE_EXPLODES_ON_HIGH_EXPLOSION_DAMAGE(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_EXPLODES_ON_EXPLOSION_DAMAGE_AT_ZERO_BODY_HEALTH(Vehicle vehicle, BOOL toggle);
	void SET_ALLOW_VEHICLE_EXPLODES_ON_CONTACT(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_DISABLE_TOWING(Vehicle vehicle, BOOL toggle);
	BOOL GET_VEHICLE_HAS_LANDING_GEAR(Vehicle vehicle);
	void CONTROL_LANDING_GEAR(Vehicle vehicle, int state);
	int GET_LANDING_GEAR_STATE(Vehicle vehicle);
	BOOL IS_ANY_VEHICLE_NEAR_POINT(float x, float y, float z, float radius);
	void REQUEST_VEHICLE_HIGH_DETAIL_MODEL(Vehicle vehicle);
	void REMOVE_VEHICLE_HIGH_DETAIL_MODEL(Vehicle vehicle);
	BOOL IS_VEHICLE_HIGH_DETAIL(Vehicle vehicle);
	void REQUEST_VEHICLE_ASSET(Hash vehicleHash, int vehicleAsset);
	BOOL HAS_VEHICLE_ASSET_LOADED(int vehicleAsset);
	void REMOVE_VEHICLE_ASSET(int vehicleAsset);
	void SET_VEHICLE_TOW_TRUCK_ARM_POSITION(Vehicle vehicle, float position);
	void ATTACH_VEHICLE_TO_TOW_TRUCK(Vehicle towTruck, Vehicle vehicle, BOOL rear, float hookOffsetX, float hookOffsetY, float hookOffsetZ);
	void DETACH_VEHICLE_FROM_TOW_TRUCK(Vehicle towTruck, Vehicle vehicle);
	BOOL DETACH_VEHICLE_FROM_ANY_TOW_TRUCK(Vehicle vehicle);
	BOOL IS_VEHICLE_ATTACHED_TO_TOW_TRUCK(Vehicle towTruck, Vehicle vehicle);
	Entity GET_ENTITY_ATTACHED_TO_TOW_TRUCK(Vehicle towTruck);
	Entity SET_VEHICLE_AUTOMATICALLY_ATTACHES(Vehicle vehicle, BOOL p1, Any p2);
	void SET_VEHICLE_BULLDOZER_ARM_POSITION(Vehicle vehicle, float position, BOOL p2);
	void SET_VEHICLE_TANK_TURRET_POSITION(Vehicle vehicle, float position, BOOL p2);
	void SET_VEHICLE_TURRET_TARGET(Vehicle vehicle, BOOL p1, float x, float y, float z, BOOL p5);
	void SET_VEHICLE_TANK_STATIONARY(Vehicle vehicle, BOOL p1);
	void SET_VEHICLE_TURRET_SPEED_THIS_FRAME(Vehicle vehicle, float speed);
	void DISABLE_VEHICLE_TURRET_MOVEMENT_THIS_FRAME(Vehicle vehicle);
	void SET_VEHICLE_FLIGHT_NOZZLE_POSITION(Vehicle vehicle, float angleRatio);
	void SET_VEHICLE_FLIGHT_NOZZLE_POSITION_IMMEDIATE(Vehicle vehicle, float angle);
	float GET_VEHICLE_FLIGHT_NOZZLE_POSITION(Vehicle plane);
	void SET_DISABLE_VERTICAL_FLIGHT_MODE_TRANSITION(Vehicle vehicle, BOOL toggle);
	BOOL GENERATE_VEHICLE_CREATION_POS_FROM_PATHS(Vector3* outVec, Any p1, Vector3* outVec1, Any p3, Any p4, Any p5, Any p6, Any p7, Any p8);
	void SET_VEHICLE_BURNOUT(Vehicle vehicle, BOOL toggle);
	BOOL IS_VEHICLE_IN_BURNOUT(Vehicle vehicle);
	void SET_VEHICLE_REDUCE_GRIP(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_REDUCE_GRIP_LEVEL(Vehicle vehicle, int val);
	void SET_VEHICLE_INDICATOR_LIGHTS(Vehicle vehicle, int turnSignal, BOOL toggle);
	void SET_VEHICLE_BRAKE_LIGHTS(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_TAIL_LIGHTS(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_HANDBRAKE(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_BRAKE(Vehicle vehicle, BOOL toggle);
	void INSTANTLY_FILL_VEHICLE_POPULATION();
	BOOL HAS_INSTANT_FILL_VEHICLE_POPULATION_FINISHED();
	void NETWORK_ENABLE_EMPTY_CROWDING_VEHICLES_REMOVAL(BOOL toggle);
	void NETWORK_CAP_EMPTY_CROWDING_VEHICLES_REMOVAL(int p0);
	BOOL GET_VEHICLE_TRAILER_VEHICLE(Vehicle vehicle, Vehicle* trailer);
	Vehicle GET_VEHICLE_TRAILER_PARENT_VEHICLE_(Vehicle trailer);
	void SET_VEHICLE_USES_LARGE_REAR_RAMP(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_RUDDER_BROKEN(Vehicle vehicle, BOOL toggle);
	void SET_CONVERTIBLE_ROOF_LATCH_STATE(Vehicle vehicle, BOOL state);
	float GET_VEHICLE_ESTIMATED_MAX_SPEED(Vehicle vehicle);
	float GET_VEHICLE_MAX_BRAKING(Vehicle vehicle);
	float GET_VEHICLE_MAX_TRACTION(Vehicle vehicle);
	float GET_VEHICLE_ACCELERATION(Vehicle vehicle);
	float GET_VEHICLE_MODEL_ESTIMATED_MAX_SPEED(Hash modelHash);
	float GET_VEHICLE_MODEL_MAX_BRAKING(Hash modelHash);
	float GET_VEHICLE_MODEL_MAX_BRAKING_MAX_MODS(Hash modelHash);
	float GET_VEHICLE_MODEL_MAX_TRACTION(Hash modelHash);
	float GET_VEHICLE_MODEL_ACCELERATION(Hash modelHash);
	float GET_VEHICLE_MODEL_ACCELERATION_MAX_MODS(Hash modelHash);
	float GET_FLYING_VEHICLE_MODEL_AGILITY(Hash modelHash);
	float GET_BOAT_VEHICLE_MODEL_AGILITY(Hash modelHash);
	float GET_VEHICLE_CLASS_ESTIMATED_MAX_SPEED(int vehicleClass);
	float GET_VEHICLE_CLASS_MAX_TRACTION(int vehicleClass);
	float GET_VEHICLE_CLASS_MAX_AGILITY(int vehicleClass);
	float GET_VEHICLE_CLASS_MAX_ACCELERATION(int vehicleClass);
	float GET_VEHICLE_CLASS_MAX_BRAKING(int vehicleClass);
	int ADD_ROAD_NODE_SPEED_ZONE(float x, float y, float z, float radius, float speed, BOOL p5);
	BOOL REMOVE_ROAD_NODE_SPEED_ZONE(int speedzone);
	void OPEN_BOMB_BAY_DOORS(Vehicle vehicle);
	void CLOSE_BOMB_BAY_DOORS(Vehicle vehicle);
	BOOL GET_ARE_BOMB_BAY_DOORS_OPEN(Vehicle aircraft);
	BOOL IS_VEHICLE_SEARCHLIGHT_ON(Vehicle vehicle);
	void SET_VEHICLE_SEARCHLIGHT(Vehicle heli, BOOL toggle, BOOL canBeUsedByAI);
	BOOL DOES_VEHICLE_HAVE_SEARCHLIGHT(Vehicle vehicle);
	BOOL IS_ENTRY_POINT_FOR_SEAT_CLEAR(Ped ped, Vehicle vehicle, int seatIndex, BOOL side, BOOL onEnter);
	Vector3 GET_ENTRY_POINT_POSITION(Vehicle vehicle, int doorId);
	BOOL CAN_SHUFFLE_SEAT(Vehicle vehicle, int seatIndex);
	int GET_NUM_MOD_KITS(Vehicle vehicle);
	void SET_VEHICLE_MOD_KIT(Vehicle vehicle, int modKit);
	int GET_VEHICLE_MOD_KIT(Vehicle vehicle);
	int GET_VEHICLE_MOD_KIT_TYPE(Vehicle vehicle);
	int GET_VEHICLE_WHEEL_TYPE(Vehicle vehicle);
	void SET_VEHICLE_WHEEL_TYPE(Vehicle vehicle, int WheelType);
	int GET_NUM_MOD_COLORS(int paintType, BOOL p1);
	void SET_VEHICLE_MOD_COLOR_1(Vehicle vehicle, int paintType, int color, int pearlescentColor);
	void SET_VEHICLE_MOD_COLOR_2(Vehicle vehicle, int paintType, int color);
	void GET_VEHICLE_MOD_COLOR_1(Vehicle vehicle, int* paintType, int* color, int* pearlescentColor);
	void GET_VEHICLE_MOD_COLOR_2(Vehicle vehicle, int* paintType, int* color);
	const char* GET_VEHICLE_MOD_COLOR_1_NAME(Vehicle vehicle, BOOL p1);
	const char* GET_VEHICLE_MOD_COLOR_2_NAME(Vehicle vehicle);
	BOOL HAVE_VEHICLE_MODS_STREAMED_IN(Vehicle vehicle);
	BOOL IS_VEHICLE_MOD_GEN9_EXCLUSIVE(Vehicle vehicle, int modType, int modIndex);
	void SET_VEHICLE_MOD(Vehicle vehicle, int modType, int modIndex, BOOL customTires);
	int GET_VEHICLE_MOD(Vehicle vehicle, int modType);
	int GET_VEHICLE_MOD_VARIATION(Vehicle vehicle, int modType);
	int GET_NUM_VEHICLE_MODS(Vehicle vehicle, int modType);
	void REMOVE_VEHICLE_MOD(Vehicle vehicle, int modType);
	void TOGGLE_VEHICLE_MOD(Vehicle vehicle, int modType, BOOL toggle);
	BOOL IS_TOGGLE_MOD_ON(Vehicle vehicle, int modType);
	const char* GET_MOD_TEXT_LABEL(Vehicle vehicle, int modType, int modValue);
	const char* GET_MOD_SLOT_NAME(Vehicle vehicle, int modType);
	const char* GET_LIVERY_NAME(Vehicle vehicle, int liveryIndex);
	int GET_VEHICLE_MOD_MODIFIER_VALUE(Vehicle vehicle, int modType, int modIndex);
	Hash GET_VEHICLE_MOD_IDENTIFIER_HASH(Vehicle vehicle, int modType, int modIndex);
	void PRELOAD_VEHICLE_MOD(Vehicle vehicle, int modType, int modIndex);
	BOOL HAS_PRELOAD_MODS_FINISHED(Vehicle vehicle);
	void RELEASE_PRELOAD_MODS(Vehicle vehicle);
	void SET_VEHICLE_TYRE_SMOKE_COLOR(Vehicle vehicle, int r, int g, int b);
	void GET_VEHICLE_TYRE_SMOKE_COLOR(Vehicle vehicle, int* r, int* g, int* b);
	void SET_VEHICLE_WINDOW_TINT(Vehicle vehicle, int tint);
	int GET_VEHICLE_WINDOW_TINT(Vehicle vehicle);
	int GET_NUM_VEHICLE_WINDOW_TINTS();
	void GET_VEHICLE_COLOR(Vehicle vehicle, int* r, int* g, int* b);
	int GET_VEHICLE_COLOURS_WHICH_CAN_BE_SET(Vehicle vehicle);
	Hash GET_VEHICLE_CAUSE_OF_DESTRUCTION(Vehicle vehicle);
	void OVERRIDE_PLANE_DAMAGE_THREHSOLD(Vehicle vehicle, float health);
	BOOL GET_IS_LEFT_VEHICLE_HEADLIGHT_DAMAGED(Vehicle vehicle);
	BOOL GET_IS_RIGHT_VEHICLE_HEADLIGHT_DAMAGED(Vehicle vehicle);
	BOOL GET_BOTH_VEHICLE_HEADLIGHTS_DAMAGED(Vehicle vehicle);
	void MODIFY_VEHICLE_TOP_SPEED(Vehicle vehicle, float value);
	void SET_VEHICLE_MAX_SPEED(Vehicle vehicle, float speed);
	void SET_VEHICLE_STAYS_FROZEN_WHEN_CLEANED_UP(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_ACT_AS_IF_HIGH_SPEED_FOR_FRAG_SMASHING(Vehicle vehicle, BOOL p1);
	void SET_PEDS_CAN_FALL_OFF_THIS_VEHICLE_FROM_LARGE_FALL_DAMAGE(Vehicle vehicle, BOOL toggle, float p2);
	int ADD_VEHICLE_COMBAT_ANGLED_AVOIDANCE_AREA(float p0, float p1, float p2, float p3, float p4, float p5, float p6);
	void REMOVE_VEHICLE_COMBAT_AVOIDANCE_AREA(int p0);
	BOOL IS_ANY_PED_RAPPELLING_FROM_HELI(Vehicle vehicle);
	void SET_VEHICLE_CHEAT_POWER_INCREASE(Vehicle vehicle, float value);
	void SET_VEHICLE_INFLUENCES_WANTED_LEVEL(Any p0, BOOL p1);
	void SET_VEHICLE_IS_WANTED(Vehicle vehicle, BOOL state);
	void SWING_BOAT_BOOM_TO_RATIO(Vehicle vehicle, float ratio);
	void SWING_BOAT_BOOM_FREELY(Vehicle vehicle, BOOL toggle);
	void ALLOW_BOAT_BOOM_TO_ANIMATE(Vehicle vehicle, BOOL toggle);
	float GET_BOAT_BOOM_POSITION_RATIO(Vehicle vehicle);
	void DISABLE_PLANE_AILERON(Vehicle vehicle, BOOL p1, BOOL p2);
	BOOL GET_IS_VEHICLE_ENGINE_RUNNING(Vehicle vehicle);
	void SET_VEHICLE_USE_ALTERNATE_HANDLING(Vehicle vehicle, BOOL toggle);
	void SET_BIKE_ON_STAND(Vehicle vehicle, float x, float y);
	void SET_VEHICLE_NOT_STEALABLE_AMBIENTLY(Vehicle vehicle, BOOL p1);
	void LOCK_DOORS_WHEN_NO_LONGER_NEEDED(Vehicle vehicle);
	void SET_LAST_DRIVEN_VEHICLE(Vehicle vehicle);
	Vehicle GET_LAST_DRIVEN_VEHICLE();
	void CLEAR_LAST_DRIVEN_VEHICLE();
	void SET_VEHICLE_HAS_BEEN_DRIVEN_FLAG(Vehicle vehicle, BOOL toggle);
	void SET_TASK_VEHICLE_GOTO_PLANE_MIN_HEIGHT_ABOVE_TERRAIN(Vehicle plane, int height);
	void SET_VEHICLE_LOD_MULTIPLIER(Vehicle vehicle, float multiplier);
	void SET_VEHICLE_CAN_SAVE_IN_GARAGE(Vehicle vehicle, BOOL toggle);
	int GET_VEHICLE_NUM_OF_BROKEN_OFF_PARTS(Vehicle vehicle);
	int GET_VEHICLE_NUM_OF_BROKEN_LOOSEN_PARTS(Vehicle vehicle);
	void SET_FORCE_VEHICLE_ENGINE_DAMAGE_BY_BULLET(Any p0, BOOL p1);
	void SET_VEHICLE_GENERATES_ENGINE_SHOCKING_EVENTS(Vehicle vehicle, BOOL toggle);
	void COPY_VEHICLE_DAMAGES(Vehicle sourceVehicle, Vehicle targetVehicle);
	void DISABLE_VEHICLE_EXPLOSION_BREAK_OFF_PARTS();
	void SET_LIGHTS_CUTOFF_DISTANCE_TWEAK(float distance);
	void SET_VEHICLE_SHOOT_AT_TARGET(Ped driver, Entity entity, float xTarget, float yTarget, float zTarget);
	BOOL GET_VEHICLE_LOCK_ON_TARGET(Vehicle vehicle, Entity* entity);
	void SET_FORCE_HD_VEHICLE(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_CUSTOM_PATH_NODE_STREAMING_RADIUS(Vehicle vehicle, float p1);
	int GET_VEHICLE_PLATE_TYPE(Vehicle vehicle);
	void TRACK_VEHICLE_VISIBILITY(Vehicle vehicle);
	BOOL IS_VEHICLE_VISIBLE(Vehicle vehicle);
	void SET_VEHICLE_GRAVITY(Vehicle vehicle, BOOL toggle);
	void SET_ENABLE_VEHICLE_SLIPSTREAMING(BOOL toggle);
	void SET_VEHICLE_SLIPSTREAMING_SHOULD_TIME_OUT(BOOL toggle);
	float GET_VEHICLE_CURRENT_TIME_IN_SLIP_STREAM(Vehicle vehicle);
	BOOL IS_VEHICLE_PRODUCING_SLIP_STREAM(Vehicle vehicle);
	void SET_VEHICLE_INACTIVE_DURING_PLAYBACK(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_ACTIVE_DURING_PLAYBACK(Vehicle vehicle, BOOL toggle);
	BOOL IS_VEHICLE_SPRAYABLE(Vehicle vehicle);
	void SET_VEHICLE_ENGINE_CAN_DEGRADE(Vehicle vehicle, BOOL toggle);
	void DISABLE_VEHCILE_DYNAMIC_AMBIENT_SCALES(Vehicle vehicle, int p1, int p2);
	void ENABLE_VEHICLE_DYNAMIC_AMBIENT_SCALES(Vehicle vehicle);
	BOOL IS_PLANE_LANDING_GEAR_INTACT(Vehicle plane);
	BOOL ARE_PLANE_PROPELLERS_INTACT(Vehicle plane);
	BOOL SET_PLANE_PROPELLER_HEALTH(Vehicle plane, float health);
	void SET_VEHICLE_CAN_DEFORM_WHEELS(Vehicle vehicle, BOOL toggle);
	BOOL IS_VEHICLE_STOLEN(Vehicle vehicle);
	void SET_VEHICLE_IS_STOLEN(Vehicle vehicle, BOOL isStolen);
	void SET_PLANE_TURBULENCE_MULTIPLIER(Vehicle vehicle, float multiplier);
	BOOL ARE_WINGS_OF_PLANE_INTACT(Vehicle plane);
	void ALLOW_AMBIENT_VEHICLES_TO_AVOID_ADVERSE_CONDITIONS(Vehicle vehicle);
	void DETACH_VEHICLE_FROM_CARGOBOB(Vehicle vehicle, Vehicle cargobob);
	BOOL DETACH_VEHICLE_FROM_ANY_CARGOBOB(Vehicle vehicle);
	BOOL DETACH_ENTITY_FROM_CARGOBOB(Vehicle cargobob, Entity entity);
	BOOL IS_VEHICLE_ATTACHED_TO_CARGOBOB(Vehicle cargobob, Vehicle vehicleAttached);
	Vehicle GET_VEHICLE_ATTACHED_TO_CARGOBOB(Vehicle cargobob);
	Entity GET_ENTITY_ATTACHED_TO_CARGOBOB(Any p0);
	void ATTACH_VEHICLE_TO_CARGOBOB(Vehicle vehicle, Vehicle cargobob, int p2, float x, float y, float z);
	void ATTACH_ENTITY_TO_CARGOBOB(Any p0, Any p1, Any p2, Any p3, Any p4, Any p5);
	void SET_CARGOBOB_FORCE_DONT_DETACH_VEHICLE(Vehicle cargobob, BOOL toggle);
	void SET_CARGOBOB_EXCLUDE_FROM_PICKUP_ENTITY(Any p0, Any p1);
	BOOL CAN_CARGOBOB_PICK_UP_ENTITY(Any p0, Any p1);
	Vector3 GET_ATTACHED_PICK_UP_HOOK_POSITION(Vehicle cargobob);
	BOOL DOES_CARGOBOB_HAVE_PICK_UP_ROPE(Vehicle cargobob);
	void CREATE_PICK_UP_ROPE_FOR_CARGOBOB(Vehicle cargobob, int state);
	void REMOVE_PICK_UP_ROPE_FOR_CARGOBOB(Vehicle cargobob);
	void SET_PICKUP_ROPE_LENGTH_FOR_CARGOBOB(Vehicle cargobob, float length1, float length2, BOOL p3);
	void SET_PICKUP_ROPE_LENGTH_WITHOUT_CREATING_ROPE_FOR_CARGOBOB(Any p0, Any p1, Any p2);
	void SET_CARGOBOB_PICKUP_ROPE_DAMPING_MULTIPLIER(Any p0, Any p1);
	void SET_CARGOBOB_PICKUP_ROPE_TYPE(Any p0, Any p1);
	BOOL DOES_CARGOBOB_HAVE_PICKUP_MAGNET(Vehicle cargobob);
	void SET_CARGOBOB_PICKUP_MAGNET_ACTIVE(Vehicle cargobob, BOOL isActive);
	void SET_CARGOBOB_PICKUP_MAGNET_STRENGTH(Vehicle cargobob, float strength);
	void SET_CARGOBOB_PICKUP_MAGNET_FALLOFF(Vehicle cargobob, float p1);
	void SET_CARGOBOB_PICKUP_MAGNET_REDUCED_STRENGTH(Vehicle cargobob, float p1);
	void SET_CARGOBOB_PICKUP_MAGNET_REDUCED_FALLOFF(Vehicle cargobob, float p1);
	void SET_CARGOBOB_PICKUP_MAGNET_PULL_STRENGTH(Vehicle cargobob, float p1);
	void SET_CARGOBOB_PICKUP_MAGNET_PULL_ROPE_LENGTH(Vehicle vehicle, float p1);
	void SET_CARGOBOB_PICKUP_MAGNET_SET_TARGETED_MODE(Vehicle vehicle, Vehicle cargobob);
	void SET_CARGOBOB_PICKUP_MAGNET_SET_AMBIENT_MODE(Vehicle vehicle, BOOL p1, BOOL p2);
	void SET_CARGOBOB_PICKUP_MAGNET_ENSURE_PICKUP_ENTITY_UPRIGHT(Vehicle vehicle, BOOL p1);
	BOOL DOES_VEHICLE_HAVE_WEAPONS(Vehicle vehicle);
	void SET_VEHICLE_WILL_TELL_OTHERS_TO_HURRY(Vehicle vehicle, BOOL p1);
	void DISABLE_VEHICLE_WEAPON(BOOL disabled, Hash weaponHash, Vehicle vehicle, Ped owner);
	BOOL IS_VEHICLE_WEAPON_DISABLED(Hash weaponHash, Vehicle vehicle, Ped owner);
	void SET_VEHICLE_USED_FOR_PILOT_SCHOOL(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_ACTIVE_FOR_PED_NAVIGATION(Vehicle vehicle, BOOL toggle);
	int GET_VEHICLE_CLASS(Vehicle vehicle);
	int GET_VEHICLE_CLASS_FROM_NAME(Hash modelHash);
	void SET_PLAYERS_LAST_VEHICLE(Vehicle vehicle);
	void SET_VEHICLE_CAN_BE_USED_BY_FLEEING_PEDS(Vehicle vehicle, BOOL toggle);
	void SET_AIRCRAFT_PILOT_SKILL_NOISE_SCALAR(Vehicle vehicle, float p1);
	void SET_VEHICLE_DROPS_MONEY_WHEN_BLOWN_UP(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_KEEP_ENGINE_ON_WHEN_ABANDONED(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_IMPATIENCE_TIMER(Vehicle vehicle, Any p1);
	void SET_VEHICLE_HANDLING_OVERRIDE(Vehicle vehicle, Hash hash);
	void SET_VEHICLE_EXTENDED_REMOVAL_RANGE(Vehicle vehicle, int range);
	void SET_VEHICLE_STEERING_BIAS_SCALAR(Any p0, float p1);
	void SET_HELI_CONTROL_LAGGING_RATE_SCALAR(Vehicle helicopter, float multiplier);
	void SET_VEHICLE_FRICTION_OVERRIDE(Vehicle vehicle, float friction);
	void SET_VEHICLE_WHEELS_CAN_BREAK_OFF_WHEN_BLOW_UP(Vehicle vehicle, BOOL toggle);
	BOOL ARE_PLANE_CONTROL_PANELS_INTACT(Vehicle vehicle, BOOL p1);
	void SET_VEHICLE_CEILING_HEIGHT(Vehicle vehicle, float height);
	void SET_VEHICLE_NO_EXPLOSION_DAMAGE_FROM_DRIVER(Vehicle vehicle, BOOL toggle);
	void CLEAR_VEHICLE_ROUTE_HISTORY(Vehicle vehicle);
	Vehicle DOES_VEHICLE_EXIST_WITH_DECORATOR(const char* decorator);
	void SET_VEHICLE_AI_CAN_USE_EXCLUSIVE_SEATS(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_EXCLUSIVE_DRIVER(Vehicle vehicle, Ped ped, int index);
	BOOL IS_PED_EXCLUSIVE_DRIVER_OF_VEHICLE(Ped ped, Vehicle vehicle, int* outIndex);
	void DISABLE_INDIVIDUAL_PLANE_PROPELLER(Vehicle vehicle, int propeller);
	void SET_VEHICLE_FORCE_AFTERBURNER(Vehicle vehicle, BOOL toggle);
	void SET_DONT_PROCESS_VEHICLE_GLASS(Vehicle vehicle, BOOL toggle);
	void SET_DISABLE_WANTED_CONES_RESPONSE(Vehicle vehicle, BOOL toggle);
	void SET_USE_DESIRED_Z_CRUISE_SPEED_FOR_LANDING(Vehicle vehicle, BOOL toggle);
	void SET_ARRIVE_DISTANCE_OVERRIDE_FOR_VEHICLE_PERSUIT_ATTACK(Vehicle vehicle, float p1);
	void SET_VEHICLE_READY_FOR_CLEANUP(Any p0);
	void SET_DISTANT_CARS_ENABLED(BOOL toggle);
	void SET_VEHICLE_NEON_COLOUR(Vehicle vehicle, int r, int g, int b);
	void SET_VEHICLE_NEON_INDEX_COLOUR(Vehicle vehicle, int index);
	void GET_VEHICLE_NEON_COLOUR(Vehicle vehicle, int* r, int* g, int* b);
	void SET_VEHICLE_NEON_ENABLED(Vehicle vehicle, int index, BOOL toggle);
	BOOL GET_VEHICLE_NEON_ENABLED(Vehicle vehicle, int index);
	void SET_AMBIENT_VEHICLE_NEON_ENABLED(BOOL p0);
	void SUPPRESS_NEONS_ON_VEHICLE(Vehicle vehicle, BOOL toggle);
	void SET_DISABLE_SUPERDUMMY(Vehicle vehicle, BOOL p1);
	void REQUEST_VEHICLE_DIAL(Vehicle vehicle);
	float GET_VEHICLE_BODY_HEALTH(Vehicle vehicle);
	void SET_VEHICLE_BODY_HEALTH(Vehicle vehicle, float value);
	void GET_VEHICLE_SIZE(Vehicle vehicle, Vector3* out1, Vector3* out2);
	float GET_FAKE_SUSPENSION_LOWERING_AMOUNT(Vehicle vehicle);
	void SET_CAR_HIGH_SPEED_BUMP_SEVERITY_MULTIPLIER(float multiplier);
	int GET_NUMBER_OF_VEHICLE_DOORS(Vehicle vehicle);
	void SET_HYDRAULICS_CONTROL(Vehicle vehicle, BOOL toggle);
	void SET_CAN_ADJUST_GROUND_CLEARANCE(Vehicle vehicle, BOOL p1);
	float GET_VEHICLE_HEALTH_PERCENTAGE(Vehicle vehicle, float maxEngineHealth, float maxPetrolTankHealth, float maxBodyHealth, float maxMainRotorHealth, float maxTailRotorHealth, float maxUnkHealth);
	BOOL GET_VEHICLE_IS_MERCENARY(Vehicle vehicle);
	void SET_VEHICLE_BROKEN_PARTS_DONT_AFFECT_AI_HANDLING(Vehicle vehicle, BOOL p1);
	void SET_VEHICLE_KERS_ALLOWED(Vehicle vehicle, BOOL toggle);
	BOOL GET_VEHICLE_HAS_KERS(Vehicle vehicle);
	void SET_PLANE_RESIST_TO_EXPLOSION(Vehicle vehicle, BOOL toggle);
	void SET_HELI_RESIST_TO_EXPLOSION(Vehicle vehicle, BOOL toggle);
	void SET_DISABLE_BMX_EXTRA_TRICK_FORCES(Any p0);
	void SET_HYDRAULIC_SUSPENSION_RAISE_FACTOR(Vehicle vehicle, int wheelId, float value);
	float GET_HYDRAULIC_SUSPENSION_RAISE_FACTOR(Vehicle vehicle, int wheelId);
	void SET_CAN_USE_HYDRAULICS(Vehicle vehicle, BOOL toggle);
	void SET_HYDRAULIC_VEHICLE_STATE(Vehicle vehicle, int state);
	void SET_HYDRAULIC_WHEEL_STATE(Vehicle vehicle, int wheelId, int state, float value, Any p4);
	BOOL HAS_VEHICLE_PETROLTANK_SET_ON_FIRE_BY_ENTITY(Any p0, Any p1);
	void CLEAR_VEHICLE_PETROLTANK_FIRE_CULPRIT(Vehicle vehicle);
	void SET_VEHICLE_BOBBLEHEAD_VELOCITY(float x, float y, float p2);
	BOOL GET_VEHICLE_IS_DUMMY(Any p0);
	BOOL SET_VEHICLE_DAMAGE_SCALE(Vehicle vehicle, float p1);
	BOOL SET_VEHICLE_WEAPON_DAMAGE_SCALE(Vehicle vehicle, float multiplier);
	BOOL SET_DISABLE_DAMAGE_WITH_PICKED_UP_ENTITY(Any p0, Any p1);
	void SET_VEHICLE_USES_MP_PLAYER_DAMAGE_MULTIPLIER(Any p0, Any p1);
	void SET_BIKE_EASY_TO_LAND(Vehicle vehicle, BOOL toggle);
	void SET_INVERT_VEHICLE_CONTROLS(Vehicle vehicle, BOOL state);
	void SET_SPEED_BOOST_EFFECT_DISABLED(BOOL disabled);
	void SET_SLOW_DOWN_EFFECT_DISABLED(BOOL disabled);
	void SET_FORMATION_LEADER(Vehicle vehicle, float x, float y, float z, float p4);
	void RESET_FORMATION_LEADER();
	BOOL GET_IS_BOAT_CAPSIZED(Vehicle vehicle);
	void SET_ALLOW_RAMMING_SOOP_OR_RAMP(Any p0, Any p1);
	void SET_SCRIPT_RAMP_IMPULSE_SCALE(Vehicle vehicle, float impulseScale);
	BOOL GET_IS_DOOR_VALID(Vehicle vehicle, int doorId);
	void SET_SCRIPT_ROCKET_BOOST_RECHARGE_TIME(Vehicle vehicle, float seconds);
	BOOL GET_HAS_ROCKET_BOOST(Vehicle vehicle);
	BOOL IS_ROCKET_BOOST_ACTIVE(Vehicle vehicle);
	void SET_ROCKET_BOOST_ACTIVE(Vehicle vehicle, BOOL active);
	BOOL GET_HAS_RETRACTABLE_WHEELS(Vehicle vehicle);
	BOOL GET_IS_WHEELS_RETRACTED(Vehicle vehicle);
	void SET_WHEELS_EXTENDED_INSTANTLY(Vehicle vehicle);
	void SET_WHEELS_RETRACTED_INSTANTLY(Vehicle vehicle);
	BOOL GET_CAR_HAS_JUMP(Vehicle vehicle);
	void SET_USE_HIGHER_CAR_JUMP(Vehicle vehicle, BOOL toggle);
	void SET_CLEAR_FREEZE_WAITING_ON_COLLISION_ONCE_PLAYER_ENTERS(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_WEAPON_RESTRICTED_AMMO(Vehicle vehicle, int weaponIndex, int capacity);
	int GET_VEHICLE_WEAPON_RESTRICTED_AMMO(Vehicle vehicle, int weaponIndex);
	BOOL GET_VEHICLE_HAS_PARACHUTE(Vehicle vehicle);
	BOOL GET_VEHICLE_CAN_DEPLOY_PARACHUTE(Vehicle vehicle);
	void VEHICLE_START_PARACHUTING(Vehicle vehicle, BOOL active);
	BOOL IS_VEHICLE_PARACHUTE_DEPLOYED(Vehicle vehicle);
	void VEHICLE_SET_RAMP_AND_RAMMING_CARS_TAKE_DAMAGE(Vehicle vehicle, BOOL toggle);
	void VEHICLE_SET_ENABLE_RAMP_CAR_SIDE_IMPULSE(Any p0, Any p1);
	void VEHICLE_SET_ENABLE_NORMALISE_RAMP_CAR_VERTICAL_VELOCTIY(Any p0, Any p1);
	void VEHICLE_SET_JET_WASH_FORCE_ENABLED(Any p0);
	void SET_VEHICLE_WEAPON_CAN_TARGET_OBJECTS(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_USE_BOOST_BUTTON_FOR_WHEEL_RETRACT(BOOL toggle);
	void VEHICLE_SET_PARACHUTE_MODEL_OVERRIDE(Vehicle vehicle, Hash modelHash);
	void VEHICLE_SET_PARACHUTE_MODEL_TINT_INDEX(Vehicle vehicle, int textureVariation);
	int VEHICLE_SET_OVERRIDE_EXTENABLE_SIDE_RATIO(Any p0, Any p1);
	int VEHICLE_SET_EXTENABLE_SIDE_TARGET_RATIO(Any p0, Any p1);
	int VEHICLE_SET_OVERRIDE_SIDE_RATIO(Any p0, Any p1);
	int GET_ALL_VEHICLES(Any* vehsStruct);
	void SET_CARGOBOB_EXTA_PICKUP_RANGE(Any p0, Any p1);
	void SET_OVERRIDE_VEHICLE_DOOR_TORQUE(Any p0, Any p1, Any p2);
	void SET_WHEELIE_ENABLED(Vehicle vehicle, BOOL enabled);
	void SET_DISABLE_HELI_EXPLODE_FROM_BODY_DAMAGE(Any p0, Any p1);
	void SET_DISABLE_EXPLODE_FROM_BODY_DAMAGE_ON_COLLISION(Vehicle vehicle, float value);
	void SET_TRAILER_ATTACHMENT_ENABLED(Any p0, Any p1);
	void SET_ROCKET_BOOST_FILL(Vehicle vehicle, float percentage);
	void SET_GLIDER_ACTIVE(Vehicle vehicle, BOOL state);
	void SET_SHOULD_RESET_TURRET_IN_SCRIPTED_CAMERAS(Vehicle vehicle, BOOL shouldReset);
	void SET_VEHICLE_DISABLE_COLLISION_UPON_CREATION(Vehicle vehicle, BOOL disable);
	void SET_GROUND_EFFECT_REDUCES_DRAG(BOOL toggle);
	void SET_DISABLE_MAP_COLLISION(Vehicle vehicle);
	void SET_DISABLE_PED_STAND_ON_TOP(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_DAMAGE_SCALES(Vehicle vehicle, Any p1, Any p2, Any p3, Any p4);
	void SET_PLANE_SECTION_DAMAGE_SCALE(Vehicle vehicle, Any p1, Any p2);
	void SET_HELI_CAN_PICKUP_ENTITY_THAT_HAS_PICK_UP_DISABLED(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_BOMB_AMMO(Vehicle vehicle, int bombCount);
	int GET_VEHICLE_BOMB_AMMO(Vehicle vehicle);
	void SET_VEHICLE_COUNTERMEASURE_AMMO(Vehicle vehicle, int counterMeasureCount);
	int GET_VEHICLE_COUNTERMEASURE_AMMO(Vehicle vehicle);
	void SET_HELI_COMBAT_OFFSET(Vehicle vehicle, float x, float y, float z);
	BOOL GET_CAN_VEHICLE_BE_PLACED_HERE(Vehicle vehicle, float x, float y, float z, float rotX, float rotY, float rotZ, int p7, Any p8);
	void SET_DISABLE_AUTOMATIC_CRASH_TASK(Vehicle vehicle, BOOL toggle);
	void SET_SPECIAL_FLIGHT_MODE_RATIO(Vehicle vehicle, float ratio);
	void SET_SPECIAL_FLIGHT_MODE_TARGET_RATIO(Vehicle vehicle, float targetRatio);
	void SET_SPECIAL_FLIGHT_MODE_ALLOWED(Vehicle vehicle, BOOL toggle);
	void SET_DISABLE_HOVER_MODE_FLIGHT(Vehicle vehicle, BOOL toggle);
	BOOL GET_OUTRIGGERS_DEPLOYED(Vehicle vehicle);
	Vector3 FIND_SPAWN_COORDINATES_FOR_HELI(Ped ped);
	void SET_DEPLOY_FOLDING_WINGS(Vehicle vehicle, BOOL deploy, BOOL p2);
	BOOL ARE_FOLDING_WINGS_DEPLOYED(Vehicle vehicle);
	void SET_DEPLOY_MISSILE_BAYS_(Vehicle vehicle, BOOL deploy);
	BOOL ARE_MISSILE_BAYS_DEPLOYED_(Vehicle vehicle);
	void SET_DIP_STRAIGHT_DOWN_WHEN_CRASHING_PLANE(Vehicle vehicle, BOOL toggle);
	void SET_TURRET_HIDDEN(Vehicle vehicle, int index, BOOL toggle);
	void SET_HOVER_MODE_WING_RATIO(Vehicle vehicle, float ratio);
	void SET_DISABLE_TURRET_MOVEMENT(Vehicle vehicle, int turretId);
	void SET_FORCE_FIX_LINK_MATRICES(Vehicle vehicle);
	void SET_TRANSFORM_RATE_FOR_ANIMATION(Vehicle vehicle, float transformRate);
	void SET_TRANSFORM_TO_SUBMARINE_USES_ALTERNATE_INPUT(Vehicle vehicle, BOOL toggle);
	void SET_VEHICLE_COMBAT_MODE(BOOL toggle);
	void SET_VEHICLE_DETONATION_MODE(BOOL toggle);
	void SET_VEHICLE_SHUNT_ON_STICK(BOOL toggle);
	BOOL GET_IS_VEHICLE_SHUNTING(Vehicle vehicle);
	BOOL GET_HAS_VEHICLE_BEEN_HIT_BY_SHUNT(Vehicle vehicle);
	Vehicle GET_LAST_SHUNT_VEHICLE(Vehicle vehicle);
	void SET_DISABLE_VEHICLE_EXPLOSIONS_DAMAGE(BOOL toggle);
	void SET_OVERRIDE_NITROUS_LEVEL(Vehicle vehicle, BOOL toggle, float level, float power, float rechargeTime, BOOL disableSound);
	void SET_INCREASE_WHEEL_CRUSH_DAMAGE(Vehicle vehicle, BOOL toggle);
	void SET_DISABLE_WEAPON_BLADE_FORCES(BOOL toggle);
	void SET_USE_DOUBLE_CLICK_FOR_CAR_JUMP(BOOL toggle);
	BOOL GET_DOES_VEHICLE_HAVE_TOMBSTONE(Vehicle vehicle);
	void HIDE_TOMBSTONE(Vehicle vehicle, BOOL toggle);
	BOOL GET_IS_VEHICLE_DISABLED_BY_EMP(Vehicle vehicle);
	void SET_DISABLE_RETRACTING_WEAPON_BLADES(BOOL toggle);
	float GET_TYRE_HEALTH(Vehicle vehicle, int wheelIndex);
	void SET_TYRE_HEALTH(Vehicle vehicle, int wheelIndex, float health);
	float GET_TYRE_WEAR_RATE(Vehicle vehicle, int wheelIndex);
	void SET_TYRE_WEAR_RATE(Vehicle vehicle, int wheelIndex, float multiplier);
	void SET_TYRE_WEAR_RATE_SCALE(Vehicle vehicle, int wheelIndex, float multiplier);
	void SET_TYRE_MAXIMUM_GRIP_DIFFERENCE_DUE_TO_WEAR_RATE(Vehicle vehicle, int wheelIndex, float multiplier);
	void SET_AIRCRAFT_IGNORE_HIGHTMAP_OPTIMISATION(Vehicle vehicle, int p1);
	void SET_REDUCED_SUSPENSION_FORCE(Vehicle vehicle, BOOL enable);
	void SET_DRIFT_TYRES(Vehicle vehicle, BOOL toggle);
	BOOL GET_DRIFT_TYRES_SET(Vehicle vehicle);
	void NETWORK_USE_HIGH_PRECISION_TRAIN_BLENDING(Vehicle vehicle, BOOL toggle);
	void SET_CHECK_FOR_ENOUGH_ROOM_FOR_PED(Vehicle vehicle, BOOL p1);
}

namespace WATER
{
	BOOL GET_WATER_HEIGHT(float x, float y, float z, float* height);
	BOOL GET_WATER_HEIGHT_NO_WAVES(float x, float y, float z, float* height);
	BOOL TEST_PROBE_AGAINST_WATER(float x1, float y1, float z1, float x2, float y2, float z2, Vector3* result);
	int TEST_PROBE_AGAINST_ALL_WATER(float x1, float y1, float z1, float x2, float y2, float z2, int flags, float* waterHeight);
	int TEST_VERTICAL_PROBE_AGAINST_ALL_WATER(float x, float y, float z, int flags, float* waterHeight);
	void MODIFY_WATER(float x, float y, float radius, float height);
	int ADD_EXTRA_CALMING_QUAD(float xLow, float yLow, float xHigh, float yHigh, float height);
	void REMOVE_EXTRA_CALMING_QUAD(int calmingQuad);
	void SET_DEEP_OCEAN_SCALER(float intensity);
	float GET_DEEP_OCEAN_SCALER();
	void SET_CALMED_WAVE_HEIGHT_SCALER(float height);
	void RESET_DEEP_OCEAN_SCALER();
}

namespace WEAPON
{
	void ENABLE_LASER_SIGHT_RENDERING(BOOL toggle);
	Hash GET_WEAPON_COMPONENT_TYPE_MODEL(Hash componentHash);
	Hash GET_WEAPONTYPE_MODEL(Hash weaponHash);
	Hash GET_WEAPONTYPE_SLOT(Hash weaponHash);
	Hash GET_WEAPONTYPE_GROUP(Hash weaponHash);
	int GET_WEAPON_COMPONENT_VARIANT_EXTRA_COUNT(Hash componentHash);
	Hash GET_WEAPON_COMPONENT_VARIANT_EXTRA_MODEL(Hash componentHash, int extraComponentIndex);
	void SET_CURRENT_PED_WEAPON(Ped ped, Hash weaponHash, BOOL bForceInHand);
	BOOL GET_CURRENT_PED_WEAPON(Ped ped, Hash* weaponHash, BOOL p2);
	Entity GET_CURRENT_PED_WEAPON_ENTITY_INDEX(Ped ped, Any p1);
	Hash GET_BEST_PED_WEAPON(Ped ped, BOOL p1);
	BOOL SET_CURRENT_PED_VEHICLE_WEAPON(Ped ped, Hash weaponHash);
	BOOL GET_CURRENT_PED_VEHICLE_WEAPON(Ped ped, Hash* weaponHash);
	void SET_PED_CYCLE_VEHICLE_WEAPONS_ONLY(Ped ped);
	BOOL IS_PED_ARMED(Ped ped, int typeFlags);
	BOOL IS_WEAPON_VALID(Hash weaponHash);
	BOOL HAS_PED_GOT_WEAPON(Ped ped, Hash weaponHash, BOOL p2);
	BOOL IS_PED_WEAPON_READY_TO_SHOOT(Ped ped);
	Hash GET_PED_WEAPONTYPE_IN_SLOT(Ped ped, Hash weaponSlot);
	int GET_AMMO_IN_PED_WEAPON(Ped ped, Hash weaponhash);
	void ADD_AMMO_TO_PED(Ped ped, Hash weaponHash, int ammo);
	void SET_PED_AMMO(Ped ped, Hash weaponHash, int ammo, BOOL p3);
	void SET_PED_INFINITE_AMMO(Ped ped, BOOL toggle, Hash weaponHash);
	void SET_PED_INFINITE_AMMO_CLIP(Ped ped, BOOL toggle);
	void SET_PED_STUN_GUN_FINITE_AMMO(Any p0, Any p1);
	void GIVE_WEAPON_TO_PED(Ped ped, Hash weaponHash, int ammoCount, BOOL isHidden, BOOL bForceInHand);
	void GIVE_DELAYED_WEAPON_TO_PED(Ped ped, Hash weaponHash, int ammoCount, BOOL bForceInHand);
	void REMOVE_ALL_PED_WEAPONS(Ped ped, BOOL p1);
	void REMOVE_WEAPON_FROM_PED(Ped ped, Hash weaponHash);
	void HIDE_PED_WEAPON_FOR_SCRIPTED_CUTSCENE(Ped ped, BOOL toggle);
	void SET_PED_CURRENT_WEAPON_VISIBLE(Ped ped, BOOL visible, BOOL deselectWeapon, BOOL p3, BOOL p4);
	void SET_PED_DROPS_WEAPONS_WHEN_DEAD(Ped ped, BOOL toggle);
	BOOL HAS_PED_BEEN_DAMAGED_BY_WEAPON(Ped ped, Hash weaponHash, int weaponType);
	void CLEAR_PED_LAST_WEAPON_DAMAGE(Ped ped);
	BOOL HAS_ENTITY_BEEN_DAMAGED_BY_WEAPON(Entity entity, Hash weaponHash, int weaponType);
	void CLEAR_ENTITY_LAST_WEAPON_DAMAGE(Entity entity);
	void SET_PED_DROPS_WEAPON(Ped ped);
	void SET_PED_DROPS_INVENTORY_WEAPON(Ped ped, Hash weaponHash, float xOffset, float yOffset, float zOffset, int ammoCount);
	int GET_MAX_AMMO_IN_CLIP(Ped ped, Hash weaponHash, BOOL p2);
	BOOL GET_AMMO_IN_CLIP(Ped ped, Hash weaponHash, int* ammo);
	BOOL SET_AMMO_IN_CLIP(Ped ped, Hash weaponHash, int ammo);
	BOOL GET_MAX_AMMO(Ped ped, Hash weaponHash, int* ammo);
	BOOL GET_MAX_AMMO_BY_TYPE(Ped ped, Hash ammoTypeHash, int* ammo);
	void ADD_PED_AMMO_BY_TYPE(Ped ped, Hash ammoTypeHash, int ammo);
	void SET_PED_AMMO_BY_TYPE(Ped ped, Hash ammoTypeHash, int ammo);
	int GET_PED_AMMO_BY_TYPE(Ped ped, Hash ammoTypeHash);
	void SET_PED_AMMO_TO_DROP(Ped ped, int p1);
	void SET_PICKUP_AMMO_AMOUNT_SCALER(float p0);
	Hash GET_PED_AMMO_TYPE_FROM_WEAPON(Ped ped, Hash weaponHash);
	Hash GET_PED_ORIGINAL_AMMO_TYPE_FROM_WEAPON(Ped ped, Hash weaponHash);
	BOOL GET_PED_LAST_WEAPON_IMPACT_COORD(Ped ped, Vector3* coords);
	void SET_PED_GADGET(Ped ped, Hash gadgetHash, BOOL p2);
	BOOL GET_IS_PED_GADGET_EQUIPPED(Ped ped, Hash gadgetHash);
	Hash GET_SELECTED_PED_WEAPON(Ped ped);
	void EXPLODE_PROJECTILES(Ped ped, Hash weaponHash, BOOL p2);
	void REMOVE_ALL_PROJECTILES_OF_TYPE(Hash weaponHash, BOOL explode);
	float GET_LOCKON_DISTANCE_OF_CURRENT_PED_WEAPON(Ped ped);
	float GET_MAX_RANGE_OF_CURRENT_PED_WEAPON(Ped ped);
	BOOL HAS_VEHICLE_GOT_PROJECTILE_ATTACHED(Ped driver, Vehicle vehicle, Hash weaponHash, Any p3);
	void GIVE_WEAPON_COMPONENT_TO_PED(Ped ped, Hash weaponHash, Hash componentHash);
	void REMOVE_WEAPON_COMPONENT_FROM_PED(Ped ped, Hash weaponHash, Hash componentHash);
	BOOL HAS_PED_GOT_WEAPON_COMPONENT(Ped ped, Hash weaponHash, Hash componentHash);
	BOOL IS_PED_WEAPON_COMPONENT_ACTIVE(Ped ped, Hash weaponHash, Hash componentHash);
	BOOL REFILL_AMMO_INSTANTLY(Ped ped);
	BOOL MAKE_PED_RELOAD(Ped ped);
	void REQUEST_WEAPON_ASSET(Hash weaponHash, int p1, int p2);
	BOOL HAS_WEAPON_ASSET_LOADED(Hash weaponHash);
	void REMOVE_WEAPON_ASSET(Hash weaponHash);
	Object CREATE_WEAPON_OBJECT(Hash weaponHash, int ammoCount, float x, float y, float z, BOOL showWorldModel, float scale, Any p7, Any p8, Any p9);
	void GIVE_WEAPON_COMPONENT_TO_WEAPON_OBJECT(Object weaponObject, Hash componentHash);
	void REMOVE_WEAPON_COMPONENT_FROM_WEAPON_OBJECT(Object object, Hash componentHash);
	BOOL HAS_WEAPON_GOT_WEAPON_COMPONENT(Object weapon, Hash componentHash);
	void GIVE_WEAPON_OBJECT_TO_PED(Object weaponObject, Ped ped);
	BOOL DOES_WEAPON_TAKE_WEAPON_COMPONENT(Hash weaponHash, Hash componentHash);
	Object GET_WEAPON_OBJECT_FROM_PED(Ped ped, BOOL p1);
	void GIVE_LOADOUT_TO_PED(Ped ped, Hash loadoutHash);
	void SET_PED_WEAPON_TINT_INDEX(Ped ped, Hash weaponHash, int tintIndex);
	int GET_PED_WEAPON_TINT_INDEX(Ped ped, Hash weaponHash);
	void SET_WEAPON_OBJECT_TINT_INDEX(Object weapon, int tintIndex);
	int GET_WEAPON_OBJECT_TINT_INDEX(Object weapon);
	int GET_WEAPON_TINT_COUNT(Hash weaponHash);
	void SET_PED_WEAPON_COMPONENT_TINT_INDEX(Ped ped, Hash weaponHash, Hash camoComponentHash, int colorIndex);
	int GET_PED_WEAPON_COMPONENT_TINT_INDEX(Ped ped, Hash weaponHash, Hash camoComponentHash);
	void SET_WEAPON_OBJECT_COMPONENT_TINT_INDEX(Object weaponObject, Hash camoComponentHash, int colorIndex);
	int GET_WEAPON_OBJECT_COMPONENT_TINT_INDEX(Object weaponObject, Hash camoComponentHash);
	int GET_PED_WEAPON_CAMO_INDEX(Ped ped, Hash weaponHash);
	void SET_WEAPON_OBJECT_CAMO_INDEX(Object weaponObject, int p1);
	BOOL GET_WEAPON_HUD_STATS(Hash weaponHash, Any* outData);
	BOOL GET_WEAPON_COMPONENT_HUD_STATS(Hash componentHash, Any* outData);
	float GET_WEAPON_DAMAGE(Hash weaponHash, Hash componentHash);
	int GET_WEAPON_CLIP_SIZE(Hash weaponHash);
	float GET_WEAPON_TIME_BETWEEN_SHOTS(Hash weaponHash);
	void SET_PED_CHANCE_OF_FIRING_BLANKS(Ped ped, float xBias, float yBias);
	Object SET_PED_SHOOT_ORDNANCE_WEAPON(Ped ped, float p1);
	void REQUEST_WEAPON_HIGH_DETAIL_MODEL(Entity weaponObject);
	void SET_WEAPON_DAMAGE_MODIFIER(Hash weaponHash, float damageMultiplier);
	void SET_WEAPON_AOE_MODIFIER(Hash weaponHash, float multiplier);
	void SET_WEAPON_EFFECT_DURATION_MODIFIER(Hash p0, float p1);
	BOOL IS_PED_CURRENT_WEAPON_SILENCED(Ped ped);
	BOOL IS_FLASH_LIGHT_ON(Ped ped);
	BOOL SET_FLASH_LIGHT_FADE_DISTANCE(float distance);
	void SET_FLASH_LIGHT_ACTIVE_HISTORY(Ped ped, BOOL toggle);
	void SET_WEAPON_ANIMATION_OVERRIDE(Ped ped, Hash animStyle);
	int GET_WEAPON_DAMAGE_TYPE(Hash weaponHash);
	void SET_EQIPPED_WEAPON_START_SPINNING_AT_FULL_SPEED(Ped ped);
	BOOL CAN_USE_WEAPON_ON_PARACHUTE(Hash weaponHash);
	int CREATE_AIR_DEFENCE_SPHERE(float x, float y, float z, float radius, float p4, float p5, float p6, Hash weaponHash);
	int CREATE_AIR_DEFENCE_ANGLED_AREA(float p0, float p1, float p2, float p3, float p4, float p5, float p6, float p7, float p8, float radius, Hash weaponHash);
	BOOL REMOVE_AIR_DEFENCE_SPHERE(int zoneId);
	void REMOVE_ALL_AIR_DEFENCE_SPHERES();
	void SET_PLAYER_TARGETTABLE_FOR_AIR_DEFENCE_SPHERE(Player player, int zoneId, BOOL enable);
	BOOL IS_AIR_DEFENCE_SPHERE_IN_AREA(float x, float y, float z, float radius, int* outZoneId);
	void FIRE_AIR_DEFENCE_SPHERE_WEAPON_AT_POSITION(int zoneId, float x, float y, float z);
	BOOL DOES_AIR_DEFENCE_SPHERE_EXIST(int zoneId);
	void SET_CAN_PED_SELECT_INVENTORY_WEAPON(Ped ped, Hash weaponHash, BOOL toggle);
	void SET_CAN_PED_SELECT_ALL_WEAPONS(Ped ped, BOOL toggle);
}

namespace ZONE
{
	int GET_ZONE_AT_COORDS(float x, float y, float z);
	int GET_ZONE_FROM_NAME_ID(const char* zoneName);
	int GET_ZONE_POPSCHEDULE(int zoneId);
	const char* GET_NAME_OF_ZONE(float x, float y, float z);
	void SET_ZONE_ENABLED(int zoneId, BOOL toggle);
	int GET_ZONE_SCUMMINESS(int zoneId);
	void OVERRIDE_POPSCHEDULE_VEHICLE_MODEL(int scheduleId, Hash vehicleHash);
	void CLEAR_POPSCHEDULE_OVERRIDE_VEHICLE_MODEL(int scheduleId);
	Hash GET_HASH_OF_MAP_AREA_AT_COORDS(float x, float y, float z);
}