ThreadManForUser.java

/* This autogenerated file is part of jpcsp. */
/*
This file is part of jpcsp.

Jpcsp is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

Jpcsp is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Jpcsp.  If not, see <http://www.gnu.org/licenses/>.
 */

package jpcsp.HLE.modules150;

import jpcsp.HLE.Modules;
import jpcsp.HLE.modules.HLEModule;
import jpcsp.HLE.modules.HLEModuleFunction;
import jpcsp.HLE.modules.HLEModuleManager;

import jpcsp.Memory;
import jpcsp.Processor;

import jpcsp.Allegrex.CpuState; // New-Style Processor

public class ThreadManForUser implements HLEModule {
	@Override
	public String getName() { return "ThreadManForUser"; }
	
	@Override
	public void installModule(HLEModuleManager mm, int version) {
		if (version >= 150) {
		
			mm.addFunction(_sceKernelReturnFromCallbackFunction, 0x6E9EA350);
			mm.addFunction(sceKernelRegisterThreadEventHandlerFunction, 0x0C106E53);
			mm.addFunction(sceKernelReleaseThreadEventHandlerFunction, 0x72F3C145);
			mm.addFunction(sceKernelReferThreadEventHandlerStatusFunction, 0x369EEB6B);
			mm.addFunction(sceKernelCreateCallbackFunction, 0xE81CAF8F);
			mm.addFunction(sceKernelDeleteCallbackFunction, 0xEDBA5844);
			mm.addFunction(sceKernelNotifyCallbackFunction, 0xC11BA8C4);
			mm.addFunction(sceKernelCancelCallbackFunction, 0xBA4051D6);
			mm.addFunction(sceKernelGetCallbackCountFunction, 0x2A3D44FF);
			mm.addFunction(sceKernelCheckCallbackFunction, 0x349D6D6C);
			mm.addFunction(sceKernelReferCallbackStatusFunction, 0x730ED8BC);
			mm.addFunction(sceKernelSleepThreadFunction, 0x9ACE131E);
			mm.addFunction(sceKernelSleepThreadCBFunction, 0x82826F70);
			mm.addFunction(sceKernelWakeupThreadFunction, 0xD59EAD2F);
			mm.addFunction(sceKernelCancelWakeupThreadFunction, 0xFCCFAD26);
			mm.addFunction(sceKernelSuspendThreadFunction, 0x9944F31F);
			mm.addFunction(sceKernelResumeThreadFunction, 0x75156E8F);
			mm.addFunction(sceKernelWaitThreadEndFunction, 0x278C0DF5);
			mm.addFunction(sceKernelWaitThreadEndCBFunction, 0x840E8133);
			mm.addFunction(sceKernelDelayThreadFunction, 0xCEADEB47);
			mm.addFunction(sceKernelDelayThreadCBFunction, 0x68DA9E36);
			mm.addFunction(sceKernelDelaySysClockThreadFunction, 0xBD123D9E);
			mm.addFunction(sceKernelDelaySysClockThreadCBFunction, 0x1181E963);
			mm.addFunction(sceKernelCreateSemaFunction, 0xD6DA4BA1);
			mm.addFunction(sceKernelDeleteSemaFunction, 0x28B6489C);
			mm.addFunction(sceKernelSignalSemaFunction, 0x3F53E640);
			mm.addFunction(sceKernelWaitSemaFunction, 0x4E3A1105);
			mm.addFunction(sceKernelWaitSemaCBFunction, 0x6D212BAC);
			mm.addFunction(sceKernelPollSemaFunction, 0x58B1F937);
			mm.addFunction(sceKernelCancelSemaFunction, 0x8FFDF9A2);
			mm.addFunction(sceKernelReferSemaStatusFunction, 0xBC6FEBC5);
			mm.addFunction(sceKernelCreateEventFlagFunction, 0x55C20A00);
			mm.addFunction(sceKernelDeleteEventFlagFunction, 0xEF9E4C70);
			mm.addFunction(sceKernelSetEventFlagFunction, 0x1FB15A32);
			mm.addFunction(sceKernelClearEventFlagFunction, 0x812346E4);
			mm.addFunction(sceKernelWaitEventFlagFunction, 0x402FCF22);
			mm.addFunction(sceKernelWaitEventFlagCBFunction, 0x328C546A);
			mm.addFunction(sceKernelPollEventFlagFunction, 0x30FD48F0);
			mm.addFunction(sceKernelCancelEventFlagFunction, 0xCD203292);
			mm.addFunction(sceKernelReferEventFlagStatusFunction, 0xA66B0120);
			mm.addFunction(sceKernelCreateMbxFunction, 0x8125221D);
			mm.addFunction(sceKernelDeleteMbxFunction, 0x86255ADA);
			mm.addFunction(sceKernelSendMbxFunction, 0xE9B3061E);
			mm.addFunction(sceKernelReceiveMbxFunction, 0x18260574);
			mm.addFunction(sceKernelReceiveMbxCBFunction, 0xF3986382);
			mm.addFunction(sceKernelPollMbxFunction, 0x0D81716A);
			mm.addFunction(sceKernelCancelReceiveMbxFunction, 0x87D4DD36);
			mm.addFunction(sceKernelReferMbxStatusFunction, 0xA8E8C846);
			mm.addFunction(sceKernelCreateMsgPipeFunction, 0x7C0DC2A0);
			mm.addFunction(sceKernelDeleteMsgPipeFunction, 0xF0B7DA1C);
			mm.addFunction(sceKernelSendMsgPipeFunction, 0x876DBFAD);
			mm.addFunction(sceKernelSendMsgPipeCBFunction, 0x7C41F2C2);
			mm.addFunction(sceKernelTrySendMsgPipeFunction, 0x884C9F90);
			mm.addFunction(sceKernelReceiveMsgPipeFunction, 0x74829B76);
			mm.addFunction(sceKernelReceiveMsgPipeCBFunction, 0xFBFA697D);
			mm.addFunction(sceKernelTryReceiveMsgPipeFunction, 0xDF52098F);
			mm.addFunction(sceKernelCancelMsgPipeFunction, 0x349B864D);
			mm.addFunction(sceKernelReferMsgPipeStatusFunction, 0x33BE4024);
			mm.addFunction(sceKernelCreateVplFunction, 0x56C039B5);
			mm.addFunction(sceKernelDeleteVplFunction, 0x89B3D48C);
			mm.addFunction(sceKernelAllocateVplFunction, 0xBED27435);
			mm.addFunction(sceKernelAllocateVplCBFunction, 0xEC0A693F);
			mm.addFunction(sceKernelTryAllocateVplFunction, 0xAF36D708);
			mm.addFunction(sceKernelFreeVplFunction, 0xB736E9FF);
			mm.addFunction(sceKernelCancelVplFunction, 0x1D371B8A);
			mm.addFunction(sceKernelReferVplStatusFunction, 0x39810265);
			mm.addFunction(sceKernelCreateFplFunction, 0xC07BB470);
			mm.addFunction(sceKernelDeleteFplFunction, 0xED1410E0);
			mm.addFunction(sceKernelAllocateFplFunction, 0xD979E9BF);
			mm.addFunction(sceKernelAllocateFplCBFunction, 0xE7282CB6);
			mm.addFunction(sceKernelTryAllocateFplFunction, 0x623AE665);
			mm.addFunction(sceKernelFreeFplFunction, 0xF6414A71);
			mm.addFunction(sceKernelCancelFplFunction, 0xA8AA591F);
			mm.addFunction(sceKernelReferFplStatusFunction, 0xD8199E4C);
			mm.addFunction(_sceKernelReturnFromTimerHandlerFunction, 0x0E927AED);
			mm.addFunction(sceKernelUSec2SysClockFunction, 0x110DEC9A);
			mm.addFunction(sceKernelUSec2SysClockWideFunction, 0xC8CD158C);
			mm.addFunction(sceKernelSysClock2USecFunction, 0xBA6B92E2);
			mm.addFunction(sceKernelSysClock2USecWideFunction, 0xE1619D7C);
			mm.addFunction(sceKernelGetSystemTimeFunction, 0xDB738F35);
			mm.addFunction(sceKernelGetSystemTimeWideFunction, 0x82BC5777);
			mm.addFunction(sceKernelGetSystemTimeLowFunction, 0x369ED59D);
			mm.addFunction(sceKernelSetAlarmFunction, 0x6652B8CA);
			mm.addFunction(sceKernelSetSysClockAlarmFunction, 0xB2C25152);
			mm.addFunction(sceKernelCancelAlarmFunction, 0x7E65B999);
			mm.addFunction(sceKernelReferAlarmStatusFunction, 0xDAA3F564);
			mm.addFunction(sceKernelCreateVTimerFunction, 0x20FFF560);
			mm.addFunction(sceKernelDeleteVTimerFunction, 0x328F9E52);
			mm.addFunction(sceKernelGetVTimerBaseFunction, 0xB3A59970);
			mm.addFunction(sceKernelGetVTimerBaseWideFunction, 0xB7C18B77);
			mm.addFunction(sceKernelGetVTimerTimeFunction, 0x034A921F);
			mm.addFunction(sceKernelGetVTimerTimeWideFunction, 0xC0B3FFD2);
			mm.addFunction(sceKernelSetVTimerTimeFunction, 0x542AD630);
			mm.addFunction(sceKernelSetVTimerTimeWideFunction, 0xFB6425C3);
			mm.addFunction(sceKernelStartVTimerFunction, 0xC68D9437);
			mm.addFunction(sceKernelStopVTimerFunction, 0xD0AEEE87);
			mm.addFunction(sceKernelSetVTimerHandlerFunction, 0xD8B299AE);
			mm.addFunction(sceKernelSetVTimerHandlerWideFunction, 0x53B00E9A);
			mm.addFunction(sceKernelCancelVTimerHandlerFunction, 0xD2D615EF);
			mm.addFunction(sceKernelReferVTimerStatusFunction, 0x5F32BEAA);
			mm.addFunction(sceKernelCreateThreadFunction, 0x446D8DE6);
			mm.addFunction(sceKernelDeleteThreadFunction, 0x9FA03CD3);
			mm.addFunction(sceKernelStartThreadFunction, 0xF475845D);
			mm.addFunction(_sceKernelExitThreadFunction, 0x532A522E);
			mm.addFunction(sceKernelExitThreadFunction, 0xAA73C935);
			mm.addFunction(sceKernelExitDeleteThreadFunction, 0x809CE29B);
			mm.addFunction(sceKernelTerminateThreadFunction, 0x616403BA);
			mm.addFunction(sceKernelTerminateDeleteThreadFunction, 0x383F7BCC);
			mm.addFunction(sceKernelSuspendDispatchThreadFunction, 0x3AD58B8C);
			mm.addFunction(sceKernelResumeDispatchThreadFunction, 0x27E22EC2);
			mm.addFunction(sceKernelChangeCurrentThreadAttrFunction, 0xEA748E31);
			mm.addFunction(sceKernelChangeThreadPriorityFunction, 0x71BC9871);
			mm.addFunction(sceKernelRotateThreadReadyQueueFunction, 0x912354A7);
			mm.addFunction(sceKernelReleaseWaitThreadFunction, 0x2C34E053);
			mm.addFunction(sceKernelGetThreadIdFunction, 0x293B45B8);
			mm.addFunction(sceKernelGetThreadCurrentPriorityFunction, 0x94AA61EE);
			mm.addFunction(sceKernelGetThreadExitStatusFunction, 0x3B183E26);
			mm.addFunction(sceKernelCheckThreadStackFunction, 0xD13BDE95);
			mm.addFunction(sceKernelGetThreadStackFreeSizeFunction, 0x52089CA1);
			mm.addFunction(sceKernelReferThreadStatusFunction, 0x17C1684E);
			mm.addFunction(sceKernelReferThreadRunStatusFunction, 0xFFC36A14);
			mm.addFunction(sceKernelReferSystemStatusFunction, 0x627E6F3A);
			mm.addFunction(sceKernelGetThreadmanIdListFunction, 0x94416130);
			mm.addFunction(sceKernelGetThreadmanIdTypeFunction, 0x57CF62DD);
			mm.addFunction(sceKernelReferThreadProfilerFunction, 0x64D4540E);
			mm.addFunction(sceKernelReferGlobalProfilerFunction, 0x8218B4DD);
			
		}
	}
	
