/**
 * @file lscript_execute.cpp
 * @brief classes to execute bytecode
 *
 * Copyright (c) 2002-$CurrentYear$, Linden Research, Inc.
 * $License$
 */

#include "linden_common.h"

#include <sstream>

#include "lscript_execute.h"
#include "lltimer.h"
#include "lscript_readlso.h"
#include "lscript_library.h"
#include "lscript_heapruntime.h"
#include "lscript_alloc.h"

void (*binary_operations[LST_EOF][LST_EOF])(U8 *buffer, LSCRIPTOpCodesEnum opcode);
void (*unary_operations[LST_EOF])(U8 *buffer, LSCRIPTOpCodesEnum opcode);

char* LSCRIPTRunTimeFaultStrings[LSRF_EOF] =		/*Flawfinder: ignore*/
{
	"invalid",				//	LSRF_INVALID,
	"Math Error",			//	LSRF_MATH,
	"Stack-Heap Collision",	//	LSRF_STACK_HEAP_COLLISION,
	"Bounds Check Error",	//	LSRF_BOUND_CHECK_ERROR,
	"Heap Error",			//	LSRF_HEAP_ERROR,
	"Version Mismatch",		//	LSRF_VERSION_MISMATCH,
	"Missing Inventory",	//	LSRF_MISSING_INVENTORY,
	"Hit Sandbox Limit",	//	LSRF_SANDBOX,
	"Chat Overrun",			//	LSRF_CHAT_OVERRUN,
	"Too Many Listens",			  //	LSRF_TOO_MANY_LISTENS,
	"Lists may not contain lists" //	LSRF_NESTING_LISTS,
};

//static
S64 LLScriptExecute::sGlobalInstructionCount = 0;

LLScriptExecute::LLScriptExecute(FILE *fp)
{
	U8  sizearray[4];
	S32 filesize;
	S32 pos = 0;
	if (fread(&sizearray, 1, 4, fp) != 4)
	{
		llwarns << "Short read" << llendl;
		filesize = 0;
	} else {
		filesize = bytestream2integer(sizearray, pos);
	}
	mBuffer = new U8[filesize];
	fseek(fp, 0, SEEK_SET);
	if (fread(mBuffer, 1, filesize, fp) != filesize)
	{
		llwarns << "Short read" << llendl;
	}
	fclose(fp);

	init();
}

LLScriptExecute::LLScriptExecute(U8 *buffer)
{
	mBuffer = buffer;

	init();
}

LLScriptExecute::~LLScriptExecute()
{
	delete [] mBuffer;
}

void LLScriptExecute::init()
{
	S32 i, j;

	mInstructionCount = 0;

	for (i = 0; i < 256; i++)
	{
		mExecuteFuncs[i] = run_noop;
	}
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_NOOP]] = run_noop;

	mExecuteFuncs[LSCRIPTOpCodes[LOPC_POP]] = run_pop;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_POPS]] = run_pops;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_POPL]] = run_popl;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_POPV]] = run_popv;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_POPQ]] = run_popq;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_POPARG]] = run_poparg;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_POPIP]] = run_popip;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_POPBP]] = run_popbp;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_POPSP]] = run_popsp;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_POPSLR]] = run_popslr;

	mExecuteFuncs[LSCRIPTOpCodes[LOPC_DUP]] = run_dup;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_DUPS]] = run_dups;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_DUPL]] = run_dupl;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_DUPV]] = run_dupv;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_DUPQ]] = run_dupq;

	mExecuteFuncs[LSCRIPTOpCodes[LOPC_STORE]] = run_store;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_STORES]] = run_stores;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_STOREL]] = run_storel;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_STOREV]] = run_storev;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_STOREQ]] = run_storeq;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_STOREG]] = run_storeg;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_STOREGL]] = run_storegl;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_STOREGS]] = run_storegs;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_STOREGV]] = run_storegv;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_STOREGQ]] = run_storegq;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_LOADP]] = run_loadp;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_LOADSP]] = run_loadsp;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_LOADLP]] = run_loadlp;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_LOADVP]] = run_loadvp;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_LOADQP]] = run_loadqp;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_LOADGP]] = run_loadgp;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_LOADGSP]] = run_loadgsp;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_LOADGLP]] = run_loadglp;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_LOADGVP]] = run_loadgvp;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_LOADGQP]] = run_loadgqp;

	mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSH]] = run_push;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHS]] = run_pushs;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHL]] = run_pushl;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHV]] = run_pushv;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHQ]] = run_pushq;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHG]] = run_pushg;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHGS]] = run_pushgs;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHGL]] = run_pushgl;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHGV]] = run_pushgv;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHGQ]] = run_pushgq;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHIP]] = run_puship;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHSP]] = run_pushsp;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHBP]] = run_pushbp;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHARGB]] = run_pushargb;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHARGI]] = run_pushargi;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHARGF]] = run_pushargf;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHARGS]] = run_pushargs;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHARGV]] = run_pushargv;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHARGQ]] = run_pushargq;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHE]] = run_pushe;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHEV]] = run_pushev;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHEQ]] = run_pusheq;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHARGE]] = run_pusharge;

	mExecuteFuncs[LSCRIPTOpCodes[LOPC_ADD]] = run_add;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_SUB]] = run_sub;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_MUL]] = run_mul;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_DIV]] = run_div;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_MOD]] = run_mod;

	mExecuteFuncs[LSCRIPTOpCodes[LOPC_EQ]] = run_eq;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_NEQ]] = run_neq;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_LEQ]] = run_leq;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_GEQ]] = run_geq;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_LESS]] = run_less;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_GREATER]] = run_greater;

	mExecuteFuncs[LSCRIPTOpCodes[LOPC_BITAND]] = run_bitand;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_BITOR]] = run_bitor;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_BITXOR]] = run_bitxor;

	mExecuteFuncs[LSCRIPTOpCodes[LOPC_BOOLAND]] = run_booland;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_BOOLOR]] = run_boolor;

	mExecuteFuncs[LSCRIPTOpCodes[LOPC_SHL]] = run_shl;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_SHR]] = run_shr;

	mExecuteFuncs[LSCRIPTOpCodes[LOPC_NEG]] = run_neg;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_BITNOT]] = run_bitnot;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_BOOLNOT]] = run_boolnot;

	mExecuteFuncs[LSCRIPTOpCodes[LOPC_JUMP]] = run_jump;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_JUMPIF]] = run_jumpif;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_JUMPNIF]] = run_jumpnif;

	mExecuteFuncs[LSCRIPTOpCodes[LOPC_STATE]] = run_state;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_CALL]] = run_call;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_RETURN]] = run_return;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_CAST]] = run_cast;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_STACKTOS]] = run_stacktos;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_STACKTOL]] = run_stacktol;

	mExecuteFuncs[LSCRIPTOpCodes[LOPC_PRINT]] = run_print;

	mExecuteFuncs[LSCRIPTOpCodes[LOPC_CALLLIB]] = run_calllib;
	mExecuteFuncs[LSCRIPTOpCodes[LOPC_CALLLIB_TWO_BYTE]] = run_calllib_two_byte;

	for (i = 0; i < LST_EOF; i++)
	{
		for (j = 0; j < LST_EOF; j++)
		{
			binary_operations[i][j] = unknown_operation;
		}
	}

	binary_operations[LST_INTEGER][LST_INTEGER] = integer_integer_operation;
	binary_operations[LST_INTEGER][LST_FLOATINGPOINT] = integer_float_operation;
	binary_operations[LST_INTEGER][LST_VECTOR] = integer_vector_operation;

	binary_operations[LST_FLOATINGPOINT][LST_INTEGER] = float_integer_operation;
	binary_operations[LST_FLOATINGPOINT][LST_FLOATINGPOINT] = float_float_operation;
	binary_operations[LST_FLOATINGPOINT][LST_VECTOR] = float_vector_operation;

	binary_operations[LST_STRING][LST_STRING] = string_string_operation;
	binary_operations[LST_STRING][LST_KEY] = string_key_operation;

	binary_operations[LST_KEY][LST_STRING] = key_string_operation;
	binary_operations[LST_KEY][LST_KEY] = key_key_operation;

	binary_operations[LST_VECTOR][LST_INTEGER] = vector_integer_operation;
	binary_operations[LST_VECTOR][LST_FLOATINGPOINT] = vector_float_operation;
	binary_operations[LST_VECTOR][LST_VECTOR] = vector_vector_operation;
	binary_operations[LST_VECTOR][LST_QUATERNION] = vector_quaternion_operation;

	binary_operations[LST_QUATERNION][LST_QUATERNION] = quaternion_quaternion_operation;

	binary_operations[LST_INTEGER][LST_LIST] = integer_list_operation;
	binary_operations[LST_FLOATINGPOINT][LST_LIST] = float_list_operation;
	binary_operations[LST_STRING][LST_LIST] = string_list_operation;
	binary_operations[LST_KEY][LST_LIST] = key_list_operation;
	binary_operations[LST_VECTOR][LST_LIST] = vector_list_operation;
	binary_operations[LST_QUATERNION][LST_LIST] = quaternion_list_operation;
	binary_operations[LST_LIST][LST_INTEGER] = list_integer_operation;
	binary_operations[LST_LIST][LST_FLOATINGPOINT] = list_float_operation;
	binary_operations[LST_LIST][LST_STRING] = list_string_operation;
	binary_operations[LST_LIST][LST_KEY] = list_key_operation;
	binary_operations[LST_LIST][LST_VECTOR] = list_vector_operation;
	binary_operations[LST_LIST][LST_QUATERNION] = list_quaternion_operation;
	binary_operations[LST_LIST][LST_LIST] = list_list_operation;

	for (i = 0; i < LST_EOF; i++)
	{
		unary_operations[i] = unknown_operation;
	}

	unary_operations[LST_INTEGER] = integer_operation;
	unary_operations[LST_FLOATINGPOINT] = float_operation;
	unary_operations[LST_VECTOR] = vector_operation;
	unary_operations[LST_QUATERNION] = quaternion_operation;

}

S32 lscript_push_variable(LLScriptLibData *data, U8 *buffer);

