Constant Write Commands
Code type Format Description

8-bit Constant
Write 0x0aaaaaaa 0x000000dd This command will constantly write the value specified by dd to the address specified by aaaaaaa

16-bit Constant
Write 0x1aaaaaaa 0x0000dddd This command will constantly write the value specified by dddd to the address specified by aaaaaaa

32-bit Constant
Write 0x2aaaaaaa 0xdddddddd This command will constantly write the value specified by dddddddd to the address specified by aaaaaaa

Increment/Decrement Commands
Code type Format Description

8-bit Increment 0x301000nn 0xaaaaaaaa This command adds the value specified by nn to the value stored at the address aaaaaaaa

8-bit Decrement 0x302000nn 0xaaaaaaaa This command subtracts the value specified by nn to the value stored at the address aaaaaaaa

16-bit Increment 0x3030nnnn 0xaaaaaaaa This command adds the value specified by nnnn to the value stored at the address aaaaaaaa

16-bit Decrement 0x3040nnnn 0xaaaaaaaa This command subtracts the value specified by nnnn to the value stored at the address aaaaaaaa

32-bit Increment 0x30500000 0xaaaaaaaa
0xnnnnnnnn 0x00000000 This command adds the value specified by nnnnnnnn to the value stored at the address aaaaaaaa

32-bit Decrement 0x30600000 0xaaaaaaaa
0xnnnnnnnn 0x00000000 This command subtracts the value specified by nnnnnnnn to the value stored at the address aaaaaaaa

Test Commands
Code type Format Description

16-bit Equal 0xDaaaaaaa 0x0000dddd Only when the value at the address specified by aaaaaaa
is equal to the value specified by dddd will the next line of code be executed

16-bit Not Equal 0xDaaaaaaa 0x0010dddd Only when the value at the address specified by aaaaaaa
is not equal to the value specified by dddd will the next line of code be executed

16-bit Less Than 0xDaaaaaaa 0x0020dddd Only when the value at the address specified by aaaaaaa
is less than the value specified by dddd will the next line of code be executed

16-bit Greater Than 0xDaaaaaaa 0x0030dddd Only when the value at the address specified by aaaaaaa
is greater than the value specified by dddd will the next line of code be executed

8-bit Equal 0xDaaaaaaa 0x200000dd Only when the value at the address specified by aaaaaaa
is equal to the value specified by dd will the next line of code be executed

8-bit Not Equal 0xDaaaaaaa 0x201000dd Only when the value at the address specified by aaaaaaa
is not equal to the value specified by dd will the next line of code be executed

8-bit Less Than 0xDaaaaaaa 0x202000dd Only when the value at the address specified by aaaaaaa
is less than the value specified by dd will the next line of code be executed

8-bit Greater Than 0xDaaaaaaa 0x203000dd Only when the value at the address specified by aaaaaaa
is greater than the value specified by dd will the next line of code be executed

16-bit Equal:
Multiple Skip 0xEnnndddd 0x0aaaaaaa Only when the value at the address specified by aaaaaaa
is equal to the value specified by dddd will the next nnn lines of code be executed.
Otherwise, they will be skipped

16-bit Not Equal:
Multiple Skip 0xEnnndddd 0x1aaaaaaa Only when the value at the address specified by aaaaaaa
is not equal to the value specified by dddd will the next nnn lines of code be executed.
Otherwise, they will be skipped

16-bit Less Than:
Multiple Skip 0xEnnndddd 0x2aaaaaaa Only when the value at the address specified by aaaaaaa
is less than the value specified by dddd will the next nnn lines of code be executed.
Otherwise, they will be skipped

16-bit Greater Than:
Multiple Skip 0xEnnndddd 0x3aaaaaaa Only when the value at the address specified by aaaaaaa
is greater than the value specified by dddd will the next nnn lines of code be executed.
Otherwise, they will be skipped

8-bit Equal:
Multiple Skip 0xE1nndddd 0x0aaaaaaa Only when the value at the address specified by aaaaaaa
is equal to the value specified by dddd will the next nn lines of code be executed.
Otherwise, they will be skipped