	@Override
	public void uninstallModule(HLEModuleManager mm, int version) {
		if (version >= 150) {
		
			mm.removeFunction(_sceKernelReturnFromCallbackFunction);
			mm.removeFunction(sceKernelRegisterThreadEventHandlerFunction);
			mm.removeFunction(sceKernelReleaseThreadEventHandlerFunction);
			mm.removeFunction(sceKernelReferThreadEventHandlerStatusFunction);
			mm.removeFunction(sceKernelCreateCallbackFunction);
			mm.removeFunction(sceKernelDeleteCallbackFunction);
			mm.removeFunction(sceKernelNotifyCallbackFunction);
			mm.removeFunction(sceKernelCancelCallbackFunction);
			mm.removeFunction(sceKernelGetCallbackCountFunction);
			mm.removeFunction(sceKernelCheckCallbackFunction);
			mm.removeFunction(sceKernelReferCallbackStatusFunction);
			mm.removeFunction(sceKernelSleepThreadFunction);
			mm.removeFunction(sceKernelSleepThreadCBFunction);
			mm.removeFunction(sceKernelWakeupThreadFunction);
			mm.removeFunction(sceKernelCancelWakeupThreadFunction);
			mm.removeFunction(sceKernelSuspendThreadFunction);
			mm.removeFunction(sceKernelResumeThreadFunction);
			mm.removeFunction(sceKernelWaitThreadEndFunction);
			mm.removeFunction(sceKernelWaitThreadEndCBFunction);
			mm.removeFunction(sceKernelDelayThreadFunction);
			mm.removeFunction(sceKernelDelayThreadCBFunction);
			mm.removeFunction(sceKernelDelaySysClockThreadFunction);
			mm.removeFunction(sceKernelDelaySysClockThreadCBFunction);
			mm.removeFunction(sceKernelCreateSemaFunction);
			mm.removeFunction(sceKernelDeleteSemaFunction);
			mm.removeFunction(sceKernelSignalSemaFunction);
			mm.removeFunction(sceKernelWaitSemaFunction);
			mm.removeFunction(sceKernelWaitSemaCBFunction);
			mm.removeFunction(sceKernelPollSemaFunction);
			mm.removeFunction(sceKernelCancelSemaFunction);
			mm.removeFunction(sceKernelReferSemaStatusFunction);
			mm.removeFunction(sceKernelCreateEventFlagFunction);
			mm.removeFunction(sceKernelDeleteEventFlagFunction);
			mm.removeFunction(sceKernelSetEventFlagFunction);
			mm.removeFunction(sceKernelClearEventFlagFunction);
			mm.removeFunction(sceKernelWaitEventFlagFunction);
			mm.removeFunction(sceKernelWaitEventFlagCBFunction);
			mm.removeFunction(sceKernelPollEventFlagFunction);
			mm.removeFunction(sceKernelCancelEventFlagFunction);
			mm.removeFunction(sceKernelReferEventFlagStatusFunction);
			mm.removeFunction(sceKernelCreateMbxFunction);
			mm.removeFunction(sceKernelDeleteMbxFunction);
			mm.removeFunction(sceKernelSendMbxFunction);
			mm.removeFunction(sceKernelReceiveMbxFunction);
			mm.removeFunction(sceKernelReceiveMbxCBFunction);
			mm.removeFunction(sceKernelPollMbxFunction);
			mm.removeFunction(sceKernelCancelReceiveMbxFunction);
			mm.removeFunction(sceKernelReferMbxStatusFunction);
			mm.removeFunction(sceKernelCreateMsgPipeFunction);
			mm.removeFunction(sceKernelDeleteMsgPipeFunction);
			mm.removeFunction(sceKernelSendMsgPipeFunction);
			mm.removeFunction(sceKernelSendMsgPipeCBFunction);
			mm.removeFunction(sceKernelTrySendMsgPipeFunction);
			mm.removeFunction(sceKernelReceiveMsgPipeFunction);
			mm.removeFunction(sceKernelReceiveMsgPipeCBFunction);
			mm.removeFunction(sceKernelTryReceiveMsgPipeFunction);
			mm.removeFunction(sceKernelCancelMsgPipeFunction);
			mm.removeFunction(sceKernelReferMsgPipeStatusFunction);
			mm.removeFunction(sceKernelCreateVplFunction);
			mm.removeFunction(sceKernelDeleteVplFunction);
			mm.removeFunction(sceKernelAllocateVplFunction);
			mm.removeFunction(sceKernelAllocateVplCBFunction);
			mm.removeFunction(sceKernelTryAllocateVplFunction);
			mm.removeFunction(sceKernelFreeVplFunction);
			mm.removeFunction(sceKernelCancelVplFunction);
			mm.removeFunction(sceKernelReferVplStatusFunction);
			mm.removeFunction(sceKernelCreateFplFunction);
			mm.removeFunction(sceKernelDeleteFplFunction);
			mm.removeFunction(sceKernelAllocateFplFunction);
			mm.removeFunction(sceKernelAllocateFplCBFunction);
			mm.removeFunction(sceKernelTryAllocateFplFunction);
			mm.removeFunction(sceKernelFreeFplFunction);
			mm.removeFunction(sceKernelCancelFplFunction);
			mm.removeFunction(sceKernelReferFplStatusFunction);
			mm.removeFunction(_sceKernelReturnFromTimerHandlerFunction);
			mm.removeFunction(sceKernelUSec2SysClockFunction);
			mm.removeFunction(sceKernelUSec2SysClockWideFunction);
			mm.removeFunction(sceKernelSysClock2USecFunction);
			mm.removeFunction(sceKernelSysClock2USecWideFunction);
			mm.removeFunction(sceKernelGetSystemTimeFunction);
			mm.removeFunction(sceKernelGetSystemTimeWideFunction);
			mm.removeFunction(sceKernelGetSystemTimeLowFunction);
			mm.removeFunction(sceKernelSetAlarmFunction);
			mm.removeFunction(sceKernelSetSysClockAlarmFunction);
			mm.removeFunction(sceKernelCancelAlarmFunction);
			mm.removeFunction(sceKernelReferAlarmStatusFunction);
			mm.removeFunction(sceKernelCreateVTimerFunction);
			mm.removeFunction(sceKernelDeleteVTimerFunction);
			mm.removeFunction(sceKernelGetVTimerBaseFunction);
			mm.removeFunction(sceKernelGetVTimerBaseWideFunction);
			mm.removeFunction(sceKernelGetVTimerTimeFunction);
			mm.removeFunction(sceKernelGetVTimerTimeWideFunction);
			mm.removeFunction(sceKernelSetVTimerTimeFunction);
			mm.removeFunction(sceKernelSetVTimerTimeWideFunction);
			mm.removeFunction(sceKernelStartVTimerFunction);
			mm.removeFunction(sceKernelStopVTimerFunction);
			mm.removeFunction(sceKernelSetVTimerHandlerFunction);
			mm.removeFunction(sceKernelSetVTimerHandlerWideFunction);
			mm.removeFunction(sceKernelCancelVTimerHandlerFunction);
			mm.removeFunction(sceKernelReferVTimerStatusFunction);
			mm.removeFunction(sceKernelCreateThreadFunction);
			mm.removeFunction(sceKernelDeleteThreadFunction);
			mm.removeFunction(sceKernelStartThreadFunction);
			mm.removeFunction(_sceKernelExitThreadFunction);
			mm.removeFunction(sceKernelExitThreadFunction);
			mm.removeFunction(sceKernelExitDeleteThreadFunction);
			mm.removeFunction(sceKernelTerminateThreadFunction);
			mm.removeFunction(sceKernelTerminateDeleteThreadFunction);
			mm.removeFunction(sceKernelSuspendDispatchThreadFunction);
			mm.removeFunction(sceKernelResumeDispatchThreadFunction);
			mm.removeFunction(sceKernelChangeCurrentThreadAttrFunction);
			mm.removeFunction(sceKernelChangeThreadPriorityFunction);
			mm.removeFunction(sceKernelRotateThreadReadyQueueFunction);
			mm.removeFunction(sceKernelReleaseWaitThreadFunction);
			mm.removeFunction(sceKernelGetThreadIdFunction);
			mm.removeFunction(sceKernelGetThreadCurrentPriorityFunction);
			mm.removeFunction(sceKernelGetThreadExitStatusFunction);
			mm.removeFunction(sceKernelCheckThreadStackFunction);
			mm.removeFunction(sceKernelGetThreadStackFreeSizeFunction);
			mm.removeFunction(sceKernelReferThreadStatusFunction);
			mm.removeFunction(sceKernelReferThreadRunStatusFunction);
			mm.removeFunction(sceKernelReferSystemStatusFunction);
			mm.removeFunction(sceKernelGetThreadmanIdListFunction);
			mm.removeFunction(sceKernelGetThreadmanIdTypeFunction);
			mm.removeFunction(sceKernelReferThreadProfilerFunction);
			mm.removeFunction(sceKernelReferGlobalProfilerFunction);
			
		}
	}
	
	
	public void _sceKernelReturnFromCallback(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function _sceKernelReturnFromCallback [0x6E9EA350]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelRegisterThreadEventHandler(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelRegisterThreadEventHandler [0x0C106E53]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelReleaseThreadEventHandler(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelReleaseThreadEventHandler [0x72F3C145]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelReferThreadEventHandlerStatus(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelReferThreadEventHandlerStatus [0x369EEB6B]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelCreateCallback(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelCreateCallback [0xE81CAF8F]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelDeleteCallback(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelDeleteCallback [0xEDBA5844]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelNotifyCallback(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelNotifyCallback [0xC11BA8C4]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelCancelCallback(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelCancelCallback [0xBA4051D6]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelGetCallbackCount(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelGetCallbackCount [0x2A3D44FF]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelCheckCallback(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelCheckCallback [0x349D6D6C]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelReferCallbackStatus(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelReferCallbackStatus [0x730ED8BC]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelSleepThread(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelSleepThread [0x9ACE131E]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelSleepThreadCB(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelSleepThreadCB [0x82826F70]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelWakeupThread(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelWakeupThread [0xD59EAD2F]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelCancelWakeupThread(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelCancelWakeupThread [0xFCCFAD26]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelSuspendThread(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelSuspendThread [0x9944F31F]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelResumeThread(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelResumeThread [0x75156E8F]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelWaitThreadEnd(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelWaitThreadEnd [0x278C0DF5]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelWaitThreadEndCB(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelWaitThreadEndCB [0x840E8133]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelDelayThread(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelDelayThread [0xCEADEB47]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelDelayThreadCB(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelDelayThreadCB [0x68DA9E36]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelDelaySysClockThread(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelDelaySysClockThread [0xBD123D9E]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelDelaySysClockThreadCB(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelDelaySysClockThreadCB [0x1181E963]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelCreateSema(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelCreateSema [0xD6DA4BA1]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelDeleteSema(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelDeleteSema [0x28B6489C]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelSignalSema(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelSignalSema [0x3F53E640]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelWaitSema(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelWaitSema [0x4E3A1105]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelWaitSemaCB(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelWaitSemaCB [0x6D212BAC]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelPollSema(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelPollSema [0x58B1F937]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelCancelSema(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelCancelSema [0x8FFDF9A2]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelReferSemaStatus(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelReferSemaStatus [0xBC6FEBC5]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelCreateEventFlag(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelCreateEventFlag [0x55C20A00]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelDeleteEventFlag(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelDeleteEventFlag [0xEF9E4C70]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelSetEventFlag(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelSetEventFlag [0x1FB15A32]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelClearEventFlag(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelClearEventFlag [0x812346E4]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelWaitEventFlag(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelWaitEventFlag [0x402FCF22]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelWaitEventFlagCB(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelWaitEventFlagCB [0x328C546A]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelPollEventFlag(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelPollEventFlag [0x30FD48F0]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelCancelEventFlag(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelCancelEventFlag [0xCD203292]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelReferEventFlagStatus(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelReferEventFlagStatus [0xA66B0120]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelCreateMbx(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelCreateMbx [0x8125221D]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelDeleteMbx(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelDeleteMbx [0x86255ADA]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelSendMbx(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelSendMbx [0xE9B3061E]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelReceiveMbx(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelReceiveMbx [0x18260574]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelReceiveMbxCB(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelReceiveMbxCB [0xF3986382]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelPollMbx(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelPollMbx [0x0D81716A]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelCancelReceiveMbx(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelCancelReceiveMbx [0x87D4DD36]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelReferMbxStatus(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelReferMbxStatus [0xA8E8C846]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelCreateMsgPipe(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelCreateMsgPipe [0x7C0DC2A0]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelDeleteMsgPipe(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelDeleteMsgPipe [0xF0B7DA1C]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelSendMsgPipe(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelSendMsgPipe [0x876DBFAD]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelSendMsgPipeCB(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelSendMsgPipeCB [0x7C41F2C2]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelTrySendMsgPipe(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelTrySendMsgPipe [0x884C9F90]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelReceiveMsgPipe(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelReceiveMsgPipe [0x74829B76]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelReceiveMsgPipeCB(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelReceiveMsgPipeCB [0xFBFA697D]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelTryReceiveMsgPipe(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelTryReceiveMsgPipe [0xDF52098F]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelCancelMsgPipe(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelCancelMsgPipe [0x349B864D]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelReferMsgPipeStatus(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelReferMsgPipeStatus [0x33BE4024]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelCreateVpl(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelCreateVpl [0x56C039B5]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelDeleteVpl(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelDeleteVpl [0x89B3D48C]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelAllocateVpl(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelAllocateVpl [0xBED27435]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelAllocateVplCB(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelAllocateVplCB [0xEC0A693F]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelTryAllocateVpl(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelTryAllocateVpl [0xAF36D708]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelFreeVpl(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelFreeVpl [0xB736E9FF]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelCancelVpl(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelCancelVpl [0x1D371B8A]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelReferVplStatus(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelReferVplStatus [0x39810265]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelCreateFpl(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelCreateFpl [0xC07BB470]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelDeleteFpl(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelDeleteFpl [0xED1410E0]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelAllocateFpl(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelAllocateFpl [0xD979E9BF]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelAllocateFplCB(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelAllocateFplCB [0xE7282CB6]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelTryAllocateFpl(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelTryAllocateFpl [0x623AE665]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelFreeFpl(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelFreeFpl [0xF6414A71]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelCancelFpl(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelCancelFpl [0xA8AA591F]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelReferFplStatus(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelReferFplStatus [0xD8199E4C]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void _sceKernelReturnFromTimerHandler(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function _sceKernelReturnFromTimerHandler [0x0E927AED]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelUSec2SysClock(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelUSec2SysClock [0x110DEC9A]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelUSec2SysClockWide(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelUSec2SysClockWide [0xC8CD158C]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelSysClock2USec(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelSysClock2USec [0xBA6B92E2]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelSysClock2USecWide(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelSysClock2USecWide [0xE1619D7C]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelGetSystemTime(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelGetSystemTime [0xDB738F35]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelGetSystemTimeWide(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelGetSystemTimeWide [0x82BC5777]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelGetSystemTimeLow(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelGetSystemTimeLow [0x369ED59D]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelSetAlarm(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelSetAlarm [0x6652B8CA]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelSetSysClockAlarm(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelSetSysClockAlarm [0xB2C25152]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelCancelAlarm(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelCancelAlarm [0x7E65B999]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelReferAlarmStatus(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelReferAlarmStatus [0xDAA3F564]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelCreateVTimer(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelCreateVTimer [0x20FFF560]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelDeleteVTimer(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelDeleteVTimer [0x328F9E52]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelGetVTimerBase(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelGetVTimerBase [0xB3A59970]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelGetVTimerBaseWide(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelGetVTimerBaseWide [0xB7C18B77]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelGetVTimerTime(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelGetVTimerTime [0x034A921F]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelGetVTimerTimeWide(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelGetVTimerTimeWide [0xC0B3FFD2]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelSetVTimerTime(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelSetVTimerTime [0x542AD630]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelSetVTimerTimeWide(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelSetVTimerTimeWide [0xFB6425C3]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelStartVTimer(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelStartVTimer [0xC68D9437]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelStopVTimer(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelStopVTimer [0xD0AEEE87]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelSetVTimerHandler(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelSetVTimerHandler [0xD8B299AE]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelSetVTimerHandlerWide(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelSetVTimerHandlerWide [0x53B00E9A]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelCancelVTimerHandler(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelCancelVTimerHandler [0xD2D615EF]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelReferVTimerStatus(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelReferVTimerStatus [0x5F32BEAA]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelCreateThread(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelCreateThread [0x446D8DE6]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelDeleteThread(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelDeleteThread [0x9FA03CD3]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelStartThread(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelStartThread [0xF475845D]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void _sceKernelExitThread(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function _sceKernelExitThread [0x532A522E]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelExitThread(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelExitThread [0xAA73C935]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelExitDeleteThread(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelExitDeleteThread [0x809CE29B]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelTerminateThread(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelTerminateThread [0x616403BA]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelTerminateDeleteThread(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelTerminateDeleteThread [0x383F7BCC]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelSuspendDispatchThread(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelSuspendDispatchThread [0x3AD58B8C]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelResumeDispatchThread(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelResumeDispatchThread [0x27E22EC2]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelChangeCurrentThreadAttr(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelChangeCurrentThreadAttr [0xEA748E31]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelChangeThreadPriority(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelChangeThreadPriority [0x71BC9871]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelRotateThreadReadyQueue(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelRotateThreadReadyQueue [0x912354A7]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelReleaseWaitThread(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelReleaseWaitThread [0x2C34E053]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelGetThreadId(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelGetThreadId [0x293B45B8]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelGetThreadCurrentPriority(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelGetThreadCurrentPriority [0x94AA61EE]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelGetThreadExitStatus(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelGetThreadExitStatus [0x3B183E26]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelCheckThreadStack(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelCheckThreadStack [0xD13BDE95]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelGetThreadStackFreeSize(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelGetThreadStackFreeSize [0x52089CA1]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelReferThreadStatus(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelReferThreadStatus [0x17C1684E]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelReferThreadRunStatus(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelReferThreadRunStatus [0xFFC36A14]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelReferSystemStatus(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelReferSystemStatus [0x627E6F3A]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelGetThreadmanIdList(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelGetThreadmanIdList [0x94416130]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelGetThreadmanIdType(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelGetThreadmanIdType [0x57CF62DD]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelReferThreadProfiler(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelReferThreadProfiler [0x64D4540E]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public void sceKernelReferGlobalProfiler(Processor processor) {
		CpuState cpu = processor.cpu;

		Modules.log.debug("Unimplemented NID function sceKernelReferGlobalProfiler [0x8218B4DD]");

		cpu.gpr[2] = 0xDEADC0DE;
	}
    
	public final HLEModuleFunction _sceKernelReturnFromCallbackFunction = new HLEModuleFunction("ThreadManForUser", "_sceKernelReturnFromCallback") {
		@Override
		public final void execute(Processor processor) {
			_sceKernelReturnFromCallback(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule._sceKernelReturnFromCallback(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelRegisterThreadEventHandlerFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelRegisterThreadEventHandler") {
		@Override
		public final void execute(Processor processor) {
			sceKernelRegisterThreadEventHandler(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelRegisterThreadEventHandler(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelReleaseThreadEventHandlerFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelReleaseThreadEventHandler") {
		@Override
		public final void execute(Processor processor) {
			sceKernelReleaseThreadEventHandler(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelReleaseThreadEventHandler(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelReferThreadEventHandlerStatusFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelReferThreadEventHandlerStatus") {
		@Override
		public final void execute(Processor processor) {
			sceKernelReferThreadEventHandlerStatus(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelReferThreadEventHandlerStatus(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelCreateCallbackFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelCreateCallback") {
		@Override
		public final void execute(Processor processor) {
			sceKernelCreateCallback(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelCreateCallback(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelDeleteCallbackFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelDeleteCallback") {
		@Override
		public final void execute(Processor processor) {
			sceKernelDeleteCallback(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelDeleteCallback(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelNotifyCallbackFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelNotifyCallback") {
		@Override
		public final void execute(Processor processor) {
			sceKernelNotifyCallback(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelNotifyCallback(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelCancelCallbackFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelCancelCallback") {
		@Override
		public final void execute(Processor processor) {
			sceKernelCancelCallback(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelCancelCallback(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelGetCallbackCountFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelGetCallbackCount") {
		@Override
		public final void execute(Processor processor) {
			sceKernelGetCallbackCount(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelGetCallbackCount(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelCheckCallbackFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelCheckCallback") {
		@Override
		public final void execute(Processor processor) {
			sceKernelCheckCallback(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelCheckCallback(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelReferCallbackStatusFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelReferCallbackStatus") {
		@Override
		public final void execute(Processor processor) {
			sceKernelReferCallbackStatus(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelReferCallbackStatus(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelSleepThreadFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelSleepThread") {
		@Override
		public final void execute(Processor processor) {
			sceKernelSleepThread(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelSleepThread(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelSleepThreadCBFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelSleepThreadCB") {
		@Override
		public final void execute(Processor processor) {
			sceKernelSleepThreadCB(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelSleepThreadCB(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelWakeupThreadFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelWakeupThread") {
		@Override
		public final void execute(Processor processor) {
			sceKernelWakeupThread(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelWakeupThread(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelCancelWakeupThreadFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelCancelWakeupThread") {
		@Override
		public final void execute(Processor processor) {
			sceKernelCancelWakeupThread(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelCancelWakeupThread(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelSuspendThreadFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelSuspendThread") {
		@Override
		public final void execute(Processor processor) {
			sceKernelSuspendThread(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelSuspendThread(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelResumeThreadFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelResumeThread") {
		@Override
		public final void execute(Processor processor) {
			sceKernelResumeThread(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelResumeThread(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelWaitThreadEndFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelWaitThreadEnd") {
		@Override
		public final void execute(Processor processor) {
			sceKernelWaitThreadEnd(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelWaitThreadEnd(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelWaitThreadEndCBFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelWaitThreadEndCB") {
		@Override
		public final void execute(Processor processor) {
			sceKernelWaitThreadEndCB(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelWaitThreadEndCB(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelDelayThreadFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelDelayThread") {
		@Override
		public final void execute(Processor processor) {
			sceKernelDelayThread(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelDelayThread(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelDelayThreadCBFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelDelayThreadCB") {
		@Override
		public final void execute(Processor processor) {
			sceKernelDelayThreadCB(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelDelayThreadCB(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelDelaySysClockThreadFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelDelaySysClockThread") {
		@Override
		public final void execute(Processor processor) {
			sceKernelDelaySysClockThread(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelDelaySysClockThread(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelDelaySysClockThreadCBFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelDelaySysClockThreadCB") {
		@Override
		public final void execute(Processor processor) {
			sceKernelDelaySysClockThreadCB(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelDelaySysClockThreadCB(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelCreateSemaFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelCreateSema") {
		@Override
		public final void execute(Processor processor) {
			sceKernelCreateSema(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelCreateSema(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelDeleteSemaFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelDeleteSema") {
		@Override
		public final void execute(Processor processor) {
			sceKernelDeleteSema(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelDeleteSema(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelSignalSemaFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelSignalSema") {
		@Override
		public final void execute(Processor processor) {
			sceKernelSignalSema(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelSignalSema(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelWaitSemaFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelWaitSema") {
		@Override
		public final void execute(Processor processor) {
			sceKernelWaitSema(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelWaitSema(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelWaitSemaCBFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelWaitSemaCB") {
		@Override
		public final void execute(Processor processor) {
			sceKernelWaitSemaCB(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelWaitSemaCB(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelPollSemaFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelPollSema") {
		@Override
		public final void execute(Processor processor) {
			sceKernelPollSema(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelPollSema(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelCancelSemaFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelCancelSema") {
		@Override
		public final void execute(Processor processor) {
			sceKernelCancelSema(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelCancelSema(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelReferSemaStatusFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelReferSemaStatus") {
		@Override
		public final void execute(Processor processor) {
			sceKernelReferSemaStatus(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelReferSemaStatus(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelCreateEventFlagFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelCreateEventFlag") {
		@Override
		public final void execute(Processor processor) {
			sceKernelCreateEventFlag(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelCreateEventFlag(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelDeleteEventFlagFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelDeleteEventFlag") {
		@Override
		public final void execute(Processor processor) {
			sceKernelDeleteEventFlag(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelDeleteEventFlag(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelSetEventFlagFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelSetEventFlag") {
		@Override
		public final void execute(Processor processor) {
			sceKernelSetEventFlag(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelSetEventFlag(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelClearEventFlagFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelClearEventFlag") {
		@Override
		public final void execute(Processor processor) {
			sceKernelClearEventFlag(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelClearEventFlag(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelWaitEventFlagFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelWaitEventFlag") {
		@Override
		public final void execute(Processor processor) {
			sceKernelWaitEventFlag(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelWaitEventFlag(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelWaitEventFlagCBFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelWaitEventFlagCB") {
		@Override
		public final void execute(Processor processor) {
			sceKernelWaitEventFlagCB(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelWaitEventFlagCB(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelPollEventFlagFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelPollEventFlag") {
		@Override
		public final void execute(Processor processor) {
			sceKernelPollEventFlag(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelPollEventFlag(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelCancelEventFlagFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelCancelEventFlag") {
		@Override
		public final void execute(Processor processor) {
			sceKernelCancelEventFlag(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelCancelEventFlag(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelReferEventFlagStatusFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelReferEventFlagStatus") {
		@Override
		public final void execute(Processor processor) {
			sceKernelReferEventFlagStatus(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelReferEventFlagStatus(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelCreateMbxFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelCreateMbx") {
		@Override
		public final void execute(Processor processor) {
			sceKernelCreateMbx(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelCreateMbx(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelDeleteMbxFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelDeleteMbx") {
		@Override
		public final void execute(Processor processor) {
			sceKernelDeleteMbx(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelDeleteMbx(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelSendMbxFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelSendMbx") {
		@Override
		public final void execute(Processor processor) {
			sceKernelSendMbx(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelSendMbx(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelReceiveMbxFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelReceiveMbx") {
		@Override
		public final void execute(Processor processor) {
			sceKernelReceiveMbx(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelReceiveMbx(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelReceiveMbxCBFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelReceiveMbxCB") {
		@Override
		public final void execute(Processor processor) {
			sceKernelReceiveMbxCB(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelReceiveMbxCB(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelPollMbxFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelPollMbx") {
		@Override
		public final void execute(Processor processor) {
			sceKernelPollMbx(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelPollMbx(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelCancelReceiveMbxFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelCancelReceiveMbx") {
		@Override
		public final void execute(Processor processor) {
			sceKernelCancelReceiveMbx(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelCancelReceiveMbx(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelReferMbxStatusFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelReferMbxStatus") {
		@Override
		public final void execute(Processor processor) {
			sceKernelReferMbxStatus(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelReferMbxStatus(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelCreateMsgPipeFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelCreateMsgPipe") {
		@Override
		public final void execute(Processor processor) {
			sceKernelCreateMsgPipe(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelCreateMsgPipe(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelDeleteMsgPipeFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelDeleteMsgPipe") {
		@Override
		public final void execute(Processor processor) {
			sceKernelDeleteMsgPipe(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelDeleteMsgPipe(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelSendMsgPipeFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelSendMsgPipe") {
		@Override
		public final void execute(Processor processor) {
			sceKernelSendMsgPipe(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelSendMsgPipe(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelSendMsgPipeCBFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelSendMsgPipeCB") {
		@Override
		public final void execute(Processor processor) {
			sceKernelSendMsgPipeCB(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelSendMsgPipeCB(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelTrySendMsgPipeFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelTrySendMsgPipe") {
		@Override
		public final void execute(Processor processor) {
			sceKernelTrySendMsgPipe(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelTrySendMsgPipe(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelReceiveMsgPipeFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelReceiveMsgPipe") {
		@Override
		public final void execute(Processor processor) {
			sceKernelReceiveMsgPipe(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelReceiveMsgPipe(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelReceiveMsgPipeCBFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelReceiveMsgPipeCB") {
		@Override
		public final void execute(Processor processor) {
			sceKernelReceiveMsgPipeCB(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelReceiveMsgPipeCB(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelTryReceiveMsgPipeFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelTryReceiveMsgPipe") {
		@Override
		public final void execute(Processor processor) {
			sceKernelTryReceiveMsgPipe(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelTryReceiveMsgPipe(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelCancelMsgPipeFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelCancelMsgPipe") {
		@Override
		public final void execute(Processor processor) {
			sceKernelCancelMsgPipe(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelCancelMsgPipe(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelReferMsgPipeStatusFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelReferMsgPipeStatus") {
		@Override
		public final void execute(Processor processor) {
			sceKernelReferMsgPipeStatus(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelReferMsgPipeStatus(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelCreateVplFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelCreateVpl") {
		@Override
		public final void execute(Processor processor) {
			sceKernelCreateVpl(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelCreateVpl(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelDeleteVplFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelDeleteVpl") {
		@Override
		public final void execute(Processor processor) {
			sceKernelDeleteVpl(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelDeleteVpl(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelAllocateVplFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelAllocateVpl") {
		@Override
		public final void execute(Processor processor) {
			sceKernelAllocateVpl(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelAllocateVpl(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelAllocateVplCBFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelAllocateVplCB") {
		@Override
		public final void execute(Processor processor) {
			sceKernelAllocateVplCB(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelAllocateVplCB(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelTryAllocateVplFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelTryAllocateVpl") {
		@Override
		public final void execute(Processor processor) {
			sceKernelTryAllocateVpl(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelTryAllocateVpl(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelFreeVplFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelFreeVpl") {
		@Override
		public final void execute(Processor processor) {
			sceKernelFreeVpl(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelFreeVpl(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelCancelVplFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelCancelVpl") {
		@Override
		public final void execute(Processor processor) {
			sceKernelCancelVpl(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelCancelVpl(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelReferVplStatusFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelReferVplStatus") {
		@Override
		public final void execute(Processor processor) {
			sceKernelReferVplStatus(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelReferVplStatus(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelCreateFplFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelCreateFpl") {
		@Override
		public final void execute(Processor processor) {
			sceKernelCreateFpl(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelCreateFpl(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelDeleteFplFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelDeleteFpl") {
		@Override
		public final void execute(Processor processor) {
			sceKernelDeleteFpl(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelDeleteFpl(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelAllocateFplFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelAllocateFpl") {
		@Override
		public final void execute(Processor processor) {
			sceKernelAllocateFpl(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelAllocateFpl(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelAllocateFplCBFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelAllocateFplCB") {
		@Override
		public final void execute(Processor processor) {
			sceKernelAllocateFplCB(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelAllocateFplCB(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelTryAllocateFplFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelTryAllocateFpl") {
		@Override
		public final void execute(Processor processor) {
			sceKernelTryAllocateFpl(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelTryAllocateFpl(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelFreeFplFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelFreeFpl") {
		@Override
		public final void execute(Processor processor) {
			sceKernelFreeFpl(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelFreeFpl(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelCancelFplFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelCancelFpl") {
		@Override
		public final void execute(Processor processor) {
			sceKernelCancelFpl(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelCancelFpl(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelReferFplStatusFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelReferFplStatus") {
		@Override
		public final void execute(Processor processor) {
			sceKernelReferFplStatus(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelReferFplStatus(processor);";
		}
	};
    
	public final HLEModuleFunction _sceKernelReturnFromTimerHandlerFunction = new HLEModuleFunction("ThreadManForUser", "_sceKernelReturnFromTimerHandler") {
		@Override
		public final void execute(Processor processor) {
			_sceKernelReturnFromTimerHandler(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule._sceKernelReturnFromTimerHandler(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelUSec2SysClockFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelUSec2SysClock") {
		@Override
		public final void execute(Processor processor) {
			sceKernelUSec2SysClock(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelUSec2SysClock(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelUSec2SysClockWideFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelUSec2SysClockWide") {
		@Override
		public final void execute(Processor processor) {
			sceKernelUSec2SysClockWide(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelUSec2SysClockWide(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelSysClock2USecFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelSysClock2USec") {
		@Override
		public final void execute(Processor processor) {
			sceKernelSysClock2USec(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelSysClock2USec(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelSysClock2USecWideFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelSysClock2USecWide") {
		@Override
		public final void execute(Processor processor) {
			sceKernelSysClock2USecWide(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelSysClock2USecWide(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelGetSystemTimeFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelGetSystemTime") {
		@Override
		public final void execute(Processor processor) {
			sceKernelGetSystemTime(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelGetSystemTime(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelGetSystemTimeWideFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelGetSystemTimeWide") {
		@Override
		public final void execute(Processor processor) {
			sceKernelGetSystemTimeWide(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelGetSystemTimeWide(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelGetSystemTimeLowFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelGetSystemTimeLow") {
		@Override
		public final void execute(Processor processor) {
			sceKernelGetSystemTimeLow(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelGetSystemTimeLow(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelSetAlarmFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelSetAlarm") {
		@Override
		public final void execute(Processor processor) {
			sceKernelSetAlarm(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelSetAlarm(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelSetSysClockAlarmFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelSetSysClockAlarm") {
		@Override
		public final void execute(Processor processor) {
			sceKernelSetSysClockAlarm(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelSetSysClockAlarm(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelCancelAlarmFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelCancelAlarm") {
		@Override
		public final void execute(Processor processor) {
			sceKernelCancelAlarm(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelCancelAlarm(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelReferAlarmStatusFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelReferAlarmStatus") {
		@Override
		public final void execute(Processor processor) {
			sceKernelReferAlarmStatus(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelReferAlarmStatus(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelCreateVTimerFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelCreateVTimer") {
		@Override
		public final void execute(Processor processor) {
			sceKernelCreateVTimer(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelCreateVTimer(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelDeleteVTimerFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelDeleteVTimer") {
		@Override
		public final void execute(Processor processor) {
			sceKernelDeleteVTimer(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelDeleteVTimer(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelGetVTimerBaseFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelGetVTimerBase") {
		@Override
		public final void execute(Processor processor) {
			sceKernelGetVTimerBase(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelGetVTimerBase(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelGetVTimerBaseWideFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelGetVTimerBaseWide") {
		@Override
		public final void execute(Processor processor) {
			sceKernelGetVTimerBaseWide(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelGetVTimerBaseWide(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelGetVTimerTimeFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelGetVTimerTime") {
		@Override
		public final void execute(Processor processor) {
			sceKernelGetVTimerTime(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelGetVTimerTime(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelGetVTimerTimeWideFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelGetVTimerTimeWide") {
		@Override
		public final void execute(Processor processor) {
			sceKernelGetVTimerTimeWide(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelGetVTimerTimeWide(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelSetVTimerTimeFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelSetVTimerTime") {
		@Override
		public final void execute(Processor processor) {
			sceKernelSetVTimerTime(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelSetVTimerTime(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelSetVTimerTimeWideFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelSetVTimerTimeWide") {
		@Override
		public final void execute(Processor processor) {
			sceKernelSetVTimerTimeWide(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelSetVTimerTimeWide(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelStartVTimerFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelStartVTimer") {
		@Override
		public final void execute(Processor processor) {
			sceKernelStartVTimer(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelStartVTimer(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelStopVTimerFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelStopVTimer") {
		@Override
		public final void execute(Processor processor) {
			sceKernelStopVTimer(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelStopVTimer(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelSetVTimerHandlerFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelSetVTimerHandler") {
		@Override
		public final void execute(Processor processor) {
			sceKernelSetVTimerHandler(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelSetVTimerHandler(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelSetVTimerHandlerWideFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelSetVTimerHandlerWide") {
		@Override
		public final void execute(Processor processor) {
			sceKernelSetVTimerHandlerWide(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelSetVTimerHandlerWide(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelCancelVTimerHandlerFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelCancelVTimerHandler") {
		@Override
		public final void execute(Processor processor) {
			sceKernelCancelVTimerHandler(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelCancelVTimerHandler(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelReferVTimerStatusFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelReferVTimerStatus") {
		@Override
		public final void execute(Processor processor) {
			sceKernelReferVTimerStatus(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelReferVTimerStatus(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelCreateThreadFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelCreateThread") {
		@Override
		public final void execute(Processor processor) {
			sceKernelCreateThread(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelCreateThread(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelDeleteThreadFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelDeleteThread") {
		@Override
		public final void execute(Processor processor) {
			sceKernelDeleteThread(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelDeleteThread(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelStartThreadFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelStartThread") {
		@Override
		public final void execute(Processor processor) {
			sceKernelStartThread(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelStartThread(processor);";
		}
	};
    
	public final HLEModuleFunction _sceKernelExitThreadFunction = new HLEModuleFunction("ThreadManForUser", "_sceKernelExitThread") {
		@Override
		public final void execute(Processor processor) {
			_sceKernelExitThread(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule._sceKernelExitThread(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelExitThreadFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelExitThread") {
		@Override
		public final void execute(Processor processor) {
			sceKernelExitThread(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelExitThread(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelExitDeleteThreadFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelExitDeleteThread") {
		@Override
		public final void execute(Processor processor) {
			sceKernelExitDeleteThread(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelExitDeleteThread(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelTerminateThreadFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelTerminateThread") {
		@Override
		public final void execute(Processor processor) {
			sceKernelTerminateThread(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelTerminateThread(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelTerminateDeleteThreadFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelTerminateDeleteThread") {
		@Override
		public final void execute(Processor processor) {
			sceKernelTerminateDeleteThread(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelTerminateDeleteThread(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelSuspendDispatchThreadFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelSuspendDispatchThread") {
		@Override
		public final void execute(Processor processor) {
			sceKernelSuspendDispatchThread(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelSuspendDispatchThread(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelResumeDispatchThreadFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelResumeDispatchThread") {
		@Override
		public final void execute(Processor processor) {
			sceKernelResumeDispatchThread(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelResumeDispatchThread(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelChangeCurrentThreadAttrFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelChangeCurrentThreadAttr") {
		@Override
		public final void execute(Processor processor) {
			sceKernelChangeCurrentThreadAttr(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelChangeCurrentThreadAttr(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelChangeThreadPriorityFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelChangeThreadPriority") {
		@Override
		public final void execute(Processor processor) {
			sceKernelChangeThreadPriority(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelChangeThreadPriority(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelRotateThreadReadyQueueFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelRotateThreadReadyQueue") {
		@Override
		public final void execute(Processor processor) {
			sceKernelRotateThreadReadyQueue(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelRotateThreadReadyQueue(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelReleaseWaitThreadFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelReleaseWaitThread") {
		@Override
		public final void execute(Processor processor) {
			sceKernelReleaseWaitThread(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelReleaseWaitThread(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelGetThreadIdFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelGetThreadId") {
		@Override
		public final void execute(Processor processor) {
			sceKernelGetThreadId(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelGetThreadId(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelGetThreadCurrentPriorityFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelGetThreadCurrentPriority") {
		@Override
		public final void execute(Processor processor) {
			sceKernelGetThreadCurrentPriority(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelGetThreadCurrentPriority(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelGetThreadExitStatusFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelGetThreadExitStatus") {
		@Override
		public final void execute(Processor processor) {
			sceKernelGetThreadExitStatus(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelGetThreadExitStatus(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelCheckThreadStackFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelCheckThreadStack") {
		@Override
		public final void execute(Processor processor) {
			sceKernelCheckThreadStack(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelCheckThreadStack(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelGetThreadStackFreeSizeFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelGetThreadStackFreeSize") {
		@Override
		public final void execute(Processor processor) {
			sceKernelGetThreadStackFreeSize(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelGetThreadStackFreeSize(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelReferThreadStatusFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelReferThreadStatus") {
		@Override
		public final void execute(Processor processor) {
			sceKernelReferThreadStatus(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelReferThreadStatus(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelReferThreadRunStatusFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelReferThreadRunStatus") {
		@Override
		public final void execute(Processor processor) {
			sceKernelReferThreadRunStatus(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelReferThreadRunStatus(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelReferSystemStatusFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelReferSystemStatus") {
		@Override
		public final void execute(Processor processor) {
			sceKernelReferSystemStatus(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelReferSystemStatus(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelGetThreadmanIdListFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelGetThreadmanIdList") {
		@Override
		public final void execute(Processor processor) {
			sceKernelGetThreadmanIdList(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelGetThreadmanIdList(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelGetThreadmanIdTypeFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelGetThreadmanIdType") {
		@Override
		public final void execute(Processor processor) {
			sceKernelGetThreadmanIdType(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelGetThreadmanIdType(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelReferThreadProfilerFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelReferThreadProfiler") {
		@Override
		public final void execute(Processor processor) {
			sceKernelReferThreadProfiler(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelReferThreadProfiler(processor);";
		}
	};
    
	public final HLEModuleFunction sceKernelReferGlobalProfilerFunction = new HLEModuleFunction("ThreadManForUser", "sceKernelReferGlobalProfiler") {
		@Override
		public final void execute(Processor processor) {
			sceKernelReferGlobalProfiler(processor);
		}
		@Override
		public final String compiledString() {
			return "jpcsp.HLE.Modules.ThreadManForUserModule.sceKernelReferGlobalProfiler(processor);";
		}
	};
    
};