U32 LLScriptExecute::run(BOOL b_print, const LLUUID &id, char **errorstr, BOOL &state_transition)
{
	//  is there a fault?
	//	if yes, print out message and exit
	state_transition = FALSE;
	S32 value = get_register(mBuffer, LREG_VN);
	S32 major_version = 0;
	if (value == LSL2_VERSION1_END_NUMBER)
	{
		major_version = 1;
	}
	else if (value == LSL2_VERSION_NUMBER)
	{
		major_version = 2;
	}
	else
	{
		set_fault(mBuffer, LSRF_VERSION_MISMATCH);
	}
	value = get_register(mBuffer, LREG_FR);
	if (value)
	{
		if (b_print)
		{
			printf("Error!\n");
		}
		*errorstr = LSCRIPTRunTimeFaultStrings[value];
		return NO_DELETE_FLAG;
	}
	else
	{
		*errorstr = NULL;
	}

	//  Get IP
	//  is IP nonzero?
	value = get_register(mBuffer, LREG_IP);

	if (value)
	{
	//	if yes, we're in opcodes, execute the next opcode by:
	//	call opcode run function pointer with buffer and IP
		mInstructionCount++;
		sGlobalInstructionCount++;
		S32 tvalue = value;
		S32	opcode = safe_instruction_bytestream2byte(mBuffer, tvalue);
		S32 b_ret_val = mExecuteFuncs[opcode](mBuffer, value, b_print, id);
		set_ip(mBuffer, value);
		add_register_fp(mBuffer, LREG_ESR, -0.1f);
	//	lsa_print_heap(mBuffer);

		if (b_print)
		{
			lsa_print_heap(mBuffer);
			printf("ip: 0x%X\n", get_register(mBuffer, LREG_IP));
			printf("sp: 0x%X\n", get_register(mBuffer, LREG_SP));
			printf("bp: 0x%X\n", get_register(mBuffer, LREG_BP));
			printf("hr: 0x%X\n", get_register(mBuffer, LREG_HR));
			printf("hp: 0x%X\n", get_register(mBuffer, LREG_HP));
		}
	//			update IP
		if (b_ret_val)
		{
			return DELETE_FLAG | CREDIT_MONEY_FLAG;
		}
		else
		{
			return NO_DELETE_FLAG;
		}
	}
	else
	{
		// make sure that IE is zero
		set_event_register(mBuffer, LREG_IE, 0, major_version);

	//	if no, we're in a state and waiting for an event
		S32 next_state = get_register(mBuffer, LREG_NS);
		S32 current_state = get_register(mBuffer, LREG_CS);
		U64 current_events = get_event_register(mBuffer, LREG_CE, major_version);
		U64 event_register = get_event_register(mBuffer, LREG_ER, major_version);
	//	check NS to see if need to switch states (NS != CS)
		if (next_state != current_state)
		{
			state_transition = TRUE;
			// ok, blow away any pending events
			mEventData.mEventDataList.deleteAllData();

	//		if yes, check state exit flag is set
			if (current_events & LSCRIPTStateBitField[LSTT_STATE_EXIT])
			{
	//			if yes, clear state exit flag
				set_event_register(mBuffer, LREG_IE, LSCRIPTStateBitField[LSTT_STATE_EXIT], major_version);
				current_events &= ~LSCRIPTStateBitField[LSTT_STATE_EXIT];
				set_event_register(mBuffer, LREG_CE, current_events, major_version);
	//			check state exit event handler
	//				if there is a handler, call it
				if (event_register & LSCRIPTStateBitField[LSTT_STATE_EXIT])
				{
		//			push a zero to be popped
					lscript_push(mBuffer, 0);
		//			push sp as current bp
					S32 sp = get_register(mBuffer, LREG_SP);
					lscript_push(mBuffer, sp);

		//			now, push any additional stack space
					S32 additional_size = get_event_stack_size(mBuffer, current_state, LSTT_STATE_EXIT);
					lscript_pusharge(mBuffer, additional_size);

					sp = get_register(mBuffer, LREG_SP);
					sp += additional_size;
					set_bp(mBuffer, sp);
	//				set IP to the event handler
					S32			opcode_start = get_state_event_opcoode_start(mBuffer, current_state, LSTT_STATE_EXIT);
					set_ip(mBuffer, opcode_start);
					return NO_DELETE_FLAG;
				}
			}
	//		if no handler or no state exit flag switch to new state
	//		set state entry flag and clear other CE flags
			current_events = LSCRIPTStateBitField[LSTT_STATE_ENTRY];
			set_event_register(mBuffer, LREG_CE, current_events, major_version);
	//		copy NS to CS
			set_register(mBuffer, LREG_CS, next_state);
	//		copy new state's handled events into ER (SR + CS*4 + 4)
			U64 handled_events = get_handled_events(mBuffer, next_state);
			set_event_register(mBuffer, LREG_ER, handled_events, major_version);
		}
//		check to see if any current events are covered by events handled by this state (CE & ER != 0)
// now, we want to look like we were called like a function
//		0x0000:		00 00 00 00 (return ip)
//		0x0004:		bp			(current sp)
//		0x0008:		parameters
//		push sp
//		add parameter size
//		pop bp
//		set ip

		S32 size = 0;
//			try to get next event from stack
		BOOL b_done = FALSE;
		LSCRIPTStateEventType event = LSTT_NULL;
		LLScriptDataCollection *eventdata;

		next_state = get_register(mBuffer, LREG_NS);
		current_state = get_register(mBuffer, LREG_CS);
		current_events = get_event_register(mBuffer, LREG_CE, major_version);
		event_register = get_event_register(mBuffer, LREG_ER, major_version);

		// first, check to see if state_entry or onrez are raised and handled
		if (  (current_events & LSCRIPTStateBitField[LSTT_STATE_ENTRY])
			&&(current_events & event_register))
		{
			// ok, this is easy since there isn't any data waiting, just set it
			//			push a zero to be popped
			lscript_push(mBuffer, 0);
//			push sp as current bp
			S32 sp = get_register(mBuffer, LREG_SP);
			lscript_push(mBuffer, sp);

			event = return_first_event((S32)LSCRIPTStateBitField[LSTT_STATE_ENTRY]);
			set_event_register(mBuffer, LREG_IE, LSCRIPTStateBitField[event], major_version);
			current_events &= ~LSCRIPTStateBitField[event];
			set_event_register(mBuffer, LREG_CE, current_events, major_version);
//			now, push any additional stack space
			S32 additional_size = get_event_stack_size(mBuffer, current_state, event) - size;
			lscript_pusharge(mBuffer, additional_size);

//			now set the bp correctly
			sp = get_register(mBuffer, LREG_SP);
			sp += additional_size + size;
			set_bp(mBuffer, sp);
//			set IP to the function
			S32			opcode_start = get_state_event_opcoode_start(mBuffer, current_state, event);
			set_ip(mBuffer, opcode_start);
			b_done = TRUE;
		}
		else if (  (current_events & LSCRIPTStateBitField[LSTT_REZ])
				 &&(current_events & event_register))
		{
			for (eventdata = mEventData.mEventDataList.getFirstData(); eventdata; eventdata = mEventData.mEventDataList.getNextData())
			{
				if (eventdata->mType & LSCRIPTStateBitField[LSTT_REZ])
				{
					//			push a zero to be popped
					lscript_push(mBuffer, 0);
		//			push sp as current bp
					S32 sp = get_register(mBuffer, LREG_SP);
					lscript_push(mBuffer, sp);

					set_event_register(mBuffer, LREG_IE, LSCRIPTStateBitField[event], major_version);
					current_events &= ~LSCRIPTStateBitField[event];
					set_event_register(mBuffer, LREG_CE, current_events, major_version);

	//				push any arguments that need to be pushed onto the stack
					// last piece of data will be type LST_NULL
					LLScriptLibData	*data = eventdata->mData;
					while (data->mType)
					{
						size += lscript_push_variable(data, mBuffer);
						data++;
					}
		//			now, push any additional stack space
					S32 additional_size = get_event_stack_size(mBuffer, current_state, event) - size;
					lscript_pusharge(mBuffer, additional_size);

		//			now set the bp correctly
					sp = get_register(mBuffer, LREG_SP);
					sp += additional_size + size;
					set_bp(mBuffer, sp);
		//			set IP to the function
					S32			opcode_start = get_state_event_opcoode_start(mBuffer, current_state, event);
					set_ip(mBuffer, opcode_start);
					mEventData.mEventDataList.deleteCurrentData();
					b_done = TRUE;
					break;
				}
			}
		}

		while (!b_done)
		{
			eventdata = mEventData.getNextEvent();
			if (eventdata)
			{
				event = eventdata->mType;

				// make sure that we can actually handle this one
				if (LSCRIPTStateBitField[event] & event_register)
				{
					//			push a zero to be popped
					lscript_push(mBuffer, 0);
		//			push sp as current bp
					S32 sp = get_register(mBuffer, LREG_SP);
					lscript_push(mBuffer, sp);

					set_event_register(mBuffer, LREG_IE, LSCRIPTStateBitField[event], major_version);
					current_events &= ~LSCRIPTStateBitField[event];
					set_event_register(mBuffer, LREG_CE, current_events, major_version);

	//				push any arguments that need to be pushed onto the stack
					// last piece of data will be type LST_NULL
					LLScriptLibData	*data = eventdata->mData;
					while (data->mType)
					{
						size += lscript_push_variable(data, mBuffer);
						data++;
					}
					b_done = TRUE;
		//			now, push any additional stack space
					S32 additional_size = get_event_stack_size(mBuffer, current_state, event) - size;
					lscript_pusharge(mBuffer, additional_size);

		//			now set the bp correctly
					sp = get_register(mBuffer, LREG_SP);
					sp += additional_size + size;
					set_bp(mBuffer, sp);
		//			set IP to the function
					S32			opcode_start = get_state_event_opcoode_start(mBuffer, current_state, event);
					set_ip(mBuffer, opcode_start);
				}
				else
				{
					llwarns << "Shit, somehow got an event that we're not registered for!" << llendl;
				}
				delete eventdata;
			}
			else
			{
//				if no data waiting, do it the old way:
				U64 handled_current = current_events & event_register;
				if (handled_current)
				{
					//			push a zero to be popped
					lscript_push(mBuffer, 0);
		//			push sp as current bp
					S32 sp = get_register(mBuffer, LREG_SP);
					lscript_push(mBuffer, sp);

					event = return_first_event((S32)handled_current);
					set_event_register(mBuffer, LREG_IE, LSCRIPTStateBitField[event], major_version);
					current_events &= ~LSCRIPTStateBitField[event];
					set_event_register(mBuffer, LREG_CE, current_events, major_version);
		//			now, push any additional stack space
					S32 additional_size = get_event_stack_size(mBuffer, current_state, event) - size;
					lscript_pusharge(mBuffer, additional_size);

		//			now set the bp correctly
					sp = get_register(mBuffer, LREG_SP);
					sp += additional_size + size;
					set_bp(mBuffer, sp);
		//			set IP to the function
					S32			opcode_start = get_state_event_opcoode_start(mBuffer, current_state, event);
					set_ip(mBuffer, opcode_start);
				}
				b_done = TRUE;
			}
		}

		return NO_DELETE_FLAG;
	}
}

BOOL run_noop(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tNOOP\n", offset);
	offset++;
	return FALSE;
}

BOOL run_pop(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPOP\n", offset);
	offset++;
	lscript_poparg(buffer, LSCRIPTDataSize[LST_INTEGER]);
	return FALSE;
}

BOOL run_pops(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPOPS\n", offset);
	offset++;
	S32 address = lscript_pop_int(buffer);
	if (address)
		lsa_decrease_ref_count(buffer, address);
	return FALSE;
}

BOOL run_popl(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPOPL\n", offset);
	offset++;
	S32 address = lscript_pop_int(buffer);
	if (address)
		lsa_decrease_ref_count(buffer, address);
	return FALSE;
}

BOOL run_popv(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPOPV\n", offset);
	offset++;
	lscript_poparg(buffer, LSCRIPTDataSize[LST_VECTOR]);
	return FALSE;
}

BOOL run_popq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPOPQ\n", offset);
	offset++;
	lscript_poparg(buffer, LSCRIPTDataSize[LST_QUATERNION]);
	return FALSE;
}

BOOL run_poparg(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPOPARG ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("%d\n", arg);
	lscript_poparg(buffer, arg);
	return FALSE;
}

BOOL run_popip(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPOPIP\n", offset);
	offset++;
	offset = lscript_pop_int(buffer);
	return FALSE;
}

BOOL run_popbp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPOPBP\n", offset);
	offset++;
	S32 bp = lscript_pop_int(buffer);
	set_bp(buffer, bp);
	return FALSE;
}

BOOL run_popsp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPOPSP\n", offset);
	offset++;
	S32 sp = lscript_pop_int(buffer);
	set_sp(buffer, sp);
	return FALSE;
}

BOOL run_popslr(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPOPSLR\n", offset);
	offset++;
	S32 slr = lscript_pop_int(buffer);
	set_register(buffer, LREG_SLR, slr);
	return FALSE;
}

BOOL run_dup(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tDUP\n", offset);
	offset++;
	S32 sp = get_register(buffer, LREG_SP);
	S32 value = bytestream2integer(buffer, sp);
	lscript_push(buffer, value);
	return FALSE;
}

BOOL run_dups(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tDUPS\n", offset);
	offset++;
	S32 sp = get_register(buffer, LREG_SP);
	S32 value = bytestream2integer(buffer, sp);
	lscript_push(buffer, value);
	lsa_increase_ref_count(buffer, value);
	return FALSE;
}

BOOL run_dupl(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tDUPL\n", offset);
	offset++;
	S32 sp = get_register(buffer, LREG_SP);
	S32 value = bytestream2integer(buffer, sp);
	lscript_push(buffer, value);
	lsa_increase_ref_count(buffer, value);
	return FALSE;
}

BOOL run_dupv(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tDUPV\n", offset);
	offset++;
	S32 sp = get_register(buffer, LREG_SP);
	LLVector3 value;
	bytestream2vector(value, buffer, sp);
	lscript_push(buffer, value);
	return FALSE;
}

BOOL run_dupq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tDUPV\n", offset);
	offset++;
	S32 sp = get_register(buffer, LREG_SP);
	LLQuaternion value;
	bytestream2quaternion(value, buffer, sp);
	lscript_push(buffer, value);
	return FALSE;
}

BOOL run_store(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tSTORE ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("0x%X\n", arg);
	S32 sp = get_register(buffer, LREG_SP);
	S32 value = bytestream2integer(buffer, sp);
	lscript_local_store(buffer, arg, value);
	return FALSE;
}

BOOL run_stores(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tSTORES ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("0x%X\n", arg);
	S32 sp = get_register(buffer, LREG_SP);
	S32 value = bytestream2integer(buffer, sp);

	S32 address = lscript_local_get(buffer, arg);

	lscript_local_store(buffer, arg, value);
	lsa_increase_ref_count(buffer, value);
	if (address)
		lsa_decrease_ref_count(buffer, address);
	return FALSE;
}

BOOL run_storel(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tSTOREL ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("0x%X\n", arg);
	S32 sp = get_register(buffer, LREG_SP);
	S32 value = bytestream2integer(buffer, sp);

	S32 address = lscript_local_get(buffer, arg);

	lscript_local_store(buffer, arg, value);
	lsa_increase_ref_count(buffer, value);
	if (address)
		lsa_decrease_ref_count(buffer, address);
	return FALSE;
}

BOOL run_storev(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tSTOREV ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("0x%X\n", arg);
	LLVector3 value;
	S32 sp = get_register(buffer, LREG_SP);
	bytestream2vector(value, buffer, sp);
	lscript_local_store(buffer, arg, value);
	return FALSE;
}

BOOL run_storeq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tSTOREQ ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("0x%X\n", arg);
	LLQuaternion value;
	S32 sp = get_register(buffer, LREG_SP);
	bytestream2quaternion(value, buffer, sp);
	lscript_local_store(buffer, arg, value);
	return FALSE;
}

BOOL run_storeg(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tSTOREG ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("0x%X\n", arg);
	S32 sp = get_register(buffer, LREG_SP);
	S32 value = bytestream2integer(buffer, sp);
	lscript_global_store(buffer, arg, value);
	return FALSE;
}

