import { Vector2 } from '../types/Vector2';
import { Vector3 } from '../types/Vector3';
import { Vector4 } from '../types/Vector4';
import { Color } from '../types/Color';
import { createFromHandle } from '../types/HandleRegistry';
import { inv, rai, raf, ras, rav, pvi, pvf, pvv, pvii, pvfi, _h, f, int, uint, float, Hash, u8, u16, u32, u64, i8, i16, i32, i64 } from '../types/NativeAliases';

export class Scripts {
  /**
   * @returns value
   */
  static countPlayerBits(): [int, number] {
    const result = inv<[number, number]>('0x462C687BEA254BD9', pvi(), rai());
    return [result[0], result[1]];
  }

  /**
   * @returns playerBits
   */
  static isAnyPlayerBitSet(): [boolean, number] {
    const result = inv<[boolean, number]>('0x179A6F0EE2E79026', pvi(), rai());
    return [!!result[0], result[1]];
  }

  /**
   * goalContext: see <availableContexts> in common/data/stats_and_challenges/goals_*.meta
   *
   * @param goalContext 
   */
  static activateGoalContext(goalContext: string | number): void {
    inv<void>('0x7D654266025E921B', _h(goalContext));
  }

  /**
   * @param scriptName 
   * @param stackSize 
   * @returns
   */
  static startNewScript(scriptName: string, stackSize: int): int {
    return inv<number>('0xE81651AD79516E48', scriptName, stackSize, rai());
  }

  /**
   * @param awardHash 
   * @param itemIndex 
   * @returns rpcGuid; outResultItem
   */
  static awardsGetResultItem(awardHash: string | number, itemIndex: int): [any, number, number] {
    const result = inv<[number, number, number]>('0xAC8FAB22A914AE34', pvi(), _h(awardHash), itemIndex, pvi());
    return [result[0], result[1], result[2]];
  }

  /**
   * Returns true if GtaThread+0x77C is equal to 1. Old name: _BG_EXITED_BECAUSE_BACKGROUND_THREAD_STOPPED
   *
   * @returns
   */
  static bgIsExitflagSet(): boolean {
    return !!inv<boolean>('0x2238EC3EC631AB1F', rai());
  }

  /**
   * Starts a new iteration of the current threads.
   * Call this first, then SCRIPT_THREAD_ITERATOR_GET_NEXT_THREAD_ID (0x30B4FA1C82DD4B9F)
   */
  static scriptThreadIteratorReset(): void {
    inv<void>('0x39382EB8DCD8684D');
  }

  /**
   * @param threadId 
   * @returns
   */
  static isBackgroundScript(threadId: int): boolean {
    return !!inv<boolean>('0x20B7F69B40C6B755', threadId, rai());
  }

  /**
   * @param dataIndex 
   * @returns rpcGuid; outLootData
   */
  static lootGetLootClaimData(dataIndex: int): [boolean, number, number] {
    const result = inv<[boolean, number, number]>('0xF1E9045F5AA9E428', pvi(), dataIndex, pvi(), rai());
    return [!!result[0], result[1], result[2]];
  }