8-bit Not Equal:
Multiple Skip 0xE1nndddd 0x1aaaaaaa Only when the value at the address specified by aaaaaaa
is not equal to the value specified by dddd will the next nn lines of code be executed.
Otherwise, they will be skipped

8-bit Less Than:
Multiple Skip 0xE1nndddd 0x2aaaaaaa Only when the value at the address specified by aaaaaaa
is less than the value specified by dddd will the next nn lines of code be executed.
Otherwise, they will be skipped

8-bit Greater Than:
Multiple Skip 0xE1nndddd 0x3aaaaaaa Only when the value at the address specified by aaaaaaa
is greater than the value specified by dddd will the next nn lines of code be executed.
Otherwise, they will be skipped

Adress Equal 0xDaaaaaaa 0x4bbbbbbb
0xnnnnnnnn 0x0000000Y Only when the value at the address specified by aaaaaaa
is equal to the value at the adress specified by bbbbbbb
will the next nnnnnnnn line of code be executed.
The way to access the adresses is determined by Y: 0 = 8bit, 1 = 16bit, 2 = 32bit

Adress Not Equal 0xDaaaaaaa 0x5bbbbbbb
0xnnnnnnnn 0x0000000Y Only when the value at the address specified by aaaaaaa
is not equal to the value at the adress specified by bbbbbbb
will the next nnnnnnnn line of code be executed.
The way to access the adresses is determined by Y: 0 = 8bit, 1 = 16bit, 2 = 32bit

Adress Less Than 0xDaaaaaaa 0x5bbbbbbb
0xnnnnnnnn 0x0000000Y Only when the value at the address specified by aaaaaaa
is less than the value at the adress specified by bbbbbbb
will the next nnnnnnnn line of code be executed.
The way to access the adresses is determined by Y: 0 = 8bit, 1 = 16bit, 2 = 32bit

Adress Greather Than 0xDaaaaaaa 0x5bbbbbbb
0xnnnnnnnn 0x0000000Y Only when the value at the address specified by aaaaaaa
is Greather than the value at the adress specified by bbbbbbb
will the next nnnnnnnn line of code be executed.
The way to access the adresses is determined by Y: 0 = 8bit, 1 = 16bit, 2 = 32bit

Boolean Commands
Code type Format Description
8-bit OR 0x7aaaaaaa 0x000000vv aaaaaaa = address (25 bit)
8-bit AND 0x7aaaaaaa 0x000200vv vv = value (8/16 bit)
8-bit XOR 0x7aaaaaaa 0x000400vv Performs a bitwise logical operation between given value, vv, and the value stored at
16-bit OR 0x7aaaaaaa 0x0001vvvv given address, aaaaaaa. Example:
16-bit AND 0x7aaaaaaa 0x0003vvvv 0x7048D402 0x005014A9
16-bit XOR 0x7aaaaaaa 0x0005vvvv 0x14A9 is XORed to the 16-bit value at address (user ram)+0x0048D402

Pointer Commands
Code type Format Description

8-bit write 0x6aaaaaaa 0x000000vv
0x0000nnnn 0xiiiiiiii aaaaaaa = address to load 32-bit base from (25 bit)
vv = value to store at base + offset (8/16/32 bit)
qqq = offset to add to load the base(*4)
nnnn = number of times to point (16 bit) (must be 1 for normal pointer codes)
iiiiiiii = 32-bit offset to add to base (n = 1)

16-bit write 0x6aaaaaaa 0x0000vvvv
0x0001nnnn 0xiiiiiiii aaaaaaa = address to load 32-bit base from (25 bit)
vvvv = value to store at base + offset (8/16/32 bit)
qqq = offset to add to load the base(*4)
nnnn = number of times to point (16 bit) (must be 1 for normal pointer codes)
iiiiiiii = 32-bit offset to add to base (n = 1)

32-bit write 0x6aaaaaaa 0xvvvvvvvv
0x0002nnnn 0xiiiiiiii aaaaaaa = address to load 32-bit base from (25 bit)
vvvvvvvv = value to store at base + offset (8/16/32 bit)
qqq = offset to add to load the base(*4)
nnnn = number of times to point (16 bit) (must be 1 for normal pointer codes)
iiiiiiii = 32-bit offset to add to base (n = 1)