BOOL run_storegs(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tSTOREGS ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("0x%X\n", arg);
	S32 sp = get_register(buffer, LREG_SP);
	S32 value = bytestream2integer(buffer, sp);

	S32 address = lscript_global_get(buffer, arg);

	lscript_global_store(buffer, arg, value);

	lsa_increase_ref_count(buffer, value);
	if (address)
		lsa_decrease_ref_count(buffer, address);
	return FALSE;
}

BOOL run_storegl(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tSTOREGL ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("0x%X\n", arg);
	S32 sp = get_register(buffer, LREG_SP);
	S32 value = bytestream2integer(buffer, sp);

	S32 address = lscript_global_get(buffer, arg);

	lscript_global_store(buffer, arg, value);

	lsa_increase_ref_count(buffer, value);
	if (address)
		lsa_decrease_ref_count(buffer, address);
	return FALSE;
}

BOOL run_storegv(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tSTOREGV ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("0x%X\n", arg);
	LLVector3 value;
	S32 sp = get_register(buffer, LREG_SP);
	bytestream2vector(value, buffer, sp);
	lscript_global_store(buffer, arg, value);
	return FALSE;
}

BOOL run_storegq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tSTOREGQ ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("0x%X\n", arg);
	LLQuaternion value;
	S32 sp = get_register(buffer, LREG_SP);
	bytestream2quaternion(value, buffer, sp);
	lscript_global_store(buffer, arg, value);
	return FALSE;
}

BOOL run_loadp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tSTOREP ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("0x%X\n", arg);
	S32 value = lscript_pop_int(buffer);
	lscript_local_store(buffer, arg, value);
	return FALSE;
}

BOOL run_loadsp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tSTORESP ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("0x%X\n", arg);
	S32 value = lscript_pop_int(buffer);

	S32 address = lscript_local_get(buffer, arg);
	if (address)
		lsa_decrease_ref_count(buffer, address);

	lscript_local_store(buffer, arg, value);
	return FALSE;
}

BOOL run_loadlp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tSTORELP ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("0x%X\n", arg);
	S32 value = lscript_pop_int(buffer);

	S32 address = lscript_local_get(buffer, arg);
	if (address)
		lsa_decrease_ref_count(buffer, address);

	lscript_local_store(buffer, arg, value);
	return FALSE;
}

BOOL run_loadvp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tSTOREVP ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("0x%X\n", arg);
	LLVector3 value;
	lscript_pop_vector(buffer, value);
	lscript_local_store(buffer, arg, value);
	return FALSE;
}

BOOL run_loadqp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tSTOREQP ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("0x%X\n", arg);
	LLQuaternion value;
	lscript_pop_quaternion(buffer, value);
	lscript_local_store(buffer, arg, value);
	return FALSE;
}

BOOL run_loadgp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tSTOREGP ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("0x%X\n", arg);
	S32 value = lscript_pop_int(buffer);
	lscript_global_store(buffer, arg, value);
	return FALSE;
}

BOOL run_loadgsp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tSTOREGSP ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("%d\n", arg);
	S32 value = lscript_pop_int(buffer);

	S32 address = lscript_global_get(buffer, arg);
	if (address)
		lsa_decrease_ref_count(buffer, address);

	lscript_global_store(buffer, arg, value);
	return FALSE;
}

BOOL run_loadglp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tSTOREGLP ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("0x%X\n", arg);
	S32 value = lscript_pop_int(buffer);

	S32 address = lscript_global_get(buffer, arg);
	if (address)
		lsa_decrease_ref_count(buffer, address);

	lscript_global_store(buffer, arg, value);
	return FALSE;
}

BOOL run_loadgvp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tSTOREGVP ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("0x%X\n", arg);
	LLVector3 value;
	lscript_pop_vector(buffer, value);
	lscript_global_store(buffer, arg, value);
	return FALSE;
}

BOOL run_loadgqp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tSTOREGQP ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("0x%X\n", arg);
	LLQuaternion value;
	lscript_pop_quaternion(buffer, value);
	lscript_global_store(buffer, arg, value);
	return FALSE;
}

BOOL run_push(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPUSH ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("0x%X\n", arg);
	S32 value = lscript_local_get(buffer, arg);
	lscript_push(buffer, value);
	return FALSE;
}

BOOL run_pushs(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPUSHS ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("0x%X\n", arg);
	S32 value = lscript_local_get(buffer, arg);
	lscript_push(buffer, value);
	lsa_increase_ref_count(buffer, value);
	return FALSE;
}

BOOL run_pushl(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPUSHL ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("0x%X\n", arg);
	S32 value = lscript_local_get(buffer, arg);
	lscript_push(buffer, value);
	lsa_increase_ref_count(buffer, value);
	return FALSE;
}

BOOL run_pushv(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPUSHV ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("0x%X\n", arg);
	LLVector3 value;
	lscript_local_get(buffer, arg, value);
	lscript_push(buffer, value);
	return FALSE;
}

BOOL run_pushq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPUSHQ ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("0x%X\n", arg);
	LLQuaternion value;
	lscript_local_get(buffer, arg, value);
	lscript_push(buffer, value);
	return FALSE;
}

BOOL run_pushg(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPUSHG ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("0x%X\n", arg);
	S32 value = lscript_global_get(buffer, arg);
	lscript_push(buffer, value);
	return FALSE;
}

BOOL run_pushgs(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPUSHGS ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("0x%X\n", arg);
	S32 value = lscript_global_get(buffer, arg);
	lscript_push(buffer, value);
	lsa_increase_ref_count(buffer, value);
	return FALSE;
}

BOOL run_pushgl(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPUSHGL ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("0x%X\n", arg);
	S32 value = lscript_global_get(buffer, arg);
	lscript_push(buffer, value);
	lsa_increase_ref_count(buffer, value);
	return FALSE;
}

BOOL run_pushgv(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPUSHGV ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("0x%X\n", arg);
	LLVector3 value;
	lscript_global_get(buffer, arg, value);
	lscript_push(buffer, value);
	return FALSE;
}

BOOL run_pushgq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPUSHGQ ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("0x%X\n", arg);
	LLQuaternion value;
	lscript_global_get(buffer, arg, value);
	lscript_push(buffer, value);
	return FALSE;
}

BOOL run_puship(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPUSHIP\n", offset);
	offset++;
	lscript_push(buffer, offset);
	return FALSE;
}

BOOL run_pushbp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPUSHBP\n", offset);
	offset++;
	lscript_push(buffer, get_register(buffer, LREG_BP));
	return FALSE;
}

BOOL run_pushsp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPUSHSP\n", offset);
	offset++;
	lscript_push(buffer, get_register(buffer, LREG_SP));
	return FALSE;
}

BOOL run_pushargb(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPUSHGARGB ", offset);
	offset++;
	U8 arg = safe_instruction_bytestream2byte(buffer, offset);
	if (b_print)
		printf("%d\n", (U32)arg);
	lscript_push(buffer, arg);
	return FALSE;
}

BOOL run_pushargi(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPUSHARGI ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("%d\n", arg);
	lscript_push(buffer, arg);
	return FALSE;
}

BOOL run_pushargf(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPUSHARGF ", offset);
	offset++;
	F32 arg = safe_instruction_bytestream2float(buffer, offset);
	if (b_print)
		printf("%f\n", arg);
	lscript_push(buffer, arg);
	return FALSE;
}

BOOL run_pushargs(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPUSHARGS ", offset);
	S32 toffset = offset;
	safe_instruction_bytestream_count_char(buffer, toffset);
	S32 size = toffset - offset;
	char *arg = new char[size];
	offset++;
	safe_instruction_bytestream2char(arg, buffer, offset);
	if (b_print)
		printf("%s\n", arg);
	S32 address = lsa_heap_add_data(buffer, new LLScriptLibData(arg), get_max_heap_size(buffer), TRUE);
	lscript_push(buffer, address);
	delete [] arg;
	return FALSE;
}

BOOL run_pushargv(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPUSHARGV ", offset);
	offset++;
	LLVector3 arg;
	safe_instruction_bytestream2vector(arg, buffer, offset);
	if (b_print)
		printf("< %f, %f, %f >\n", arg.mV[VX], arg.mV[VY], arg.mV[VZ]);
	lscript_push(buffer, arg);
	return FALSE;
}
BOOL run_pushargq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPUSHARGQ ", offset);
	offset++;
	LLQuaternion arg;
	safe_instruction_bytestream2quaternion(arg, buffer, offset);
	if (b_print)
		printf("< %f, %f, %f, %f >\n", arg.mQ[VX], arg.mQ[VY], arg.mQ[VZ], arg.mQ[VS]);
	lscript_push(buffer, arg);
	return FALSE;
}
BOOL run_pushe(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPUSHE\n", offset);
	offset++;
	lscript_pusharge(buffer, LSCRIPTDataSize[LST_INTEGER]);
	return FALSE;
}
BOOL run_pushev(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPUSHEV\n", offset);
	offset++;
	lscript_pusharge(buffer, LSCRIPTDataSize[LST_VECTOR]);
	return FALSE;
}
BOOL run_pusheq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPUSHEQ\n", offset);
	offset++;
	lscript_pusharge(buffer, LSCRIPTDataSize[LST_QUATERNION]);
	return FALSE;
}
BOOL run_pusharge(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPUSHARGE ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("%d\n", arg);
	lscript_pusharge(buffer, arg);
	return FALSE;
}

void print_type(U8 type)
{
	if (type == LSCRIPTTypeByte[LST_INTEGER])
	{
		printf("integer");
	}
	else if (type == LSCRIPTTypeByte[LST_FLOATINGPOINT])
	{
		printf("float");
	}
	else if (type == LSCRIPTTypeByte[LST_STRING])
	{
		printf("string");
	}
	else if (type == LSCRIPTTypeByte[LST_KEY])
	{
		printf("key");
	}
	else if (type == LSCRIPTTypeByte[LST_VECTOR])
	{
		printf("vector");
	}
	else if (type == LSCRIPTTypeByte[LST_QUATERNION])
	{
		printf("quaternion");
	}
	else if (type == LSCRIPTTypeByte[LST_LIST])
	{
		printf("list");
	}
}

void unknown_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	printf("Unknown arithmetic operation!\n");
}

void integer_integer_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	S32 lside = lscript_pop_int(buffer);
	S32 rside = lscript_pop_int(buffer);
	S32 result = 0;

	switch(opcode)
	{
	case LOPC_ADD:
		result = lside + rside;
		break;
	case LOPC_SUB:
		result = lside - rside;
		break;
	case LOPC_MUL:
		result = lside * rside;
		break;
	case LOPC_DIV:
		if (rside){
			if( ( rside == -1 ) || ( rside == (S32) 0xffffffff ) )//	division by -1 can have funny results: multiplication is OK: SL-31252
			{
				result = -1 * lside;
			}
			else
			{
				result = lside / rside;
			}
		}
		else
			set_fault(buffer, LSRF_MATH);
		break;
	case LOPC_MOD:
		if (rside)
		{
			if (rside == -1 || rside == 1 )	 // mod(1) = mod(-1) = 0: SL-31252
			{
				result = 0;
			}
			else
			{
				result = lside % rside;
			}
		}
		else
			set_fault(buffer, LSRF_MATH);
		break;
	case LOPC_EQ:
		result = (lside == rside);
		break;
	case LOPC_NEQ:
		result = (lside != rside);
		break;
	case LOPC_LEQ:
		result = (lside <= rside);
		break;
	case LOPC_GEQ:
		result = (lside >= rside);
		break;
	case LOPC_LESS:
		result = (lside < rside);
		break;
	case LOPC_GREATER:
		result = (lside > rside);
		break;
	case LOPC_BITAND:
		result = (lside & rside);
		break;
	case LOPC_BITOR:
		result = (lside | rside);
		break;
	case LOPC_BITXOR:
		result = (lside ^ rside);
		break;
	case LOPC_BOOLAND:
		result = (lside && rside);
		break;
	case LOPC_BOOLOR:
		result = (lside || rside);
		break;
	case LOPC_SHL:
		result = (lside << rside);
		break;
	case LOPC_SHR:
		result = (lside >> rside);
		break;
	default:
		break;
	}
	lscript_push(buffer, result);
}

void integer_float_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	S32 lside = lscript_pop_int(buffer);
	F32 rside = lscript_pop_float(buffer);
	S32 resulti = 0;
	F32 resultf = 0;

	switch(opcode)
	{
	case LOPC_ADD:
		resultf = lside + rside;
		lscript_push(buffer, resultf);
		break;
	case LOPC_SUB:
		resultf = lside - rside;
		lscript_push(buffer, resultf);
		break;
	case LOPC_MUL:
		resultf = lside * rside;
		lscript_push(buffer, resultf);
		break;
	case LOPC_DIV:
		if (rside)
			resultf = lside / rside;
		else
			set_fault(buffer, LSRF_MATH);
		lscript_push(buffer, resultf);
		break;
	case LOPC_EQ:
		resulti = (lside == rside);
		lscript_push(buffer, resulti);
		break;
	case LOPC_NEQ:
		resulti = (lside != rside);
		lscript_push(buffer, resulti);
		break;
	case LOPC_LEQ:
		resulti = (lside <= rside);
		lscript_push(buffer, resulti);
		break;
	case LOPC_GEQ:
		resulti = (lside >= rside);
		lscript_push(buffer, resulti);
		break;
	case LOPC_LESS:
		resulti = (lside < rside);
		lscript_push(buffer, resulti);
		break;
	case LOPC_GREATER:
		resulti = (lside > rside);
		lscript_push(buffer, resulti);
		break;
	default:
		break;
	}
}

