@nativewrappers/redm-codegen 0.0.2

package/dist/namespaces/Scripts.js

@@ -0,0 +1,716 @@
+import { inv, rai, ras, pvi, _h, f } from '../types/NativeAliases';
+export class Scripts {
+    /**
+     * @returns value
+     */
+    static countPlayerBits() {
+        const result = inv('0x462C687BEA254BD9', pvi(), rai());
+        return [result[0], result[1]];
+    }
+    /**
+     * @returns playerBits
+     */
+    static isAnyPlayerBitSet() {
+        const result = inv('0x179A6F0EE2E79026', pvi());
+        return [result[0], result[1]];
+    }
+    /**
+     * goalContext: see <availableContexts> in common/data/stats_and_challenges/goals_*.meta
+     *
+     * @param goalContext
+     */
+    static activateGoalContext(goalContext) {
+        inv('0x7D654266025E921B', _h(goalContext));
+    }
+    /**
+     * @param scriptName
+     * @param stackSize
+     * @returns
+     */
+    static startNewScript(scriptName, stackSize) {
+        return inv('0xE81651AD79516E48', scriptName, stackSize, rai());
+    }
+    /**
+     * @param awardHash
+     * @param itemIndex
+     * @returns rpcGuid; outResultItem
+     */
+    static awardsGetResultItem(awardHash, itemIndex) {
+        const result = inv('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() {
+        return inv('0x2238EC3EC631AB1F', rai());
+    }
+    /**
+     * Starts a new iteration of the current threads.
+     * Call this first, then SCRIPT_THREAD_ITERATOR_GET_NEXT_THREAD_ID (0x30B4FA1C82DD4B9F)
+     */
+    static scriptThreadIteratorReset() {
+        inv('0x39382EB8DCD8684D');
+    }
+    /**
+     * @param threadId
+     * @returns
+     */
+    static isBackgroundScript(threadId) {
+        return inv('0x20B7F69B40C6B755', threadId);
+    }
+    /**
+     * @param dataIndex
+     * @returns rpcGuid; outLootData
+     */
+    static lootGetLootClaimData(dataIndex) {
+        const result = inv('0xF1E9045F5AA9E428', pvi(), dataIndex, pvi(), rai());
+        return [!!result[0], result[1], result[2]];
+    }
+    /**
+     * @param scriptHash
+     * @returns
+     */
+    static doesScriptWithNameHashExist(scriptHash) {
+        return inv('0xA34E89749F628284', _h(scriptHash), rai());
+    }
+    /**
+     * @param p0
+     * @param p1
+     * @param p2
+     * @param gamemodeName
+     * @param title
+     * @param subtitle
+     */
+    static displayLoadingScreens(p0, p1, p2, gamemodeName, title, subtitle) {
+        inv('0x1E5B70E53DB661E5', _h(p0), _h(p1), _h(p2), gamemodeName, title, subtitle);
+    }
+    /**
+     * @param bitIndex
+     * @returns value
+     */
+    static clearPlayerBitAtIndex(bitIndex) {
+        const result = inv('0xD426E2E3288469D6', pvi(), bitIndex);
+        return result;
+    }
+    /**
+     * @param p0
+     */
+    static N_0x6F700A4BF7C3331B(p0) {
+        inv('0x6F700A4BF7C3331B', p0);
+    }
+    /**
+     * Inserts the given context into the background scripts context map.
+     *
+     * @param contextName
+     */
+    static bgStartContext(contextName) {
+        inv('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, argCount, stackSize) {
+        const result = inv('0xB8BA7F44DF1575E1', scriptName, pvi(), argCount, stackSize, rai());
+        return [result[0], result[1]];
+    }
+    /**
+     * @param threadId
+     * @returns
+     */
+    static doesThreadExist(threadId) {
+        return inv('0xFF975BC4435A0FA3', threadId);
+    }
+    /**
+     * 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) {
+        return inv('0x5CE8DE5909565748', eventGroup, rai());
+    }
+    static shutdownLoadingScreen() {
+        inv('0xFC179D7E8886DADF');
+    }
+    /**
+     * @param p0
+     * @returns
+     */
+    static N_0xE7282390542F570D(p0) {
+        return inv('0xE7282390542F570D', p0);
+    }
+    /**
+     * @param scriptIndex
+     * @param p1
+     * @returns
+     */
+    static bgGetLaunchParamValue(scriptIndex, p1) {
+        return inv('0x55C40B7592BAD213', scriptIndex, p1, rai());
+    }
+    /**
+     * @param p0
+     * @param p1
+     */
+    static N_0x1BDB5A07307F6929(p0, p1) {
+        inv('0x1BDB5A07307F6929', p0, p1);
+    }
+    /**
+     * @param index
+     * @returns
+     */
+    static doesCompressedGlobalBlockBufferExist(index) {
+        return inv('0x66EE5B93C308F734', index);
+    }
+    /**
+     * @param index
+     * @param toggle
+     */
+    static setGlobalBlockCanBeAccessed(index, toggle) {
+        inv('0xE66F392BFCE734AF', index, toggle);
+    }
+    /**
+     * @param p0
+     * @returns
+     */
+    static bgGetScriptIdFromNameHash(p0) {
+        return inv('0x829CD22E043A2577', _h(p0), rai());
+    }
+    /**
+     * @returns
+     */
+    static getNoLoadingScreen() {
+        return inv('0x323DAF00687E0F28', rai());
+    }
+    /**
+     * @param p0
+     * @param p1
+     * @returns
+     */
+    static N_0x0A79C81C418F5D38(p0, p1) {
+        return inv('0x0A79C81C418F5D38', p0, p1);
+    }
+    /**
+     * @param p0
+     * @returns
+     */
+    static N_0xA88E1D7FA1E20080(p0) {
+        return inv('0xA88E1D7FA1E20080', p0);
+    }
+    /**
+     * @param params
+     */
+    static bailWithPassThroughParams(params) {
+        inv('0xE98204D3C25AE14C', params);
+    }
+    /**
+     * If the function returns 0, the end of the iteration has been reached.
+     *
+     * @returns
+     */
+    static scriptThreadIteratorGetNextThreadId() {
+        return inv('0x3CE3FB167E837D7C', rai());
+    }
+    /**
+     * @param scriptHash
+     */
+    static setScriptWithNameHashAsNoLongerNeeded(scriptHash) {
+        inv('0x50723A1567C8361E', _h(scriptHash));
+    }
+    /**
+     * @param p1
+     * @returns value
+     */
+    static getBlockOfPlayerBits(p1) {
+        const result = inv('0xFA3B530A5CC693D5', pvi(), p1, rai());
+        return [result[0], result[1]];
+    }
+    /**
+     * Deletes the given context from the background scripts context map.
+     *
+     * @param contextName
+     */
+    static bgEndContext(contextName) {
+        inv('0x3ABF7BA1C3E2C8CF', contextName);
+    }
+    /**
+     * @param scriptHash
+     * @returns
+     */
+    static hasScriptWithNameHashLoaded(scriptHash) {
+        return inv('0xA5D8E0C2F3C7EEBC', _h(scriptHash), rai());
+    }
+    /**
+     * @param p0
+     */
+    static N_0x5827BE85A87B073D(p0) {
+        inv('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() {
+        return inv('0x54AE4FDEEFEAB77E', rai());
+    }
+    /**
+     * @param bitIndex
+     * @returns value
+     */
+    static setPlayerBitAtIndex(bitIndex) {
+        const result = inv('0x31010318BA9897AC', pvi(), bitIndex);
+        return result;
+    }
+    /**
+     * @returns value
+     */
+    static clearAllPlayerBits() {
+        const result = inv('0xDE544B7EC0C187CC', pvi());
+        return result;
+    }
+    /**
+     * @param itemIndex
+     * @returns rpcGuid; outResultItem
+     */
+    static lootGetResultItem(itemIndex) {
+        const result = inv('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) {
+        return inv('0xE97BD36574F8B0A6', scriptName, rai());
+    }
+    /**
+     * @param toggle
+     */
+    static setNoLoadingScreen(toggle) {
+        inv('0x5CB83156AA038F95', toggle);
+    }
+    /**
+     * @param scriptIndex
+     * @param p1
+     * @returns
+     */
+    static bgDoesLaunchParamExist(scriptIndex, p1) {
+        return inv('0x4AE1DFF337A86FDE', scriptIndex, p1, rai());
+    }
+    /**
+     * @param threadId
+     */
+    static requestThreadExit(threadId) {
+        inv('0x7DE4643157AD646C', threadId);
+    }
+    /**
+     * Hashed version of BG_END_CONTEXT
+     *
+     * @param contextHash
+     */
+    static bgEndContextHash(contextHash) {
+        inv('0x6D1431744182CDE8', _h(contextHash));
+    }
+    /**
+     * @param scriptName
+     * @returns
+     */
+    static doesScriptExist(scriptName) {
+        return inv('0x552B171E3F69E5AE', scriptName, rai());
+    }
+    /**
+     * @returns
+     */
+    static getHashOfThisScriptName() {
+        return (inv('0xBC2C927F5C264960', rai())) & 0xFFFFFFFF;
+    }
+    static bgReloadAllBackgroundScripts() {
+        inv('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, eventDataSize, scriptMetadataIndex) {
+        const result = inv('0x5AE99C571D5BBE5D', eventGroup, pvi(), eventDataSize, scriptMetadataIndex, pvi());
+        return [result[0], result[1]];
+    }
+    /**
+     * goalContext: see _ACTIVATE_GOAL_CONTEXT
+     *
+     * @param goalContext
+     * @returns
+     */
+    static isGoalContextActive(goalContext) {
+        return inv('0x7409669C5ED50144', _h(goalContext));
+    }
+    /**
+     * @param scriptName
+     */
+    static setScriptAsNoLongerNeeded(scriptName) {
+        inv('0x0086D3067E1CFD1C', scriptName);
+    }
+    /**
+     * @returns p0; p1; p2
+     */
+    static N_0x64F765D9A1F8F02C() {
+        const result = inv('0x64F765D9A1F8F02C', pvi(), pvi(), pvi());
+        return [result[0], result[1], result[2]];
+    }
+    /**
+     * @param scriptName
+     */
+    static requestScript(scriptName) {
+        inv('0x46ED607DDD40D7FE', scriptName);
+    }
+    /**
+     * @param toggle
+     */
+    static setAllGlobalBlocksHaveBeenLoaded(toggle) {
+        inv('0x11986B05885564D2', toggle);
+    }
+    /**
+     * Returns "INVALID_NET_RPC_GUID" if netRpcGuid is invalid.
+     *
+     * @returns netRpcGuid
+     */
+    static netRpcGuidToString() {
+        const result = inv('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, eventIndex) {
+        return (inv('0xA85E614430EFF816', eventGroup, eventIndex, rai())) & 0xFFFFFFFF;
+    }
+    /**
+     * @param scriptHash
+     * @param argCount
+     * @param stackSize
+     * @returns args
+     */
+    static startNewScriptWithNameHashAndArgs(scriptHash, argCount, stackSize) {
+        const result = inv('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, eventType) {
+        return inv('0xC9F59C0A710ECD34', eventGroup, _h(eventType), rai());
+    }
+    /**
+     * @param index
+     * @returns
+     */
+    static getGlobalBlockCanBeAccessed(index) {
+        return inv('0x42A7EB5C814C2DE0', index, rai());
+    }
+    /**
+     * @returns
+     */
+    static isThreadExitRequested() {
+        return inv('0x9E4EF615E307FBBE');
+    }
+    static terminateThisThread() {
+        inv('0x5E8B6D17FF91CD59');
+    }
+    static N_0x76CBCD9EADC00955() {
+        inv('0x76CBCD9EADC00955');
+    }
+    /**
+     * @param p0
+     * @param p1
+     * @param p2
+     * @param p3
+     * @param p4
+     * @param p5
+     * @param p6
+     * @param p7
+     */
+    static N_0x29FB4CE89472C3CB(p0, p1, p2, p3, p4, p5, p6, p7) {
+        inv('0x29FB4CE89472C3CB', p0, p1, f(p2), f(p3), p4, p5, p6, p7);
+    }
+    /**
+     * @param threadId
+     */
+    static terminateThread(threadId) {
+        inv('0x87ED52AE40EA1A52', threadId);
+    }
+    /**
+     * @param eventDataSize
+     * @param scriptMetadataIndex
+     * @param threadId
+     * @returns eventData
+     */
+    static triggerScriptEvent2(eventDataSize, scriptMetadataIndex, threadId) {
+        const result = inv('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) {
+        return inv('0x8E34C953364A76DD', _h(scriptHash), rai());
+    }
+    /**
+     * Waiting for child scripts to terminate / waiting for collapse of child scripts
+     *
+     * @param p0
+     * @returns
+     */
+    static haveAllChildScriptsTerminated(p0) {
+        return inv('0x380FFA15B72408FB', p0);
+    }
+    /**
+     * @param p0
+     * @param p1
+     * @param p2
+     */
+    static N_0xFFDDF802279BE128(p0, p1, p2) {
+        inv('0xFFDDF802279BE128', p0, p1, p2);
+    }
+    /**
+     * @param bitIndex
+     * @returns value
+     */
+    static isPlayerBitSetAtIndex(bitIndex) {
+        const result = inv('0x72B2E00C9BAC6789', pvi(), bitIndex, rai());
+        return [!!result[0], result[1]];
+    }
+    /**
+     * @returns value
+     */
+    static setAllPlayerBits() {
+        const result = inv('0x20F4CB76689ACDBC', pvi());
+        return result;
+    }
+    /**
+     * Sets bit 0 in GtaThread+0x784
+     */
+    static bgSetExitflagResponse() {
+        inv('0x4858148E3B8A75D0');
+    }
+    /**
+     * @returns value
+     */
+    static countParticipantBits() {
+        const result = inv('0x2F050A3FF8738245', pvi(), rai());
+        return [result[0], result[1]];
+    }
+    /**
+     * Same as GET_IS_LOADING_SCREEN_ACTIVE
+     *
+     * @returns
+     */
+    static isLoadingScreenVisible() {
+        return inv('0xB54ADBE65D528FCB', rai());
+    }
+    /**
+     * @param p0
+     * @param p1
+     * @param p2
+     */
+    static N_0xE4ABE20DCE7C7CFE(p0, p1, p2) {
+        inv('0xE4ABE20DCE7C7CFE', p0, p1, p2);
+    }
+    /**
+     * @param p1
+     * @param p2
+     * @returns value
+     */
+    static setBlockOfPlayerBits(p1, p2) {
+        const result = inv('0xC6DFB8C04C86D5A5', pvi(), p1, p2);
+        return result;
+    }
+    /**
+     * Hashed version of BG_START_CONTEXT
+     *
+     * @param contextHash
+     */
+    static bgStartContextHash(contextHash) {
+        inv('0x2EB67D564DCC09D5', _h(contextHash));
+    }
+    /**
+     * @param threadId
+     * @returns
+     */
+    static isThreadExitRequestedForThreadWithThisId(threadId) {
+        return inv('0x30BED53646C86D11', threadId);
+    }
+    /**
+     * @param index
+     * @returns
+     */
+    static restoreGlobalBlock(index) {
+        return inv('0xDC3914A99B4A5FDF', index);
+    }
+    /**
+     * @param eventGroup
+     * @param eventIndex
+     * @param p2
+     */
+    static setEventFlagForDeletion(eventGroup, eventIndex, p2) {
+        inv('0x4768D5252EAEB76F', eventGroup, eventIndex, p2);
+    }
+    /**
+     * @param threadId
+     * @returns threadExists; hasScriptHandler
+     */
+    static getThreadExistenceDetails(threadId) {
+        const result = inv('0xD92FA81B64920E85', threadId, pvi(), pvi());
+        return [!!result[0], !!result[1]];
+    }
+    /**
+     * @param p0
+     * @param p1
+     * @param p2
+     */
+    static N_0x42A429CDFED6D99D(p0, p1, p2) {
+        inv('0x42A429CDFED6D99D', p0, p1, p2);
+    }
+    /**
+     * @param p0
+     */
+    static stopDisplayingMpTransitionLoadingScreens(p0) {
+        inv('0x778D4733E0F2F265', p0);
+    }
+    /**
+     * @param threadId
+     * @param ignoreKilledState
+     * @returns
+     */
+    static isThreadActive(threadId, ignoreKilledState) {
+        return inv('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, eventIndex, eventDataSize) {
+        const result = inv('0x57EC5FA4D4D6AFCA', eventGroup, eventIndex, pvi(), eventDataSize, rai());
+        return [!!result[0], result[1]];
+    }
+    /**
+     * @param awardHash
+     * @param dataIndex
+     * @returns rpcGuid; outUnlockData
+     */
+    static awardsGetUnlockClaimData(awardHash, dataIndex) {
+        const result = inv('0xB9467E41DAB1CF2C', pvi(), _h(awardHash), dataIndex, pvi());
+        return [result[0], result[1], result[2]];
+    }
+    /**
+     * @param scriptHash
+     */
+    static requestScriptWithNameHash(scriptHash) {
+        inv('0xF6B9CE3F8D5B9B74', _h(scriptHash));
+    }
+    /**
+     * Used in Script Function DISABLE_REGISTERED_WORLD_BRAINS
+     *
+     * @param p0
+     */
+    static N_0x11B0A0B282FA9B10(p0) {
+        inv('0x11B0A0B282FA9B10', p0);
+    }
+    /**
+     * @param scriptHash
+     * @param stackSize
+     * @returns
+     */
+    static startNewScriptWithNameHash(scriptHash, stackSize) {
+        return inv('0xEB1C67C3A5333A92', _h(scriptHash), stackSize, rai());
+    }
+    /**
+     * @param threadId
+     * @returns
+     */
+    static getHashOfThread(threadId) {
+        return (inv('0x724CB89D35B283D0', threadId, rai())) & 0xFFFFFFFF;
+    }
+    /**
+     * @param nameHash
+     */
+    static requestThreadExitForAllThreadsWithThisName(nameHash) {
+        inv('0x7423F7835770F619', _h(nameHash));
+    }
+    /**
+     * @param p0
+     * @param p1
+     */
+    static N_0x1C5EB3C27F7508CB(p0, p1) {
+        inv('0x1C5EB3C27F7508CB', p0, p1);
+    }
+    /**
+     * goalContext: see _ACTIVATE_GOAL_CONTEXT
+     *
+     * @param goalContext
+     */
+    static deactivateGoalContext(goalContext) {
+        inv('0x50B72A754EE64A71', _h(goalContext));
+    }
+    /**
+     * @param bailCode
+     */
+    static bailToLandingPage(bailCode) {
+        inv('0xBC2C927F5C264243', bailCode);
+    }
+    /**
+     * @param index
+     * @returns
+     */
+    static storeGlobalBlock(index) {
+        return inv('0xB952A3AC41D58F2F', index);
+    }
+    static N_0xF9E951A1E5517C06() {
+        inv('0xF9E951A1E5517C06');
+    }
+    /**
+     * @returns
+     */
+    static getIdOfThisThread() {
+        return inv('0x55525C346BEF6960', rai());
+    }
+}