  /**
   * @param scriptHash 
   * @returns
   */
  static doesScriptWithNameHashExist(scriptHash: string | number): boolean {
    return !!inv<boolean>('0xA34E89749F628284', _h(scriptHash), rai());
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @param gamemodeName 
   * @param title 
   * @param subtitle 
   */
  static displayLoadingScreens(p0: string | number, p1: string | number, p2: string | number, gamemodeName: string, title: string, subtitle: string): void {
    inv<void>('0x1E5B70E53DB661E5', _h(p0), _h(p1), _h(p2), gamemodeName, title, subtitle);
  }

  /**
   * @param bitIndex 
   * @returns value
   */
  static clearPlayerBitAtIndex(bitIndex: int): number {
    const result = inv<number>('0xD426E2E3288469D6', pvi(), bitIndex);
    return result;
  }

  /**
   * @param p0 
   */
  static N_0x6F700A4BF7C3331B(p0: boolean): void {
    inv<void>('0x6F700A4BF7C3331B', p0);
  }

  /**
   * Inserts the given context into the background scripts context map.
   *
   * @param contextName 
   */
  static bgStartContext(contextName: string): void {
    inv<void>('0x49BA5678BA040CA7', contextName);
  }

  /**
   * return : script thread id, 0 if failed
   * Pass pointer to struct of args in p1, size of struct goes into p2
   *
   * @param scriptName 
   * @param argCount 
   * @param stackSize 
   * @returns args
   */
  static startNewScriptWithArgs(scriptName: string, argCount: int, stackSize: int): [int, number] {
    const result = inv<[number, number]>('0xB8BA7F44DF1575E1', scriptName, pvi(), argCount, stackSize, rai());
    return [result[0], result[1]];
  }

  /**
   * @param threadId 
   * @returns
   */
  static doesThreadExist(threadId: int): boolean {
    return !!inv<boolean>('0xFF975BC4435A0FA3', threadId, rai());
  }

  /**
   * eventGroup: 0 = SCRIPT_EVENT_QUEUE_AI (CEventGroupScriptAI), 1 = SCRIPT_EVENT_QUEUE_NETWORK (CEventGroupScriptNetwork), 2 = unk, 3 = unk, 4 = SCRIPT_EVENT_QUEUE_ERRORS (CEventGroupScriptErrors)
   *
   * @param eventGroup 
   * @returns
   */
  static getNumberOfEvents(eventGroup: int): int {
    return inv<number>('0x5CE8DE5909565748', eventGroup, rai());
  }

  static shutdownLoadingScreen(): void {
    inv<void>('0xFC179D7E8886DADF');
  }

  /**
   * @param p0 
   * @returns
   */
  static N_0xE7282390542F570D(p0: any): any {
    return inv<number>('0xE7282390542F570D', p0);
  }

  /**
   * @param scriptIndex 
   * @param p1 
   * @returns
   */
  static bgGetLaunchParamValue(scriptIndex: int, p1: string): int {
    return inv<number>('0x55C40B7592BAD213', scriptIndex, p1, rai());
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0x1BDB5A07307F6929(p0: any, p1: any): void {
    inv<void>('0x1BDB5A07307F6929', p0, p1);
  }

  /**
   * @param index 
   * @returns
   */
  static doesCompressedGlobalBlockBufferExist(index: int): boolean {
    return !!inv<boolean>('0x66EE5B93C308F734', index, rai());
  }

  /**
   * @param index 
   * @param toggle 
   */
  static setGlobalBlockCanBeAccessed(index: int, toggle: boolean): void {
    inv<void>('0xE66F392BFCE734AF', index, toggle);
  }

  /**
   * @param p0 
   * @returns
   */
  static bgGetScriptIdFromNameHash(p0: string | number): int {
    return inv<number>('0x829CD22E043A2577', _h(p0), rai());
  }

  /**
   * @returns
   */
  static getNoLoadingScreen(): boolean {
    return !!inv<boolean>('0x323DAF00687E0F28', rai());
  }

  /**
   * @param p0 
   * @param p1 
   * @returns
   */
  static N_0x0A79C81C418F5D38(p0: any, p1: any): any {
    return inv<number>('0x0A79C81C418F5D38', p0, p1);
  }

  /**
   * @param p0 
   * @returns
   */
  static N_0xA88E1D7FA1E20080(p0: any): any {
    return inv<number>('0xA88E1D7FA1E20080', p0);
  }

  /**
   * @param params 
   */
  static bailWithPassThroughParams(params: string): void {
    inv<void>('0xE98204D3C25AE14C', params);
  }

  /**
   * If the function returns 0, the end of the iteration has been reached.
   *
   * @returns
   */
  static scriptThreadIteratorGetNextThreadId(): int {
    return inv<number>('0x3CE3FB167E837D7C', rai());
  }

  /**
   * @param scriptHash 
   */
  static setScriptWithNameHashAsNoLongerNeeded(scriptHash: string | number): void {
    inv<void>('0x50723A1567C8361E', _h(scriptHash));
  }

  /**
   * @param p1 
   * @returns value
   */
  static getBlockOfPlayerBits(p1: int): [int, number] {
    const result = inv<[number, number]>('0xFA3B530A5CC693D5', pvi(), p1, rai());
    return [result[0], result[1]];
  }

  /**
   * Deletes the given context from the background scripts context map.
   *
   * @param contextName 
   */
  static bgEndContext(contextName: string): void {
    inv<void>('0x3ABF7BA1C3E2C8CF', contextName);
  }

  /**
   * @param scriptHash 
   * @returns
   */
  static hasScriptWithNameHashLoaded(scriptHash: string | number): boolean {
    return !!inv<boolean>('0xA5D8E0C2F3C7EEBC', _h(scriptHash), rai());
  }

  /**
   * @param p0 
   */
  static N_0x5827BE85A87B073D(p0: any): void {
    inv<void>('0x5827BE85A87B073D', p0);
  }

  /**
   * enum eThreadExitReason
   * {
   * THREAD_EXIT_REASON_NONE,
   * THREAD_EXIT_REASON_BACKGROUND_THREAD_STOPPED,
   * THREAD_EXIT_REASON_SESSION_MERGE,
   * THREAD_EXIT_REASON_SCENARIO_OUT_OF_SCOPE,
   * THREAD_EXIT_REASON_REQUESTED_BY_SCRIPT
   * };
   *
   * @returns
   */
  static getThreadExitReason(): int {
    return inv<number>('0x54AE4FDEEFEAB77E', rai());
  }

  /**
   * @param bitIndex 
   * @returns value
   */
  static setPlayerBitAtIndex(bitIndex: int): number {
    const result = inv<number>('0x31010318BA9897AC', pvi(), bitIndex);
    return result;
  }

  /**
   * @returns value
   */
  static clearAllPlayerBits(): number {
    const result = inv<number>('0xDE544B7EC0C187CC', pvi());
    return result;
  }

  /**
   * @param itemIndex 
   * @returns rpcGuid; outResultItem
   */
  static lootGetResultItem(itemIndex: int): [any, number, number] {
    const result = inv<[number, number, number]>('0x4293B44A855F82CC', pvi(), itemIndex, pvi());
    return [result[0], result[1], result[2]];
  }

  /**
   * Returns if a script has been loaded into the game. Used to see if a script was loaded after requesting.
   *
   * @param scriptName 
   * @returns
   */
  static hasScriptLoaded(scriptName: string): boolean {
    return !!inv<boolean>('0xE97BD36574F8B0A6', scriptName, rai());
  }

  /**
   * @param toggle 
   */
  static setNoLoadingScreen(toggle: boolean): void {
    inv<void>('0x5CB83156AA038F95', toggle);
  }

  /**
   * @param scriptIndex 
   * @param p1 
   * @returns
   */
  static bgDoesLaunchParamExist(scriptIndex: int, p1: string): boolean {
    return !!inv<boolean>('0x4AE1DFF337A86FDE', scriptIndex, p1, rai());
  }

  /**
   * @param threadId 
   */
  static requestThreadExit(threadId: int): void {
    inv<void>('0x7DE4643157AD646C', threadId);
  }

  /**
   * Hashed version of BG_END_CONTEXT
   *
   * @param contextHash 
   */
  static bgEndContextHash(contextHash: string | number): void {
    inv<void>('0x6D1431744182CDE8', _h(contextHash));
  }

  /**
   * @param scriptName 
   * @returns
   */
  static doesScriptExist(scriptName: string): boolean {
    return !!inv<boolean>('0x552B171E3F69E5AE', scriptName, rai());
  }

  /**
   * @returns
   */
  static getHashOfThisScriptName(): number {
    return (inv<number>('0xBC2C927F5C264960', rai())) & 0xFFFFFFFF;
  }

  static bgReloadAllBackgroundScripts(): void {
    inv<void>('0xBE7D814CFA181B56');
  }

  /**
   * eventGroup: 0 = SCRIPT_EVENT_QUEUE_AI (CEventGroupScriptAI), 1 = SCRIPT_EVENT_QUEUE_NETWORK (CEventGroupScriptNetwork), 2 = unk, 3 = unk, 4 = SCRIPT_EVENT_QUEUE_SCRIPT_ERRORS (CEventGroupScriptErrors) Note: eventDataSize is NOT the size in bytes, it is the size determined by the SIZE_OF operator (RAGE Script operator, not C/C++ sizeof). That is, the size in bytes divided by 8 (script variables are always 8-byte aligned!). playerBits (also known as playersToBroadcastTo) is a bitset that indicates which players this event should be sent to. In order to send the event to specific players only, use (1 << playerIndex). Set all bits if it should be broadcast to all players.
   *
   * @param eventGroup 
   * @param eventDataSize 
   * @param scriptMetadataIndex 
   * @returns eventData; playerBits
   */
  static triggerScriptEvent(eventGroup: int, eventDataSize: int, scriptMetadataIndex: int): [number, number] {
    const result = inv<[number, number]>('0x5AE99C571D5BBE5D', eventGroup, pvi(), eventDataSize, scriptMetadataIndex, pvi());
    return [result[0], result[1]];
  }

  /**
   * goalContext: see _ACTIVATE_GOAL_CONTEXT
   *
   * @param goalContext 
   * @returns
   */
  static isGoalContextActive(goalContext: string | number): boolean {
    return !!inv<boolean>('0x7409669C5ED50144', _h(goalContext), rai());
  }

  /**
   * @param scriptName 
   */
  static setScriptAsNoLongerNeeded(scriptName: string): void {
    inv<void>('0x0086D3067E1CFD1C', scriptName);
  }

  /**
   * @returns p0; p1; p2
   */
  static N_0x64F765D9A1F8F02C(): [number, number, number] {
    const result = inv<[number, number, number]>('0x64F765D9A1F8F02C', pvi(), pvi(), pvi());
    return [result[0], result[1], result[2]];
  }

  /**
   * @param scriptName 
   */
  static requestScript(scriptName: string): void {
    inv<void>('0x46ED607DDD40D7FE', scriptName);
  }

  /**
   * @param toggle 
   */
  static setAllGlobalBlocksHaveBeenLoaded(toggle: boolean): void {
    inv<void>('0x11986B05885564D2', toggle);
  }

  /**
   * Returns "INVALID_NET_RPC_GUID" if netRpcGuid is invalid.
   *
   * @returns netRpcGuid
   */
  static netRpcGuidToString(): [string, number] {
    const result = inv<[string, number]>('0xAC9FF854BD4BA9B5', pvi(), ras());
    return [result[0], result[1]];
  }

  /**
   * eventGroup: 0 = SCRIPT_EVENT_QUEUE_AI (CEventGroupScriptAI), 1 = SCRIPT_EVENT_QUEUE_NETWORK (CEventGroupScriptNetwork), 2 = unk, 3 = unk, 4 = SCRIPT_EVENT_QUEUE_SCRIPT_ERRORS (CEventGroupScriptErrors) Returns event name hash: https://alloc8or.re/rdr3/doc/enums/eEventType.txt
   *
   * @param eventGroup 
   * @param eventIndex 
   * @returns
   */
  static getEventAtIndex(eventGroup: int, eventIndex: int): number {
    return (inv<number>('0xA85E614430EFF816', eventGroup, eventIndex, rai())) & 0xFFFFFFFF;
  }

  /**
   * @param scriptHash 
   * @param argCount 
   * @param stackSize 
   * @returns args
   */
  static startNewScriptWithNameHashAndArgs(scriptHash: string | number, argCount: int, stackSize: int): [int, number] {
    const result = inv<[number, number]>('0xC4BB298BD441BE78', _h(scriptHash), pvi(), argCount, stackSize, rai());
    return [result[0], result[1]];
  }

  /**
   * eventGroup: 0 = SCRIPT_EVENT_QUEUE_AI (CEventGroupScriptAI), 1 = SCRIPT_EVENT_QUEUE_NETWORK (CEventGroupScriptNetwork), 2 = unk, 3 = unk, 4 = SCRIPT_EVENT_QUEUE_SCRIPT_ERRORS (CEventGroupScriptErrors)
   *
   * @param eventGroup 
   * @param eventType 
   * @returns
   */
  static getEventExists(eventGroup: int, eventType: string | number): boolean {
    return !!inv<boolean>('0xC9F59C0A710ECD34', eventGroup, _h(eventType), rai());
  }

  /**
   * @param index 
   * @returns
   */
  static getGlobalBlockCanBeAccessed(index: int): boolean {
    return !!inv<boolean>('0x42A7EB5C814C2DE0', index, rai());
  }

  /**
   * @returns
   */
  static isThreadExitRequested(): boolean {
    return !!inv<boolean>('0x9E4EF615E307FBBE', rai());
  }

  static terminateThisThread(): void {
    inv<void>('0x5E8B6D17FF91CD59');
  }

  static N_0x76CBCD9EADC00955(): void {
    inv<void>('0x76CBCD9EADC00955');
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   * @param p3 
   * @param p4 
   * @param p5 
   * @param p6 
   * @param p7 
   */
  static N_0x29FB4CE89472C3CB(p0: any, p1: any, p2: float, p3: float, p4: string, p5: string, p6: string, p7: int): void {
    inv<void>('0x29FB4CE89472C3CB', p0, p1, f(p2), f(p3), p4, p5, p6, p7);
  }

  /**
   * @param threadId 
   */
  static terminateThread(threadId: int): void {
    inv<void>('0x87ED52AE40EA1A52', threadId);
  }

  /**
   * @param eventDataSize 
   * @param scriptMetadataIndex 
   * @param threadId 
   * @returns eventData
   */
  static triggerScriptEvent2(eventDataSize: int, scriptMetadataIndex: int, threadId: int): number {
    const result = inv<number>('0x8B61C950A148FFA2', pvi(), eventDataSize, scriptMetadataIndex, threadId);
    return result;
  }

  /**
   * Gets the number of instances of the specified script is currently running. Actually returns numRefs - 1.
   * if (program)
   * v3 = rage::scrProgram::GetNumRefs(program) - 1;
   * return v3; Old name: _GET_NUMBER_OF_REFERENCES_OF_SCRIPT_WITH_NAME_HASH
   *
   * @param scriptHash 
   * @returns
   */
  static getNumberOfThreadsRunningTheScriptWithThisHash(scriptHash: string | number): int {
    return inv<number>('0x8E34C953364A76DD', _h(scriptHash), rai());
  }

  /**
   * Waiting for child scripts to terminate / waiting for collapse of child scripts
   *
   * @param p0 
   * @returns
   */
  static haveAllChildScriptsTerminated(p0: int): any {
    return inv<number>('0x380FFA15B72408FB', p0);
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   */
  static N_0xFFDDF802279BE128(p0: any, p1: any, p2: any): void {
    inv<void>('0xFFDDF802279BE128', p0, p1, p2);
  }

  /**
   * @param bitIndex 
   * @returns value
   */
  static isPlayerBitSetAtIndex(bitIndex: int): [boolean, number] {
    const result = inv<[boolean, number]>('0x72B2E00C9BAC6789', pvi(), bitIndex, rai());
    return [!!result[0], result[1]];
  }

  /**
   * @returns value
   */
  static setAllPlayerBits(): number {
    const result = inv<number>('0x20F4CB76689ACDBC', pvi());
    return result;
  }

  /**
   * Sets bit 0 in GtaThread+0x784
   */
  static bgSetExitflagResponse(): void {
    inv<void>('0x4858148E3B8A75D0');
  }

  /**
   * @returns value
   */
  static countParticipantBits(): [int, number] {
    const result = inv<[number, number]>('0x2F050A3FF8738245', pvi(), rai());
    return [result[0], result[1]];
  }

  /**
   * Same as GET_IS_LOADING_SCREEN_ACTIVE
   *
   * @returns
   */
  static isLoadingScreenVisible(): boolean {
    return !!inv<boolean>('0xB54ADBE65D528FCB', rai());
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   */
  static N_0xE4ABE20DCE7C7CFE(p0: any, p1: any, p2: any): void {
    inv<void>('0xE4ABE20DCE7C7CFE', p0, p1, p2);
  }

  /**
   * @param p1 
   * @param p2 
   * @returns value
   */
  static setBlockOfPlayerBits(p1: int, p2: int): number {
    const result = inv<number>('0xC6DFB8C04C86D5A5', pvi(), p1, p2);
    return result;
  }

  /**
   * Hashed version of BG_START_CONTEXT
   *
   * @param contextHash 
   */
  static bgStartContextHash(contextHash: string | number): void {
    inv<void>('0x2EB67D564DCC09D5', _h(contextHash));
  }

  /**
   * @param threadId 
   * @returns
   */
  static isThreadExitRequestedForThreadWithThisId(threadId: int): boolean {
    return !!inv<boolean>('0x30BED53646C86D11', threadId, rai());
  }

  /**
   * @param index 
   * @returns
   */
  static restoreGlobalBlock(index: int): any {
    return inv<number>('0xDC3914A99B4A5FDF', index);
  }

  /**
   * @param eventGroup 
   * @param eventIndex 
   * @param p2 
   */
  static setEventFlagForDeletion(eventGroup: int, eventIndex: int, p2: boolean): void {
    inv<void>('0x4768D5252EAEB76F', eventGroup, eventIndex, p2);
  }

  /**
   * @param threadId 
   * @returns threadExists; hasScriptHandler
   */
  static getThreadExistenceDetails(threadId: int): [boolean, boolean] {
    const result = inv<[number, number]>('0xD92FA81B64920E85', threadId, pvi(), pvi());
    return [!!result[0], !!result[1]];
  }

  /**
   * @param p0 
   * @param p1 
   * @param p2 
   */
  static N_0x42A429CDFED6D99D(p0: any, p1: any, p2: any): void {
    inv<void>('0x42A429CDFED6D99D', p0, p1, p2);
  }

  /**
   * @param p0 
   */
  static stopDisplayingMpTransitionLoadingScreens(p0: any): void {
    inv<void>('0x778D4733E0F2F265', p0);
  }

  /**
   * @param threadId 
   * @param ignoreKilledState 
   * @returns
   */
  static isThreadActive(threadId: int, ignoreKilledState: boolean): boolean {
    return !!inv<boolean>('0x46E9AE36D8FA6417', threadId, ignoreKilledState, rai());
  }

  /**
   * eventGroup: 0 = SCRIPT_EVENT_QUEUE_AI (CEventGroupScriptAI), 1 = SCRIPT_EVENT_QUEUE_NETWORK (CEventGroupScriptNetwork), 2 = unk, 3 = unk, 4 = SCRIPT_EVENT_QUEUE_SCRIPT_ERRORS (CEventGroupScriptErrors) Note: eventDataSize is NOT the size in bytes, it is the size determined by the SIZE_OF operator (RAGE Script operator, not C/C++ sizeof). That is, the size in bytes divided by 8 (script variables are always 8-byte aligned!). https://github.com/femga/rdr3_discoveries/tree/master/AI/EVENTS
   *
   * @param eventGroup 
   * @param eventIndex 
   * @param eventDataSize 
   * @returns eventData
   */
  static getEventData(eventGroup: int, eventIndex: int, eventDataSize: int): [boolean, number] {
    const result = inv<[boolean, number]>('0x57EC5FA4D4D6AFCA', eventGroup, eventIndex, pvi(), eventDataSize, rai());
    return [!!result[0], result[1]];
  }

  /**
   * @param awardHash 
   * @param dataIndex 
   * @returns rpcGuid; outUnlockData
   */
  static awardsGetUnlockClaimData(awardHash: string | number, dataIndex: int): [any, number, number] {
    const result = inv<[number, number, number]>('0xB9467E41DAB1CF2C', pvi(), _h(awardHash), dataIndex, pvi());
    return [result[0], result[1], result[2]];
  }

  /**
   * @param scriptHash 
   */
  static requestScriptWithNameHash(scriptHash: string | number): void {
    inv<void>('0xF6B9CE3F8D5B9B74', _h(scriptHash));
  }

  /**
   * Used in Script Function DISABLE_REGISTERED_WORLD_BRAINS
   *
   * @param p0 
   */
  static N_0x11B0A0B282FA9B10(p0: boolean): void {
    inv<void>('0x11B0A0B282FA9B10', p0);
  }

  /**
   * @param scriptHash 
   * @param stackSize 
   * @returns
   */
  static startNewScriptWithNameHash(scriptHash: string | number, stackSize: int): int {
    return inv<number>('0xEB1C67C3A5333A92', _h(scriptHash), stackSize, rai());
  }

  /**
   * @param threadId 
   * @returns
   */
  static getHashOfThread(threadId: int): number {
    return (inv<number>('0x724CB89D35B283D0', threadId, rai())) & 0xFFFFFFFF;
  }

  /**
   * @param nameHash 
   */
  static requestThreadExitForAllThreadsWithThisName(nameHash: string | number): void {
    inv<void>('0x7423F7835770F619', _h(nameHash));
  }

  /**
   * @param p0 
   * @param p1 
   */
  static N_0x1C5EB3C27F7508CB(p0: any, p1: any): void {
    inv<void>('0x1C5EB3C27F7508CB', p0, p1);
  }

  /**
   * goalContext: see _ACTIVATE_GOAL_CONTEXT
   *
   * @param goalContext 
   */
  static deactivateGoalContext(goalContext: string | number): void {
    inv<void>('0x50B72A754EE64A71', _h(goalContext));
  }

  /**
   * @param bailCode 
   */
  static bailToLandingPage(bailCode: int): void {
    inv<void>('0xBC2C927F5C264243', bailCode);
  }

  /**
   * @param index 
   * @returns
   */
  static storeGlobalBlock(index: int): any {
    return inv<number>('0xB952A3AC41D58F2F', index);
  }

  static N_0xF9E951A1E5517C06(): void {
    inv<void>('0xF9E951A1E5517C06');
  }

  /**
   * @returns
   */
  static getIdOfThisThread(): int {
    return inv<number>('0x55525C346BEF6960', rai());
  }

}