void integer_vector_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	S32 lside = lscript_pop_int(buffer);
	LLVector3 rside;
	lscript_pop_vector(buffer, rside);

	switch(opcode)
	{
	case LOPC_MUL:
		rside *= (F32)lside;
		lscript_push(buffer, rside);
		break;
	default:
		break;
	}
}

void float_integer_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	F32 lside = lscript_pop_float(buffer);
	S32 rside = lscript_pop_int(buffer);
	S32 resulti = 0;
	F32 resultf = 0;

	switch(opcode)
	{
	case LOPC_ADD:
		resultf = lside + rside;
		lscript_push(buffer, resultf);
		break;
	case LOPC_SUB:
		resultf = lside - rside;
		lscript_push(buffer, resultf);
		break;
	case LOPC_MUL:
		resultf = lside * rside;
		lscript_push(buffer, resultf);
		break;
	case LOPC_DIV:
		if (rside)
			resultf = lside / rside;
		else
			set_fault(buffer, LSRF_MATH);
		lscript_push(buffer, resultf);
		break;
	case LOPC_EQ:
		resulti = (lside == rside);
		lscript_push(buffer, resulti);
		break;
	case LOPC_NEQ:
		resulti = (lside != rside);
		lscript_push(buffer, resulti);
		break;
	case LOPC_LEQ:
		resulti = (lside <= rside);
		lscript_push(buffer, resulti);
		break;
	case LOPC_GEQ:
		resulti = (lside >= rside);
		lscript_push(buffer, resulti);
		break;
	case LOPC_LESS:
		resulti = (lside < rside);
		lscript_push(buffer, resulti);
		break;
	case LOPC_GREATER:
		resulti = (lside > rside);
		lscript_push(buffer, resulti);
		break;
	default:
		break;
	}
}

void float_float_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	F32 lside = lscript_pop_float(buffer);
	F32 rside = lscript_pop_float(buffer);
	F32 resultf = 0;
	S32 resulti = 0;

	switch(opcode)
	{
	case LOPC_ADD:
		resultf = lside + rside;
		lscript_push(buffer, resultf);
		break;
	case LOPC_SUB:
		resultf = lside - rside;
		lscript_push(buffer, resultf);
		break;
	case LOPC_MUL:
		resultf = lside * rside;
		lscript_push(buffer, resultf);
		break;
	case LOPC_DIV:
		if (rside)
			resultf = lside / rside;
		else
			set_fault(buffer, LSRF_MATH);
		lscript_push(buffer, resultf);
		break;
	case LOPC_EQ:
		resulti = (lside == rside);
		lscript_push(buffer, resulti);
		break;
	case LOPC_NEQ:
		resulti = (lside != rside);
		lscript_push(buffer, resulti);
		break;
	case LOPC_LEQ:
		resulti = (lside <= rside);
		lscript_push(buffer, resulti);
		break;
	case LOPC_GEQ:
		resulti = (lside >= rside);
		lscript_push(buffer, resulti);
		break;
	case LOPC_LESS:
		resulti = (lside < rside);
		lscript_push(buffer, resulti);
		break;
	case LOPC_GREATER:
		resulti = (lside > rside);
		lscript_push(buffer, resulti);
		break;
	default:
		break;
	}
}

void float_vector_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	F32 lside = lscript_pop_float(buffer);
	LLVector3 rside;
	lscript_pop_vector(buffer, rside);

	switch(opcode)
	{
	case LOPC_MUL:
		rside *= lside;
		lscript_push(buffer, rside);
		break;
	default:
		break;
	}
}

void string_string_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	S32 lside = lscript_pop_int(buffer);
	S32 rside = lscript_pop_int(buffer);
	S32 resulti;
	S32 address;

	switch(opcode)
	{
	case LOPC_ADD:
		address = lsa_cat_strings(buffer, lside, rside, get_max_heap_size(buffer));
		lscript_push(buffer, address);
		break;
	case LOPC_EQ:
		resulti = !lsa_cmp_strings(buffer, lside, rside);
		lscript_push(buffer, resulti);
		break;
	case LOPC_NEQ:
		resulti = lsa_cmp_strings(buffer, lside, rside);
		lscript_push(buffer, resulti);
		break;
	default:
		break;
	}
}

void string_key_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	S32 lside = lscript_pop_int(buffer);
	S32 rside = lscript_pop_int(buffer);
	S32 resulti;

	switch(opcode)
	{
	case LOPC_NEQ:
		resulti = lsa_cmp_strings(buffer, lside, rside);
		lscript_push(buffer, resulti);
		break;
	case LOPC_EQ:
		resulti = !lsa_cmp_strings(buffer, lside, rside);
		lscript_push(buffer, resulti);
		break;
	default:
		break;
	}
}

void key_string_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	S32 lside = lscript_pop_int(buffer);
	S32 rside = lscript_pop_int(buffer);
	S32 resulti;

	switch(opcode)
	{
	case LOPC_NEQ:
		resulti = lsa_cmp_strings(buffer, lside, rside);
		lscript_push(buffer, resulti);
		break;
	case LOPC_EQ:
		resulti = !lsa_cmp_strings(buffer, lside, rside);
		lscript_push(buffer, resulti);
		break;
	default:
		break;
	}
}

void key_key_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	S32 lside = lscript_pop_int(buffer);
	S32 rside = lscript_pop_int(buffer);
	S32 resulti;

	switch(opcode)
	{
	case LOPC_EQ:
		resulti = !lsa_cmp_strings(buffer, lside, rside);
		lscript_push(buffer, resulti);
		break;
	case LOPC_NEQ:
		resulti = lsa_cmp_strings(buffer, lside, rside);
		lscript_push(buffer, resulti);
		break;
	default:
		break;
	}
}

void vector_integer_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	LLVector3 lside;
	lscript_pop_vector(buffer, lside);
	S32 rside = lscript_pop_int(buffer);

	switch(opcode)
	{
	case LOPC_MUL:
		lside *= (F32)rside;
		lscript_push(buffer, lside);
		break;
	case LOPC_DIV:
		if (rside)
			lside *= (1.f/rside);
		else
			set_fault(buffer, LSRF_MATH);
		lscript_push(buffer, lside);
		break;
	default:
		break;
	}
}

void vector_float_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	LLVector3 lside;
	lscript_pop_vector(buffer, lside);
	F32 rside = lscript_pop_float(buffer);

	switch(opcode)
	{
	case LOPC_MUL:
		lside *= rside;
		lscript_push(buffer, lside);
		break;
	case LOPC_DIV:
		if (rside)
			lside *= (1.f/rside);
		else
			set_fault(buffer, LSRF_MATH);
		lscript_push(buffer, lside);
		break;
	default:
		break;
	}
}

void vector_vector_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	LLVector3 lside;
	lscript_pop_vector(buffer, lside);
	LLVector3 rside;
	lscript_pop_vector(buffer, rside);
	S32 resulti = 0;
	F32 resultf = 0.f;

	switch(opcode)
	{
	case LOPC_ADD:
		lside += rside;
		lscript_push(buffer, lside);
		break;
	case LOPC_SUB:
		lside -= rside;
		lscript_push(buffer, lside);
		break;
	case LOPC_MUL:
		resultf = lside * rside;
		lscript_push(buffer, resultf);
		break;
	case LOPC_MOD:
		lside = lside % rside;
		lscript_push(buffer, lside);
		break;
	case LOPC_EQ:
		resulti = (lside == rside);
		lscript_push(buffer, resulti);
		break;
	case LOPC_NEQ:
		resulti = (lside != rside);
		lscript_push(buffer, resulti);
		break;
	default:
		break;
	}
}

void vector_quaternion_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	LLVector3 lside;
	lscript_pop_vector(buffer, lside);
	LLQuaternion rside;
	lscript_pop_quaternion(buffer, rside);

	switch(opcode)
	{
	case LOPC_MUL:
		lside = lside * rside;
		lscript_push(buffer, lside);
		break;
	case LOPC_DIV:
		lside = lside * rside.conjQuat();
		lscript_push(buffer, lside);
		break;
	default:
		break;
	}
}

void quaternion_quaternion_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	LLQuaternion lside;
	lscript_pop_quaternion(buffer, lside);
	LLQuaternion rside;
	lscript_pop_quaternion(buffer, rside);
	S32 resulti = 0;

	switch(opcode)
	{
	case LOPC_ADD:
		lside = lside + rside;
		lscript_push(buffer, lside);
		break;
	case LOPC_SUB:
		lside = lside - rside;
		lscript_push(buffer, lside);
		break;
	case LOPC_MUL:
		lside *= rside;
		lscript_push(buffer, lside);
		break;
	case LOPC_DIV:
		lside = lside * rside.conjQuat();
		lscript_push(buffer, lside);
		break;
	case LOPC_EQ:
		resulti = (lside == rside);
		lscript_push(buffer, resulti);
		break;
	case LOPC_NEQ:
		resulti = (lside != rside);
		lscript_push(buffer, resulti);
		break;
	default:
		break;
	}
}

void integer_list_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	S32 lside = lscript_pop_int(buffer);
	S32 rside = lscript_pop_int(buffer);
	S32 address;

	switch(opcode)
	{
	case LOPC_ADD:
		{
			LLScriptLibData *list = new LLScriptLibData;
			list->mType = LST_LIST;
			list->mListp = new LLScriptLibData(lside);
			address = lsa_preadd_lists(buffer, list, rside, get_max_heap_size(buffer));
			lscript_push(buffer, address);
			list->mListp = NULL;
			delete list;
		}
		break;
	default:
		break;
	}
}

void float_list_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	F32 lside = lscript_pop_float(buffer);
	S32 rside = lscript_pop_int(buffer);
	S32 address;

	switch(opcode)
	{
	case LOPC_ADD:
		{
			LLScriptLibData *list = new LLScriptLibData;
			list->mType = LST_LIST;
			list->mListp = new LLScriptLibData(lside);
			address = lsa_preadd_lists(buffer, list, rside, get_max_heap_size(buffer));
			lscript_push(buffer, address);
			list->mListp = NULL;
			delete list;
		}
		break;
	default:
		break;
	}
}

void string_list_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	S32 lside = lscript_pop_int(buffer);
	S32 rside = lscript_pop_int(buffer);
	S32 address;

	switch(opcode)
	{
	case LOPC_ADD:
		{
			LLScriptLibData *string = lsa_get_data(buffer, lside, TRUE);
			LLScriptLibData *list = new LLScriptLibData;
			list->mType = LST_LIST;
			list->mListp = string;
			address = lsa_preadd_lists(buffer, list, rside, get_max_heap_size(buffer));
			lscript_push(buffer, address);
			list->mListp = NULL;
			delete list;
		}
		break;
	default:
		break;
	}
}

void key_list_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	S32 lside = lscript_pop_int(buffer);
	S32 rside = lscript_pop_int(buffer);
	S32 address;

	switch(opcode)
	{
	case LOPC_ADD:
		{
			LLScriptLibData *key = lsa_get_data(buffer, lside, TRUE);
			// need to convert key to key, since it comes out like a string
			if (key->mType == LST_STRING)
			{
				key->mKey = key->mString;
				key->mString = NULL;
				key->mType = LST_KEY;
			}
			LLScriptLibData *list = new LLScriptLibData;
			list->mType = LST_LIST;
			list->mListp = key;
			address = lsa_preadd_lists(buffer, list, rside, get_max_heap_size(buffer));
			lscript_push(buffer, address);
			list->mListp = NULL;
			delete list;
		}
		break;
	default:
		break;
	}
}

void vector_list_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	LLVector3 lside;
	lscript_pop_vector(buffer, lside);
	S32 rside = lscript_pop_int(buffer);
	S32 address;

	switch(opcode)
	{
	case LOPC_ADD:
		{
			LLScriptLibData *list = new LLScriptLibData;
			list->mType = LST_LIST;
			list->mListp = new LLScriptLibData(lside);
			address = lsa_preadd_lists(buffer, list, rside, get_max_heap_size(buffer));
			lscript_push(buffer, address);
			list->mListp = NULL;
			delete list;
		}
		break;
	default:
		break;
	}
}

void quaternion_list_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	LLQuaternion lside;
	lscript_pop_quaternion(buffer, lside);
	S32 rside = lscript_pop_int(buffer);
	S32 address;

	switch(opcode)
	{
	case LOPC_ADD:
		{
			LLScriptLibData *list = new LLScriptLibData;
			list->mType = LST_LIST;
			list->mListp = new LLScriptLibData(lside);
			address = lsa_preadd_lists(buffer, list, rside, get_max_heap_size(buffer));
			lscript_push(buffer, address);
			list->mListp = NULL;
			delete list;
		}
		break;
	default:
		break;
	}
}