8-bit inverse write 0x6aaaaaaa 0x000000vv
0x0003nnnn 0xiiiiiiii aaaaaaa = address to load 32-bit base from (25 bit)
vv = value to store at base - offset (8/16/32 bit)
qqq = offset to add to load the base(*4)
nnnn = number of times to point (16 bit) (must be 1 for normal pointer codes)
iiiiiiii = 32-bit offset to subtract to base (n = 1)

16-bit inverse write 0x6aaaaaaa 0x0000vvvv
0x0004nnnn 0xiiiiiiii aaaaaaa = address to load 32-bit base from (25 bit)
vvvv = value to store at base - offset (8/16/32 bit)
qqq = offset to add to load the base(*4)
nnnn = number of times to point (16 bit) (must be 1 for normal pointer codes)
iiiiiiii = 32-bit offset to subtract to base (n = 1)

32-bit inverse write 0x6aaaaaaa 0xvvvvvvvv
0x0005nnnn 0xiiiiiiii aaaaaaa = address to load 32-bit base from (25 bit)
vvvvvvvv = value to store at base - offset (8/16/32 bit)
qqq = offset to add to load the base(*4)
nnnn = number of times to point (16 bit) (must be 1 for normal pointer codes)
iiiiiiii = 32-bit offset to subtract to base (n = 1)

Extra pointer line (n > 1)
type null 0x00000000 0x00000000 This will do absolutely nothing but it's required for n > 1.
You may need to use this if you want to use the qqq in normal pointer codes
Extra pointer line (n > 1)
type pointer walk 0xSppppppp 0xSppppppp This will make you able to go trough various level of pointers S indicates the type of offset to find the next pointer(0x2 +p 0x3 -p)
while p indicates the offset to find the next pointer.
Extra pointer line (n > 1)
type multi adress write 0x9sssssss 0xwwwwwwww sssssss = offset to add to base(*bytes of the code type, see above)
wwwwwwww = value to sum to starting value (vvvvvvvv) each time it's pointed

Extra pointer line (n = 2)
type copy byte 0x1sssssss 0x00000000 This extra pointer line will change sligtly the working of the pointer codes as specified above.
vvvvvvvv = bytes to be copied
aaaaaaa = address to load 32-bit base from (25 bit) (source)
iiiiiiii = 32-bit offset to add to base
qqq = offset to add to aaaaaaa to load the base(*4) (destination)
sssssss = 32-bit offset to add to base (destination)

Miscellaneous Commands
Code type Format Description

Jocker Code 0xD00000dd 0x1nnnnnnn This command will check the psp controller for the combination specified by nnnnnnn.
If equal it will execute the next dd+1 code lines else it will skip them.
It can check for combinations of up to 3 buttons
and it can be used even with kernel mode only buttons (like note, screen, etc)
Combination are sums of the values found here: Button Codes
NOTE: remapsp remaps are ignored by this function.

Inverse Jocker Code 0xD00000dd 0x3nnnnnnn This command will check the psp controller for the combination specified by nnnnnnn.
If not equal it will execute the next dd+1 code lines else it will skip them.
It can check for combinations of up to 3 buttons
and it can be used even with kernel mode only buttons (like note, screen, etc)
Combination are sums of the values found here: Button Codes
NOTE: remapsp remaps are ignored by this function.

Copy Bytes 0x5aaaaaaa 0xnnnnnnnn
0xbbbbbbbb 0x00000000 This command will copy part of the memory from one area to another
aaaaaaa = Address to copy from
bbbbbbbb = Address to copy to
nnnnnnnn = Number of bytes to copy

32-bit Multi-Address
Write/Value increase 0x4aaaaaaa 0xxxxxyyyy
0xdddddddd 0xIIIIIIII Starting with the address specified by aaaaaaa, this code will write to xxxx addresses.
The next address is determined by incrementing the current address by (yyyy * 4).
The value specified by dddddddd is written to each calculated address.
If IIIIIIII is different from zero the value defined by dddddddd
is increased of IIIIIIII at every new adress being patched. This code is also known as “Patch Code”