void list_integer_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	S32 lside = lscript_pop_int(buffer);
	S32 rside = lscript_pop_int(buffer);
	S32 address;

	switch(opcode)
	{
	case LOPC_ADD:
		{
			LLScriptLibData *list = new LLScriptLibData;
			list->mType = LST_LIST;
			list->mListp = new LLScriptLibData(rside);
			address = lsa_postadd_lists(buffer, lside, list, get_max_heap_size(buffer));
			list->mListp = NULL;
			delete list;
			lscript_push(buffer, address);
		}
		break;
	default:
		break;
	}
}

void list_float_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	S32 lside = lscript_pop_int(buffer);
	F32 rside = lscript_pop_float(buffer);
	S32 address;

	switch(opcode)
	{
	case LOPC_ADD:
		{
			LLScriptLibData *list = new LLScriptLibData;
			list->mType = LST_LIST;
			list->mListp = new LLScriptLibData(rside);
			address = lsa_postadd_lists(buffer, lside, list, get_max_heap_size(buffer));
			list->mListp = NULL;
			delete list;
			lscript_push(buffer, address);
		}
		break;
	default:
		break;
	}
}

void list_string_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	S32 lside = lscript_pop_int(buffer);
	S32 rside = lscript_pop_int(buffer);
	S32 address;

	switch(opcode)
	{
	case LOPC_ADD:
		{
			LLScriptLibData *string = lsa_get_data(buffer, rside, TRUE);
			LLScriptLibData *list = new LLScriptLibData;
			list->mType = LST_LIST;
			list->mListp = string;
			address = lsa_postadd_lists(buffer, lside, list, get_max_heap_size(buffer));
			list->mListp = NULL;
			delete list;
			lscript_push(buffer, address);
		}
		break;
	default:
		break;
	}
}

void list_key_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	S32 lside = lscript_pop_int(buffer);
	S32 rside = lscript_pop_int(buffer);
	S32 address;

	switch(opcode)
	{
	case LOPC_ADD:
		{
			LLScriptLibData *key = lsa_get_data(buffer, rside, TRUE);
			// need to convert key to key, since it comes out like a string
			if (key->mType == LST_STRING)
			{
				key->mKey = key->mString;
				key->mString = NULL;
				key->mType = LST_KEY;
			}
			LLScriptLibData *list = new LLScriptLibData;
			list->mType = LST_LIST;
			list->mListp = key;
			address = lsa_postadd_lists(buffer, lside, list, get_max_heap_size(buffer));
			list->mListp = NULL;
			delete list;
			lscript_push(buffer, address);
		}
		break;
	default:
		break;
	}
}

void list_vector_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	S32 lside = lscript_pop_int(buffer);
	LLVector3 rside;
	lscript_pop_vector(buffer, rside);
	S32 address;

	switch(opcode)
	{
	case LOPC_ADD:
		{
			LLScriptLibData *list = new LLScriptLibData;
			list->mType = LST_LIST;
			list->mListp = new LLScriptLibData(rside);
			address = lsa_postadd_lists(buffer, lside, list, get_max_heap_size(buffer));
			list->mListp = NULL;
			delete list;
			lscript_push(buffer, address);
		}
		break;
	default:
		break;
	}
}

void list_quaternion_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	S32 lside = lscript_pop_int(buffer);
	LLQuaternion rside;
	lscript_pop_quaternion(buffer, rside);
	S32 address;

	switch(opcode)
	{
	case LOPC_ADD:
		{
			LLScriptLibData *list = new LLScriptLibData;
			list->mType = LST_LIST;
			list->mListp = new LLScriptLibData(rside);
			address = lsa_postadd_lists(buffer, lside, list, get_max_heap_size(buffer));
			list->mListp = NULL;
			delete list;
			lscript_push(buffer, address);
		}
		break;
	default:
		break;
	}
}

void list_list_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	S32 lside = lscript_pop_int(buffer);
	S32 rside = lscript_pop_int(buffer);
	S32 resulti;
	S32 address;

	switch(opcode)
	{
	case LOPC_ADD:
		address = lsa_cat_lists(buffer, lside, rside, get_max_heap_size(buffer));
		lscript_push(buffer, address);
		break;
	case LOPC_EQ:
		resulti = !lsa_cmp_lists(buffer, lside, rside);
		lscript_push(buffer, resulti);
		break;
	case LOPC_NEQ:
		resulti = lsa_cmp_lists(buffer, lside, rside);
		lscript_push(buffer, resulti);
		break;
	default:
		break;
	}
}

BOOL run_add(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tADD ", offset);
	offset++;
	U8 arg = safe_instruction_bytestream2byte(buffer, offset);
	U8 arg1 = arg >> 4;
	U8 arg2 = arg & 0xf;
	if (b_print)
	{
		print_type(arg1);
		printf(", ");
		print_type(arg2);
		printf("\n");
	}
	binary_operations[arg1][arg2](buffer, LOPC_ADD);
	return FALSE;
}

BOOL run_sub(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tSUB ", offset);
	offset++;
	U8 arg = safe_instruction_bytestream2byte(buffer, offset);
	U8 arg1 = arg >> 4;
	U8 arg2 = arg & 0xf;
	if (b_print)
	{
		print_type(arg1);
		printf(", ");
		print_type(arg2);
		printf("\n");
	}
	binary_operations[arg1][arg2](buffer, LOPC_SUB);
	return FALSE;
}
BOOL run_mul(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tMUL ", offset);
	offset++;
	U8 arg = safe_instruction_bytestream2byte(buffer, offset);
	U8 arg1 = arg >> 4;
	U8 arg2 = arg & 0xf;
	if (b_print)
	{
		print_type(arg1);
		printf(", ");
		print_type(arg2);
		printf("\n");
	}
	binary_operations[arg1][arg2](buffer, LOPC_MUL);
	return FALSE;
}
BOOL run_div(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tDIV ", offset);
	offset++;
	U8 arg = safe_instruction_bytestream2byte(buffer, offset);
	U8 arg1 = arg >> 4;
	U8 arg2 = arg & 0xf;
	if (b_print)
	{
		print_type(arg1);
		printf(", ");
		print_type(arg2);
		printf("\n");
	}
	binary_operations[arg1][arg2](buffer, LOPC_DIV);
	return FALSE;
}
BOOL run_mod(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tMOD ", offset);
	offset++;
	U8 arg = safe_instruction_bytestream2byte(buffer, offset);
	U8 arg1 = arg >> 4;
	U8 arg2 = arg & 0xf;
	if (b_print)
	{
		print_type(arg1);
		printf(", ");
		print_type(arg2);
		printf("\n");
	}
	binary_operations[arg1][arg2](buffer, LOPC_MOD);
	return FALSE;
}

BOOL run_eq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tEQ ", offset);
	offset++;
	U8 arg = safe_instruction_bytestream2byte(buffer, offset);
	U8 arg1 = arg >> 4;
	U8 arg2 = arg & 0xf;
	if (b_print)
	{
		print_type(arg1);
		printf(", ");
		print_type(arg2);
		printf("\n");
	}
	binary_operations[arg1][arg2](buffer, LOPC_EQ);
	return FALSE;
}
BOOL run_neq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tNEQ ", offset);
	offset++;
	U8 arg = safe_instruction_bytestream2byte(buffer, offset);
	U8 arg1 = arg >> 4;
	U8 arg2 = arg & 0xf;
	if (b_print)
	{
		print_type(arg1);
		printf(", ");
		print_type(arg2);
		printf("\n");
	}
	binary_operations[arg1][arg2](buffer, LOPC_NEQ);
	return FALSE;
}
BOOL run_leq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tLEQ ", offset);
	offset++;
	U8 arg = safe_instruction_bytestream2byte(buffer, offset);
	U8 arg1 = arg >> 4;
	U8 arg2 = arg & 0xf;
	if (b_print)
	{
		print_type(arg1);
		printf(", ");
		print_type(arg2);
		printf("\n");
	}
	binary_operations[arg1][arg2](buffer, LOPC_LEQ);
	return FALSE;
}
BOOL run_geq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tGEQ ", offset);
	offset++;
	U8 arg = safe_instruction_bytestream2byte(buffer, offset);
	U8 arg1 = arg >> 4;
	U8 arg2 = arg & 0xf;
	if (b_print)
	{
		print_type(arg1);
		printf(", ");
		print_type(arg2);
		printf("\n");
	}
	binary_operations[arg1][arg2](buffer, LOPC_GEQ);
	return FALSE;
}
BOOL run_less(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tLESS ", offset);
	offset++;
	U8 arg = safe_instruction_bytestream2byte(buffer, offset);
	U8 arg1 = arg >> 4;
	U8 arg2 = arg & 0xf;
	if (b_print)
	{
		print_type(arg1);
		printf(", ");
		print_type(arg2);
		printf("\n");
	}
	binary_operations[arg1][arg2](buffer, LOPC_LESS);
	return FALSE;
}
BOOL run_greater(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tGREATER ", offset);
	offset++;
	U8 arg = safe_instruction_bytestream2byte(buffer, offset);
	U8 arg1 = arg >> 4;
	U8 arg2 = arg & 0xf;
	if (b_print)
	{
		print_type(arg1);
		printf(", ");
		print_type(arg2);
		printf("\n");
	}
	binary_operations[arg1][arg2](buffer, LOPC_GREATER);
	return FALSE;
}

BOOL run_bitand(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tBITAND\n", offset);
	offset++;
	binary_operations[LST_INTEGER][LST_INTEGER](buffer, LOPC_BITAND);
	return FALSE;
}
BOOL run_bitor(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tBITOR\n", offset);
	offset++;
	binary_operations[LST_INTEGER][LST_INTEGER](buffer, LOPC_BITOR);
	return FALSE;
}
BOOL run_bitxor(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tBITXOR\n", offset);
	offset++;
	binary_operations[LST_INTEGER][LST_INTEGER](buffer, LOPC_BITXOR);
	return FALSE;
}
BOOL run_booland(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tBOOLAND\n", offset);
	offset++;
	binary_operations[LST_INTEGER][LST_INTEGER](buffer, LOPC_BOOLAND);
	return FALSE;
}
BOOL run_boolor(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tBOOLOR\n", offset);
	offset++;
	binary_operations[LST_INTEGER][LST_INTEGER](buffer, LOPC_BOOLOR);
	return FALSE;
}

BOOL run_shl(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tSHL\n", offset);
	offset++;
	binary_operations[LST_INTEGER][LST_INTEGER](buffer, LOPC_SHL);
	return FALSE;
}
BOOL run_shr(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tSHR\n", offset);
	offset++;
	binary_operations[LST_INTEGER][LST_INTEGER](buffer, LOPC_SHR);
	return FALSE;
}

void integer_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	S32 lside = lscript_pop_int(buffer);
	S32 result = 0;

	switch(opcode)
	{
	case LOPC_NEG:
		result = -lside;
		break;
	case LOPC_BITNOT:
		result = ~lside;
		break;
	case LOPC_BOOLNOT:
		result = !lside;
		break;
	default:
		break;
	}
	lscript_push(buffer, result);
}

void float_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	F32 lside = lscript_pop_float(buffer);
	F32 result = 0;

	switch(opcode)
	{
	case LOPC_NEG:
		result = -lside;
		lscript_push(buffer, result);
		break;
	default:
		break;
	}
}

void vector_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	LLVector3 lside;
	lscript_pop_vector(buffer, lside);
	LLVector3 result;

	switch(opcode)
	{
	case LOPC_NEG:
		result = -lside;
		lscript_push(buffer, result);
		break;
	default:
		break;
	}
}

void quaternion_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
{
	LLQuaternion lside;
	lscript_pop_quaternion(buffer, lside);
	LLQuaternion result;

	switch(opcode)
	{
	case LOPC_NEG:
		result = -lside;
		lscript_push(buffer, result);
		break;
	default:
		break;
	}
}


BOOL run_neg(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tNEG ", offset);
	offset++;
	U8 arg = safe_instruction_bytestream2byte(buffer, offset);
	if (b_print)
	{
		print_type(arg);
		printf("\n");
	}
	unary_operations[arg](buffer, LOPC_NEG);
	return FALSE;
}

BOOL run_bitnot(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tBITNOT\n", offset);
	offset++;
	unary_operations[LST_INTEGER](buffer, LOPC_BITNOT);
	return FALSE;
}

BOOL run_boolnot(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tBOOLNOT\n", offset);
	offset++;
	unary_operations[LST_INTEGER](buffer, LOPC_BOOLNOT);
	return FALSE;
}

BOOL run_jump(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tJUMP ", offset);
	offset++;
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("%d\n", arg);
	offset += arg;
	return FALSE;
}

BOOL run_jumpif(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tJUMPIF ", offset);
	offset++;
	U8 type = safe_instruction_bytestream2byte(buffer, offset);
	if (b_print)
	{
		print_type(type);
		printf(", ");
	}
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("%d\n", arg);

	if (type == LST_INTEGER)
	{
		S32 test = lscript_pop_int(buffer);
		if (test)
		{
			offset += arg;
		}
	}
	else if (type == LST_FLOATINGPOINT)
	{
		F32 test = lscript_pop_float(buffer);
		if (test)
		{
			offset += arg;
		}
	}
	else if (type == LST_VECTOR)
	{
		LLVector3 test;
		lscript_pop_vector(buffer, test);
		if (!test.isExactlyZero())
		{
			offset += arg;
		}
	}
	else if (type == LST_QUATERNION)
	{
		LLQuaternion test;
		lscript_pop_quaternion(buffer, test);
		if (!test.isIdentity())
		{
			offset += arg;
		}
	}
	else if (type == LST_STRING)
	{
		S32 base_address = lscript_pop_int(buffer);
		// this bit of nastiness is to get around that code paths to
		// local variables can result in lack of initialization and
		// function clean up of ref counts isn't based on scope (a
		// mistake, I know)
		S32 address = base_address + get_register(buffer, LREG_HR) - 1;
		if (address)
		{
			S32 string = address;
			string += SIZEOF_SCRIPT_ALLOC_ENTRY;
			if (safe_heap_check_address(buffer, string, 1))
			{
				S32 toffset = string;
				safe_heap_bytestream_count_char(buffer, toffset);
				S32 size = toffset - string;
				char *sdata = new char[size];
				bytestream2char(sdata, buffer, string);
				if (strlen(sdata))		/*Flawfinder: ignore*/
				{
					offset += arg;
				}
				delete [] sdata;
			}
			lsa_decrease_ref_count(buffer, base_address);
		}
	}
	else if (type == LST_KEY)
	{
		S32 base_address = lscript_pop_int(buffer);
		// this bit of nastiness is to get around that code paths to
		// local variables can result in lack of initialization and
		// function clean up of ref counts isn't based on scope (a
		// mistake, I know)
		S32 address = base_address + get_register(buffer, LREG_HR) - 1;
		if (address)
		{
			S32 string = address;
			string += SIZEOF_SCRIPT_ALLOC_ENTRY;
			if (safe_heap_check_address(buffer, string, 1))
			{
				S32 toffset = string;
				safe_heap_bytestream_count_char(buffer, toffset);
				S32 size = toffset - string;
				char *sdata = new char[size];
				bytestream2char(sdata, buffer, string);
				if (strlen(sdata))		/*Flawfinder: ignore*/
				{
					LLUUID id;
					if (id.set(sdata) && id.notNull())
						offset += arg;
				}
				delete [] sdata;
			}
			lsa_decrease_ref_count(buffer, base_address);
		}
	}
	else if (type == LST_LIST)
	{
		S32 base_address = lscript_pop_int(buffer);
		S32 address = base_address + get_register(buffer, LREG_HR) - 1;
		if (address)
		{
			if (safe_heap_check_address(buffer, address + SIZEOF_SCRIPT_ALLOC_ENTRY, 1))
			{
				LLScriptLibData *list = lsa_get_list_ptr(buffer, base_address, TRUE);
				if (list && list->getListLength())
				{
					offset += arg;
				}
				delete list;
			}
		}
	}
	return FALSE;
}

BOOL run_jumpnif(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tJUMPNIF ", offset);
	offset++;
	U8 type = safe_instruction_bytestream2byte(buffer, offset);
	if (b_print)
	{
		print_type(type);
		printf(", ");
	}
	S32 arg = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("%d\n", arg);

	if (type == LST_INTEGER)
	{
		S32 test = lscript_pop_int(buffer);
		if (!test)
		{
			offset += arg;
		}
	}
	else if (type == LST_FLOATINGPOINT)
	{
		F32 test = lscript_pop_float(buffer);
		if (!test)
		{
			offset += arg;
		}
	}
	else if (type == LST_VECTOR)
	{
		LLVector3 test;
		lscript_pop_vector(buffer, test);
		if (test.isExactlyZero())
		{
			offset += arg;
		}
	}
	else if (type == LST_QUATERNION)
	{
		LLQuaternion test;
		lscript_pop_quaternion(buffer, test);
		if (test.isIdentity())
		{
			offset += arg;
		}
	}
	else if (type == LST_STRING)
	{
		S32 base_address = lscript_pop_int(buffer);
		// this bit of nastiness is to get around that code paths to
		// local variables can result in lack of initialization and
		// function clean up of ref counts isn't based on scope (a
		// mistake, I know)
		S32 address = base_address + get_register(buffer, LREG_HR) - 1;
		if (address)
		{
			S32 string = address;
			string += SIZEOF_SCRIPT_ALLOC_ENTRY;
			if (safe_heap_check_address(buffer, string, 1))
			{
				S32 toffset = string;
				safe_heap_bytestream_count_char(buffer, toffset);
				S32 size = toffset - string;
				char *sdata = new char[size];
				bytestream2char(sdata, buffer, string);
				if (!strlen(sdata))		/*Flawfinder: ignore*/
				{
					offset += arg;
				}
				delete [] sdata;
			}
			lsa_decrease_ref_count(buffer, base_address);
		}
	}
	else if (type == LST_KEY)
	{
		S32 base_address = lscript_pop_int(buffer);
		// this bit of nastiness is to get around that code paths to
		// local variables can result in lack of initialization and
		// function clean up of ref counts isn't based on scope (a
		// mistake, I know)
		S32 address = base_address + get_register(buffer, LREG_HR) - 1;
		if (address)
		{
			S32 string = address;
			string += SIZEOF_SCRIPT_ALLOC_ENTRY;
			if (safe_heap_check_address(buffer, string, 1))
			{
				S32 toffset = string;
				safe_heap_bytestream_count_char(buffer, toffset);
				S32 size = toffset - string;
				char *sdata = new char[size];
				bytestream2char(sdata, buffer, string);
				if (strlen(sdata))		/*Flawfinder: ignore*/
				{
					LLUUID id;
					if (!id.set(sdata) || id.isNull())
						offset += arg;
				}
				else
				{
					offset += arg;
				}
				delete [] sdata;
			}
			lsa_decrease_ref_count(buffer, base_address);
		}
	}
	else if (type == LST_LIST)
	{
		S32 base_address = lscript_pop_int(buffer);
		// this bit of nastiness is to get around that code paths to
		// local variables can result in lack of initialization and
		// function clean up of ref counts isn't based on scope (a
		// mistake, I know)
		S32 address = base_address + get_register(buffer, LREG_HR) - 1;
		if (address)
		{
			if (safe_heap_check_address(buffer, address + SIZEOF_SCRIPT_ALLOC_ENTRY, 1))
			{
				LLScriptLibData *list = lsa_get_list_ptr(buffer, base_address, TRUE);
				if (!list || !list->getListLength())
				{
					offset += arg;
				}
				delete list;
			}
		}
	}
	return FALSE;
}

BOOL run_state(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tSTATE ", offset);
	offset++;
	S32 state = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("%d\n", state);

	S32 bp = lscript_pop_int(buffer);
	set_bp(buffer, bp);

	offset = lscript_pop_int(buffer);

	S32 major_version = 0;
	S32 value = get_register(buffer, LREG_VN);
	if (value == LSL2_VERSION1_END_NUMBER)
	{
		major_version = 1;
	}
	else if (value == LSL2_VERSION_NUMBER)
	{
		major_version = 2;
	}

	S32 current_state = get_register(buffer, LREG_CS);
	if (state != current_state)
	{
		U64 ce = get_event_register(buffer, LREG_CE, major_version);
		ce |= LSCRIPTStateBitField[LSTT_STATE_EXIT];
		set_event_register(buffer, LREG_CE, ce, major_version);
	}
	set_register(buffer, LREG_NS, state);
	return FALSE;
}

BOOL run_call(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tCALL ", offset);
	offset++;
	S32 func = safe_instruction_bytestream2integer(buffer, offset);
	if (b_print)
		printf("%d\n", func);

	lscript_local_store(buffer, -8, offset);

	S32 minimum = get_register(buffer, LREG_GFR);
	S32 maximum = get_register(buffer, LREG_SR);
	S32 lookup = minimum + func*4 + 4;
	S32 function;

	if (  (lookup >= minimum)
		&&(lookup < maximum))
	{
		function = bytestream2integer(buffer, lookup) + minimum;
		if (  (lookup >= minimum)
			&&(lookup < maximum))
		{
			offset = function;
			offset += bytestream2integer(buffer, function);
		}
		else
		{
			set_fault(buffer, LSRF_BOUND_CHECK_ERROR);
		}
	}
	else
	{
		set_fault(buffer, LSRF_BOUND_CHECK_ERROR);
	}
	return FALSE;
}

BOOL run_return(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tRETURN\n", offset);
	offset++;
	S32 bp = lscript_pop_int(buffer);
	set_bp(buffer, bp);
	offset = lscript_pop_int(buffer);
	return FALSE;
}

S32 axtoi(char *hexStg)
{
  S32 n = 0;         // position in string
  S32 m = 0;         // position in digit[] to shift
  S32 count;         // loop index
  S32 intValue = 0;  // integer value of hex string
  S32 digit[9];      // hold values to convert
  while (n < 8)
  {
     if (hexStg[n]=='\0')
        break;
     if (hexStg[n] > 0x29 && hexStg[n] < 0x40 ) //if 0 to 9
        digit[n] = hexStg[n] & 0x0f;            //convert to int
     else if (hexStg[n] >='a' && hexStg[n] <= 'f') //if a to f
        digit[n] = (hexStg[n] & 0x0f) + 9;      //convert to int
     else if (hexStg[n] >='A' && hexStg[n] <= 'F') //if A to F
        digit[n] = (hexStg[n] & 0x0f) + 9;      //convert to int
     else break;
    n++;
  }
  count = n;
  m = n - 1;
  n = 0;
  while(n < count)
  {
     // digit[n] is value of hex digit at position n
     // (m << 2) is the number of positions to shift
     // OR the bits into return value
     intValue = intValue | (digit[n] << (m << 2));
     m--;   // adjust the position to set
     n++;   // next digit to process
  }
  return (intValue);
}