16-bit Multi-Address
Write/Value increase 0x8aaaaaaa 0xxxxxyyyy
0x1000dddd 0xIIIIIIII Starting with the address specified by aaaaaaa, this code will write to xxxx addresses.
The next address is determined by incrementing the current address by (yyyy * 2).
The value specified by dddd is written to each calculated address.
If IIIIIIII is different from zero the value defined by dddd
is increased of IIIIIIII at every new adress being patched. This code is also known as “Patch Code”

8-bit Multi-Address
Write/Value increase 0x8aaaaaaa 0xxxxxyyyy
0x000000dd 0xIIIIIIII Starting with the address specified by aaaaaaa, this code will write to xxxx addresses.
The next address is determined by incrementing the current address by (yyyy * 1).
The value specified by dd is written to each calculated address.
If IIIIIIII is different from zero the value defined by dd
is increased of IIIIIIII at every new adress being patched. This code is also known as “Patch Code”

Code Stopper 0xCaaaaaaa 0xvvvvvvvv aaaaaaa = address (25 bit)
vvvvvvvv = value (32 bit)
All following codes will be executed only, if 32-bit value
at given address, aaaaaaa, is equal to given value, vvvvvvvv.
Otherwise, they will be skipped. Can be used to exit the code sequence at any point.
To act on all codes (like traditional “Auto Activation”), put it at the top of the code list!
Example:
0xC0153880 0x03E00008
If the 32-bit value 0x03E00008 is at the address (user ram)+0x00153880,
then activate all following codes. Otherwise, do nothing.
NOTE: this affects all the cheats entered after the one with this code as
it stops the execution of the cheat engine till the next loop

Time Command 0xB0000000 0xnnnnnnnn nnnnnnnn = delay value (32 bit)
Delay putting on all following codes for v cycles; effect varies between games and loaded prxs.
To act on all codes, put it at the top of the code list!
0xB0000000 0x10000000
Loop is executed 0x10000000 times.
NOTE: this will stop other cheats after it in the cheat list

PSP Button codes supported by cwcheat

These codes can be used to define buttons used by cwcheat for opening menus, enabling cheats, etc. in it's configuration files but also in the jocker code type.

To get a combination of keys out of this table you just need to sum up the code of every button you need in the combination.

(remember that they must be threathed as hexadecimal values and that cwcheat supports combinations of up to 3 keys)
Button Code
SELECT 0x00000001
START 0x00000008
DPAD UP 0x00000010
DPAD RIGHT 0x00000020
DPAD DOWN 0x00000040
DPAD LEFT 0x00000080
L TRIGGER 0x00000100
R TRIGGER 0x00000200
TRIANGLE 0x00001000
CIRCLE 0x00002000
CROSS 0x00004000
SQUARE 0x00008000
HOME 0x00010000
HOLD 0x00020000
NOTE 0x00800000
SCREEN 0x00400000
VOLUME UP 0x00100000
VOLUME DOWN 0x00200000
WLAN UP 0x00040000
REMOTE HOLD 0x00080000

Line identifiers

There are various line identifiers in the database and their general format is “_* ”
Identifier Use Example
_S This identifier states that a new game entry is starting and it has as an argument the id of the game which is XXXX-XXXXX or XXXX_XXXXX depending if it's from a psp or pops game. homebrews have the HOMEBREW identification _S SLUS-12345
_G This identifier tells cwcheat the name of the current game. it can be anything in ASCII characters and with a limit of 30 characthers _G Legend of Heroes
_C# This identifier declares a new cheat. Older formats had it only as “_C ” now it's possible to add a number which is 0 or 1 (eg: _C0 )depending if the cheat is disabled or enabled by default (this doesn't mean it will start working automatically: you still need to enable the global cheat apply). The old format “_C ” is to be considered dropped and could be removed without notice so avoid using it _C0 Infinite HP
_L This identifier declares a new codeline which is made of two entries an adress and a value. it can be in hexdecimal, octal or decimal (remember to put the correct base identifier which is 0x for hexdecimal, 0 for octal and nothing for decimal) _L 0×10015648 0x0000FFFF
# This identifier declares that the current line is a comment: it will be ignored # hello folks!