BOOL run_cast(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	char caststr[1024];		/*Flawfinder: ignore*/
	if (b_print)
		printf("[0x%X]\tCAST ", offset);
	offset++;
	U8 arg = safe_instruction_bytestream2byte(buffer, offset);
	U8 from = arg >> 4;
	U8 to = arg & 0xf;
	if (b_print)
	{
		print_type(from);
		printf(", ");
		print_type(to);
		printf("\n");
	}

	switch(from)
	{
	case LST_INTEGER:
		{
			switch(to)
			{
			case LST_INTEGER:
				break;
			case LST_FLOATINGPOINT:
				{
					S32 source = lscript_pop_int(buffer);
					F32 dest = (F32)source;
					lscript_push(buffer, dest);
				}
				break;
			case LST_STRING:
				{
					S32 address, source = lscript_pop_int(buffer);
					snprintf(caststr, sizeof(caststr), "%d", source);		/* Flawfinder: ignore */
					address = lsa_heap_add_data(buffer, new LLScriptLibData(caststr), get_max_heap_size(buffer), TRUE);
					lscript_push(buffer, address);
				}
				break;
			case LST_LIST:
				{
					S32 address, source = lscript_pop_int(buffer);
					LLScriptLibData *list = new LLScriptLibData;
					list->mType = LST_LIST;
					list->mListp = new LLScriptLibData(source);
					address = lsa_heap_add_data(buffer, list, get_max_heap_size(buffer), TRUE);
					lscript_push(buffer, address);
				}
				break;
			default:
				break;
			}
		}
		break;
	case LST_FLOATINGPOINT:
		{
			switch(to)
			{
			case LST_INTEGER:
				{
					F32 source = lscript_pop_float(buffer);
					S32 dest = (S32)source;
					lscript_push(buffer, dest);
				}
				break;
			case LST_FLOATINGPOINT:
				break;
			case LST_STRING:
				{
					S32 address;
					F32 source = lscript_pop_float(buffer);
					snprintf(caststr, sizeof(caststr), "%f", source);		/* Flawfinder: ignore */
					address = lsa_heap_add_data(buffer, new LLScriptLibData(caststr), get_max_heap_size(buffer), TRUE);
					lscript_push(buffer, address);
				}
				break;
			case LST_LIST:
				{
					S32 address;
					F32 source = lscript_pop_float(buffer);
					LLScriptLibData *list = new LLScriptLibData;
					list->mType = LST_LIST;
					list->mListp = new LLScriptLibData(source);
					address = lsa_heap_add_data(buffer, list, get_max_heap_size(buffer), TRUE);
					lscript_push(buffer, address);
				}
				break;
			default:
				break;
			}
		}
		break;
	case LST_STRING:
		{
			switch(to)
			{
			case LST_INTEGER:
				{
					S32 base_address = lscript_pop_int(buffer);
	// this bit of nastiness is to get around that code paths to local variables can result in lack of initialization
	// and function clean up of ref counts isn't based on scope (a mistake, I know)
					S32 address = base_address + get_register(buffer, LREG_HR) - 1;
					if (address)
					{
						S32 string = address;
						string += SIZEOF_SCRIPT_ALLOC_ENTRY;
						if (safe_heap_check_address(buffer, string, 1))
						{
							S32 toffset = string;
							safe_heap_bytestream_count_char(buffer, toffset);
							S32 size = toffset - string;
							char *arg = new char[size];
							bytestream2char(arg, buffer, string);
							// S32 length = strlen(arg);
							S32 dest;
							S32 base;

							// Check to see if this is a hexidecimal number.
							if (  (arg[0] == '0') &&
								  (arg[1] == 'x' || arg[1] == 'X') )
							{
								// Let strtoul do a hex conversion.
								base = 16;
							}
							else
							{
								// Force base-10, so octal is never used.
								base = 10;
							}

							dest = strtoul(arg, NULL, base);

							lscript_push(buffer, dest);
							delete [] arg;
						}
						lsa_decrease_ref_count(buffer, base_address);
					}
				}
				break;
			case LST_FLOATINGPOINT:
				{
					S32 base_address = lscript_pop_int(buffer);
	// this bit of nastiness is to get around that code paths to local variables can result in lack of initialization
	// and function clean up of ref counts isn't based on scope (a mistake, I know)
					S32 address = base_address + get_register(buffer, LREG_HR) - 1;
					if (address)
					{
						S32 string = address;
						string += SIZEOF_SCRIPT_ALLOC_ENTRY;
						if (safe_heap_check_address(buffer, string, 1))
						{
							S32 toffset = string;
							safe_heap_bytestream_count_char(buffer, toffset);
							S32 size = toffset - string;
							char *arg = new char[size];
							bytestream2char(arg, buffer, string);
							F32 dest = (F32)atof(arg);


							lscript_push(buffer, dest);
							delete [] arg;
						}
						lsa_decrease_ref_count(buffer, base_address);
					}
				}
				break;
			case LST_STRING:
				break;
			case LST_LIST:
				{
					S32 saddress = lscript_pop_int(buffer);
					LLScriptLibData *string = lsa_get_data(buffer, saddress, TRUE);
					LLScriptLibData *list = new LLScriptLibData;
					list->mType = LST_LIST;
					list->mListp = string;
					S32 address = lsa_heap_add_data(buffer, list, get_max_heap_size(buffer), TRUE);
					lscript_push(buffer, address);
				}
				break;
			case LST_VECTOR:
				{
					S32 base_address = lscript_pop_int(buffer);
	// this bit of nastiness is to get around that code paths to local variables can result in lack of initialization
	// and function clean up of ref counts isn't based on scope (a mistake, I know)
					S32 address = base_address + get_register(buffer, LREG_HR) - 1;
					if (address)
					{
						S32 string = address;
						string += SIZEOF_SCRIPT_ALLOC_ENTRY;
						if (safe_heap_check_address(buffer, string, 1))
						{
							S32 toffset = string;
							safe_heap_bytestream_count_char(buffer, toffset);
							S32 size = toffset - string;
							char *arg = new char[size];
							bytestream2char(arg, buffer, string);
							LLVector3 vec;
							S32 num = sscanf(arg, "<%f, %f, %f>", &vec.mV[VX], &vec.mV[VY], &vec.mV[VZ]);
							if (num != 3)
							{
								vec = LLVector3::zero;
							}
							lscript_push(buffer, vec);
							delete [] arg;
						}
						lsa_decrease_ref_count(buffer, base_address);
					}
				}
				break;
			case LST_QUATERNION:
				{
					S32 base_address = lscript_pop_int(buffer);
	// this bit of nastiness is to get around that code paths to local variables can result in lack of initialization
	// and function clean up of ref counts isn't based on scope (a mistake, I know)
					S32 address = base_address + get_register(buffer, LREG_HR) - 1;
					if (address)
					{
						S32 string = address;
						string += SIZEOF_SCRIPT_ALLOC_ENTRY;
						if (safe_heap_check_address(buffer, string, 1))
						{
							S32 toffset = string;
							safe_heap_bytestream_count_char(buffer, toffset);
							S32 size = toffset - string;
							char *arg = new char[size];
							bytestream2char(arg, buffer, string);
							LLQuaternion quat;
							S32 num = sscanf(arg, "<%f, %f, %f, %f>", &quat.mQ[VX], &quat.mQ[VY], &quat.mQ[VZ], &quat.mQ[VW]);
							if (num != 4)
							{
								quat = LLQuaternion::DEFAULT;

							}
							lscript_push(buffer, quat);
							delete [] arg;
						}
						lsa_decrease_ref_count(buffer, base_address);
					}
				}
				break;
			default:
				break;
			}
		}
		break;
	case LST_KEY:
		{
			switch(to)
			{
			case LST_KEY:
				break;
			case LST_STRING:
				break;
			case LST_LIST:
				{
					S32 saddress = lscript_pop_int(buffer);
					LLScriptLibData *string = lsa_get_data(buffer, saddress, TRUE);
					LLScriptLibData *list = new LLScriptLibData;
					list->mType = LST_LIST;
					list->mListp = string;
					S32 address = lsa_heap_add_data(buffer, list, get_max_heap_size(buffer), TRUE);
					lscript_push(buffer, address);
				}
				break;
			default:
				break;
			}
		}
		break;
	case LST_VECTOR:
		{
			switch(to)
			{
			case LST_VECTOR:
				break;
			case LST_STRING:
				{
					S32 address;
					LLVector3 source;
					lscript_pop_vector(buffer, source);
					snprintf(caststr, sizeof(caststr), "<%5.5f, %5.5f, %5.5f>", source.mV[VX], source.mV[VY], source.mV[VZ]);		/* Flawfinder: ignore */
					address = lsa_heap_add_data(buffer, new LLScriptLibData(caststr), get_max_heap_size(buffer), TRUE);
					lscript_push(buffer, address);
				}
				break;
			case LST_LIST:
				{
					S32 address;
					LLVector3 source;
					lscript_pop_vector(buffer, source);
					LLScriptLibData *list = new LLScriptLibData;
					list->mType = LST_LIST;
					list->mListp = new LLScriptLibData(source);
					address = lsa_heap_add_data(buffer, list, get_max_heap_size(buffer), TRUE);
					lscript_push(buffer, address);
				}
				break;
			default:
				break;
			}
		}
		break;
	case LST_QUATERNION:
		{
			switch(to)
			{
			case LST_QUATERNION:
				break;
			case LST_STRING:
				{
					S32 address;
					LLQuaternion source;
					lscript_pop_quaternion(buffer, source);
					snprintf(caststr, sizeof(caststr), "<%5.5f, %5.5f, %5.5f, %5.5f>", source.mQ[VX], source.mQ[VY], source.mQ[VZ], source.mQ[VS]);		/* Flawfinder: ignore */
					address = lsa_heap_add_data(buffer, new LLScriptLibData(caststr), get_max_heap_size(buffer), TRUE);
					lscript_push(buffer, address);
				}
				break;
			case LST_LIST:
				{
					S32 address;
					LLQuaternion source;
					lscript_pop_quaternion(buffer, source);
					LLScriptLibData *list = new LLScriptLibData;
					list->mType = LST_LIST;
					list->mListp = new LLScriptLibData(source);
					address = lsa_heap_add_data(buffer, list, get_max_heap_size(buffer), TRUE);
					lscript_push(buffer, address);
				}
				break;
			default:
				break;
			}
		}
		break;
	case LST_LIST:
		{
			switch(to)
			{
			case LST_LIST:
				break;
			case LST_STRING:
				{
					S32 address = lscript_pop_int(buffer);
					LLScriptLibData *list = lsa_get_data(buffer, address, TRUE);
					LLScriptLibData *list_root = list;

					std::ostringstream dest;
					while (list)
					{
						list->print(dest, FALSE);
						list = list->mListp;
					}
					delete list_root;
					char *tmp = strdup(dest.str().c_str());
					LLScriptLibData *string = new LLScriptLibData(tmp);
					free(tmp);
					tmp = NULL;
					S32 destaddress = lsa_heap_add_data(buffer, string, get_max_heap_size(buffer), TRUE);
					lscript_push(buffer, destaddress);
				}
				break;
			default:
				break;
			}
		}
		break;
		default:
			break;
	}
	return FALSE;
}

BOOL run_stacktos(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	offset++;
	S32 length = lscript_pop_int(buffer);
	S32 i;
	char *arg = new char[length];
	S32 fault;
	for (i = 0; i < length; i++)
	{
		fault = get_register(buffer, LREG_FR);
		if (fault)
			break;

		arg[length - i - 1] = lscript_pop_char(buffer);
	}
	S32 address = lsa_heap_add_data(buffer, new LLScriptLibData(arg), get_max_heap_size(buffer), TRUE);
	lscript_push(buffer, address);
	delete [] arg;
	return FALSE;
}

void lscript_stacktol_pop_variable(LLScriptLibData *data, U8 *buffer, char type)
{
	S32 address, string;
	S32 base_address;

	switch(type)
	{
	case LST_INTEGER:
		data->mType = LST_INTEGER;
		data->mInteger = lscript_pop_int(buffer);
		break;
	case LST_FLOATINGPOINT:
		data->mType = LST_FLOATINGPOINT;
		data->mFP = lscript_pop_float(buffer);
		break;
	case LST_KEY:
		data->mType = LST_KEY;

		base_address = lscript_pop_int(buffer);
	// this bit of nastiness is to get around that code paths to local variables can result in lack of initialization
	// and function clean up of ref counts isn't based on scope (a mistake, I know)
		address = base_address + get_register(buffer, LREG_HR) - 1;

		if (address)
		{
			string = address + SIZEOF_SCRIPT_ALLOC_ENTRY;
			if (safe_heap_check_address(buffer, string, 1))
			{
				S32 toffset = string;
				safe_heap_bytestream_count_char(buffer, toffset);
				S32 size = toffset - string;
				data->mKey = new char[size];
				bytestream2char(data->mKey, buffer, string);
			}
			lsa_decrease_ref_count(buffer, base_address);
		}
		else
		{
			data->mKey = new char[1];
			data->mKey[0] = 0;
		}
		break;
	case LST_STRING:
		data->mType = LST_STRING;

		base_address = lscript_pop_int(buffer);
	// this bit of nastiness is to get around that code paths to local variables can result in lack of initialization
	// and function clean up of ref counts isn't based on scope (a mistake, I know)
		address = base_address + get_register(buffer, LREG_HR) - 1;

		if (address)
		{
			string = address + SIZEOF_SCRIPT_ALLOC_ENTRY;
			if (safe_heap_check_address(buffer, string, 1))
			{
				S32 toffset = string;
				safe_heap_bytestream_count_char(buffer, toffset);
				S32 size = toffset - string;
				data->mString = new char[size];
				bytestream2char(data->mString, buffer, string);
			}
			lsa_decrease_ref_count(buffer, base_address);
		}
		else
		{
			data->mString = new char[1];
			data->mString[0] = 0;
		}
		break;
	case LST_VECTOR:
		data->mType = LST_VECTOR;
		lscript_pop_vector(buffer, data->mVec);
		break;
	case LST_QUATERNION:
		data->mType = LST_QUATERNION;
		lscript_pop_quaternion(buffer, data->mQuat);
		break;
	case LST_LIST:
		data->mType = LST_LIST;
		address = lscript_pop_int(buffer);
		data->mListp = lsa_get_data(buffer, address, TRUE);
		break;
	}
}

BOOL run_stacktol(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	offset++;
	S32 length = safe_instruction_bytestream2integer(buffer, offset);
	S32 i;
	S32 fault;

	S8 type;

	LLScriptLibData *data = new LLScriptLibData, *tail;
	data->mType = LST_LIST;

	for (i = 0; i < length; i++)
	{
		fault = get_register(buffer, LREG_FR);
		if (fault)
			break;

		type = lscript_pop_char(buffer);

		tail = new LLScriptLibData;

		lscript_stacktol_pop_variable(tail, buffer, type);

		tail->mListp = data->mListp;
		data->mListp = tail;
	}
	S32 address = lsa_heap_add_data(buffer,data, get_max_heap_size(buffer), TRUE);
	lscript_push(buffer, address);
	return FALSE;
}

BOOL run_print(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tPRINT ", offset);
	offset++;
	U8 type = safe_instruction_bytestream2byte(buffer, offset);
	if (b_print)
	{
		print_type(type);
		printf("\n");
	}
	switch(type)
	{
	case LST_INTEGER:
		{
			S32 source = lscript_pop_int(buffer);
			printf("%d\n", source);
		}
		break;
	case LST_FLOATINGPOINT:
		{
			F32 source = lscript_pop_float(buffer);
			printf("%f\n", source);
		}
		break;
	case LST_STRING:
		{
			S32 base_address = lscript_pop_int(buffer);
	// this bit of nastiness is to get around that code paths to local variables can result in lack of initialization
	// and function clean up of ref counts isn't based on scope (a mistake, I know)
			S32	address = base_address + get_register(buffer, LREG_HR) - 1;

			if (address)
			{
				S32 string = address;
				string += SIZEOF_SCRIPT_ALLOC_ENTRY;
				if (safe_heap_check_address(buffer, string, 1))
				{
					S32 toffset = string;
					safe_heap_bytestream_count_char(buffer, toffset);
					S32 size = toffset - string;
					char *arg = new char[size];
					bytestream2char(arg, buffer, string);
					printf("%s\n", arg);
					delete [] arg;
				}
				lsa_decrease_ref_count(buffer, base_address);
			}
		}
		break;
	case LST_VECTOR:
		{
			LLVector3 source;
			lscript_pop_vector(buffer, source);
			printf("< %f, %f, %f >\n", source.mV[VX], source.mV[VY], source.mV[VZ]);
		}
		break;
	case LST_QUATERNION:
		{
			LLQuaternion source;
			lscript_pop_quaternion(buffer, source);
			printf("< %f, %f, %f, %f >\n", source.mQ[VX], source.mQ[VY], source.mQ[VZ], source.mQ[VS]);
		}
		break;
	case LST_LIST:
		{
			S32 base_address = lscript_pop_int(buffer);
			LLScriptLibData *data = lsa_get_data(buffer, base_address, TRUE);
			LLScriptLibData *print = data;

			printf("list\n");

			while (print)
			{
				switch(print->mType)
				{
				case LST_INTEGER:
					{
						printf("%d\n", print->mInteger);
					}
					break;
				case LST_FLOATINGPOINT:
					{
						printf("%f\n", print->mFP);
					}
					break;
				case LST_STRING:
					{
						printf("%s\n", print->mString);
					}
					break;
				case LST_KEY:
					{
						printf("%s\n", print->mKey);
					}
					break;
				case LST_VECTOR:
					{
						printf("< %f, %f, %f >\n", print->mVec.mV[VX], print->mVec.mV[VY], print->mVec.mV[VZ]);
					}
					break;
				case LST_QUATERNION:
					{
						printf("< %f, %f, %f, %f >\n", print->mQuat.mQ[VX], print->mQuat.mQ[VY], print->mQuat.mQ[VZ], print->mQuat.mQ[VS]);
					}
					break;
				default:
					break;
				}
				print = print->mListp;
			}
			delete data;
		}
		break;
	default:
		break;
	}
	return FALSE;
}


void lscript_run(char *filename, BOOL b_debug)
{
	LLTimer	timer;
	if (filename == NULL)
	{
		llerrs << "filename is NULL" << llendl;
		// Just reporting error is likely not enough. Need
		// to check how to abort or error out gracefully
		// from this function. XXXTBD
	}
	else
	{
		char *error;
		BOOL b_state;
		LLScriptExecute *execute = NULL;

		FILE* file = LLFile::fopen(filename, "r");
		if (file)
		{
			execute = new LLScriptExecute(file);
			// note: LLScriptExecute() closes file for us
		}
		file = LLFile::fopen(filename, "r");
		if (file)
		{
			FILE* fp = LLFile::fopen("lscript.parse", "w");		/*Flawfinder: ignore*/
			LLScriptLSOParse *parse = new LLScriptLSOParse(file);
			parse->printData(fp);
			delete parse;
			fclose(file);
			fclose(fp);
		}
		file = LLFile::fopen(filename, "r");
		if (file && execute)
		{
			timer.reset();
			while (!execute->run(b_debug, LLUUID::null, &error, b_state))
				;
			F32 time = timer.getElapsedTimeF32();
			F32 ips = execute->mInstructionCount / time;
			llinfos << execute->mInstructionCount << " instructions in " << time << " seconds" << llendl;
			llinfos << ips/1000 << "K instructions per second" << llendl;
			printf("ip: 0x%X\n", get_register(execute->mBuffer, LREG_IP));
			printf("sp: 0x%X\n", get_register(execute->mBuffer, LREG_SP));
			printf("bp: 0x%X\n", get_register(execute->mBuffer, LREG_BP));
			printf("hr: 0x%X\n", get_register(execute->mBuffer, LREG_HR));
			printf("hp: 0x%X\n", get_register(execute->mBuffer, LREG_HP));
			delete execute;
			fclose(file);
		}
	}
}

void lscript_pop_variable(LLScriptLibData *data, U8 *buffer, char type)
{
	S32 address, string;
	S32 base_address;

	switch(type)
	{
	case 'i':
		data->mType = LST_INTEGER;
		data->mInteger = lscript_pop_int(buffer);
		break;
	case 'f':
		data->mType = LST_FLOATINGPOINT;
		data->mFP = lscript_pop_float(buffer);
		break;
	case 'k':
		data->mType = LST_KEY;

		base_address = lscript_pop_int(buffer);
	// this bit of nastiness is to get around that code paths to local variables can result in lack of initialization
	// and function clean up of ref counts isn't based on scope (a mistake, I know)
		address = base_address + get_register(buffer, LREG_HR) - 1;

		if (address)
		{
			string = address + SIZEOF_SCRIPT_ALLOC_ENTRY;
			if (safe_heap_check_address(buffer, string, 1))
			{
				S32 toffset = string;
				safe_heap_bytestream_count_char(buffer, toffset);
				S32 size = toffset - string;
				data->mKey = new char[size];
				bytestream2char(data->mKey, buffer, string);
			}
			lsa_decrease_ref_count(buffer, base_address);
		}
		else
		{
			data->mKey = new char[1];
			data->mKey[0] = 0;
		}
		break;
	case 's':
		data->mType = LST_STRING;

		base_address = lscript_pop_int(buffer);
	// this bit of nastiness is to get around that code paths to local variables can result in lack of initialization
	// and function clean up of ref counts isn't based on scope (a mistake, I know)
		address = base_address + get_register(buffer, LREG_HR) - 1;

		if (address)
		{
			string = address + SIZEOF_SCRIPT_ALLOC_ENTRY;
			if (safe_heap_check_address(buffer, string, 1))
			{
				S32 toffset = string;
				safe_heap_bytestream_count_char(buffer, toffset);
				S32 size = toffset - string;
				data->mString = new char[size];
				bytestream2char(data->mString, buffer, string);
			}
			lsa_decrease_ref_count(buffer, base_address);
		}
		else
		{
			data->mString = new char[1];
			data->mString[0] = 0;
		}
		break;
	case 'l':
		{
			S32 base_address = lscript_pop_int(buffer);
			data->mType = LST_LIST;
			data->mListp = lsa_get_list_ptr(buffer, base_address, TRUE);
		}
		break;
	case 'v':
		data->mType = LST_VECTOR;
		lscript_pop_vector(buffer, data->mVec);
		break;
	case 'q':
		data->mType = LST_QUATERNION;
		lscript_pop_quaternion(buffer, data->mQuat);
		break;
	}
}

void lscript_push_return_variable(LLScriptLibData *data, U8 *buffer)
{
	S32 address;
	switch(data->mType)
	{
	case LST_INTEGER:
		lscript_local_store(buffer, -12, data->mInteger);
		break;
	case LST_FLOATINGPOINT:
		lscript_local_store(buffer, -12, data->mFP);
		break;
	case LST_KEY:
		address = lsa_heap_add_data(buffer, data, get_max_heap_size(buffer), FALSE);
		lscript_local_store(buffer, -12, address);
		break;
	case LST_STRING:
		address = lsa_heap_add_data(buffer, data, get_max_heap_size(buffer), FALSE);
		lscript_local_store(buffer, -12, address);
		break;
	case LST_LIST:
		address = lsa_heap_add_data(buffer, data, get_max_heap_size(buffer), FALSE);
		lscript_local_store(buffer, -12, address);
		break;
	case LST_VECTOR:
		lscript_local_store(buffer, -20, data->mVec);
		break;
	case LST_QUATERNION:
		lscript_local_store(buffer, -24, data->mQuat);
		break;
	default:
		break;
	}
}

S32 lscript_push_variable(LLScriptLibData *data, U8 *buffer)
{
	S32 address;
	switch(data->mType)
	{
	case LST_INTEGER:
		lscript_push(buffer, data->mInteger);
		break;
	case LST_FLOATINGPOINT:
		lscript_push(buffer, data->mFP);
		return 4;
		break;
	case LST_KEY:
		address = lsa_heap_add_data(buffer, data, get_max_heap_size(buffer), FALSE);
		lscript_push(buffer, address);
		return 4;
		break;
	case LST_STRING:
		address = lsa_heap_add_data(buffer, data, get_max_heap_size(buffer), FALSE);
		lscript_push(buffer, address);
		return 4;
		break;
	case LST_LIST:
		address = lsa_heap_add_data(buffer, data, get_max_heap_size(buffer), FALSE);
		lscript_push(buffer, address);
		return 4;
		break;
	case LST_VECTOR:
		lscript_push(buffer, data->mVec);
		return 12;
		break;
	case LST_QUATERNION:
		lscript_push(buffer, data->mQuat);
		return 16;
		break;
	default:
		break;
	}
	return 4;
}

BOOL run_calllib(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tCALLLIB ", offset);
	offset++;
	U8 arg = safe_instruction_bytestream2byte(buffer, offset);
	if (arg >= gScriptLibrary.mNextNumber)
	{
		set_fault(buffer, LSRF_BOUND_CHECK_ERROR);
		return FALSE;
	}
	if (b_print)
		printf("%d (%s)\n", (U32)arg, gScriptLibrary.mFunctions[arg]->mName);

	// pull out the arguments and the return values
	LLScriptLibData	*arguments = NULL;
	LLScriptLibData	*returnvalue = NULL;

	S32 i, number;

	if (gScriptLibrary.mFunctions[arg]->mReturnType)
	{
		returnvalue = new LLScriptLibData;
	}

	if (gScriptLibrary.mFunctions[arg]->mArgs)
	{
		number = (S32)strlen(gScriptLibrary.mFunctions[arg]->mArgs);		/*Flawfinder: ignore*/
		arguments = new LLScriptLibData[number];
	}
	else
	{
		number = 0;
	}

	for (i = number - 1; i >= 0; i--)
	{
		lscript_pop_variable(&arguments[i], buffer, gScriptLibrary.mFunctions[arg]->mArgs[i]);
	}

	if (b_print)
	{
		printf("%s\n", gScriptLibrary.mFunctions[arg]->mDesc);
	}

	{
		// LLFastTimer time_in_libraries1(LLFastTimer::FTM_TEMP7);
		gScriptLibrary.mFunctions[arg]->mExecFunc(returnvalue, arguments, id);
	}
	add_register_fp(buffer, LREG_ESR, -gScriptLibrary.mFunctions[arg]->mEnergyUse);
	add_register_fp(buffer, LREG_SLR, gScriptLibrary.mFunctions[arg]->mSleepTime);

	if (returnvalue)
	{
		returnvalue->mType = char2type(*gScriptLibrary.mFunctions[arg]->mReturnType);
		lscript_push_return_variable(returnvalue, buffer);
	}

	delete [] arguments;
	delete returnvalue;

	// reset the BP after calling the library files
	S32 bp = lscript_pop_int(buffer);
	set_bp(buffer, bp);

	// pop off the spot for the instruction pointer
	lscript_poparg(buffer, 4);
	return FALSE;
}


BOOL run_calllib_two_byte(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
{
	if (b_print)
		printf("[0x%X]\tCALLLIB ", offset);
	offset++;
	U16 arg = safe_instruction_bytestream2u16(buffer, offset);
	if (arg >= gScriptLibrary.mNextNumber)
	{
		set_fault(buffer, LSRF_BOUND_CHECK_ERROR);
		return FALSE;
	}
	if (b_print)
		printf("%d (%s)\n", (U32)arg, gScriptLibrary.mFunctions[arg]->mName);

	// pull out the arguments and the return values
	LLScriptLibData	*arguments = NULL;
	LLScriptLibData	*returnvalue = NULL;

	S32 i, number;

	if (gScriptLibrary.mFunctions[arg]->mReturnType)
	{
		returnvalue = new LLScriptLibData;
	}

	if (gScriptLibrary.mFunctions[arg]->mArgs)
	{
		number = (S32)strlen(gScriptLibrary.mFunctions[arg]->mArgs);		/*Flawfinder: ignore*/
		arguments = new LLScriptLibData[number];
	}
	else
	{
		number = 0;
	}

	for (i = number - 1; i >= 0; i--)
	{
		lscript_pop_variable(&arguments[i], buffer, gScriptLibrary.mFunctions[arg]->mArgs[i]);
	}

	if (b_print)
	{
		printf("%s\n", gScriptLibrary.mFunctions[arg]->mDesc);
	}

	{
		// LLFastTimer time_in_libraries2(LLFastTimer::FTM_TEMP8);
		gScriptLibrary.mFunctions[arg]->mExecFunc(returnvalue, arguments, id);
	}
	add_register_fp(buffer, LREG_ESR, -gScriptLibrary.mFunctions[arg]->mEnergyUse);
	add_register_fp(buffer, LREG_SLR, gScriptLibrary.mFunctions[arg]->mSleepTime);

	if (returnvalue)
	{
		returnvalue->mType = char2type(*gScriptLibrary.mFunctions[arg]->mReturnType);
		lscript_push_return_variable(returnvalue, buffer);
	}

	delete [] arguments;
	delete returnvalue;

	// reset the BP after calling the library files
	S32 bp = lscript_pop_int(buffer);
	set_bp(buffer, bp);

	// pop off the spot for the instruction pointer
	lscript_poparg(buffer, 4);
	return FALSE;
}