Cafe Codetypes

Cheat Codes for the Wii U are expressed in the Cafe Codetype. These are merely the Wii U-equivalent to the Wii's Gecko- or GCN's Action Replay Codetypes. The general scheme looks like following:

CCPS0000 LLLLLLLL
VVVVVVVV 00000000

The first byte (CC) defines the codetype. P tells if a pointer is being used. S gives information about the data size. LLLLLLLL represents the location/address. KKKKKKKK instead of LLLLLLLL is used to express an offset between a pointer and the cheat's destination.

Legend:

  • CC = Code Type:
    00 = RAM Writes
    01 = Patch/String Writes
    02 = Skip Writes
    03 = If equal
    04 = If not equal
    05 = If greater
    06 = If lower
    07 = If greater or equal
    08 = If lower or equal
    09 = Conditional logical AND
    0A = Conditional logical OR
    0B = If value between
    0C = Add Time-Dependence
    0D = Reset Timer
    10 = Load Integer
    11 = Store Integer
    12 = Load Float
    13 = Store Float
    14 = Integer Operations
    15 = Float Operations
    20 = Memory fill
    30 = Load Pointer
    31 = Add Offset to Pointer
    C0 = Execute ASM
    C1 = Perform Cafe OS Syscalls
    D0 = Termination
    D1 = No Operation
    D2 = Timer Termination
    F0 = Corruptor

  • P = Pointer:
    0 = no pointer
    1 = pointer

  • S = Size:
    8-bits = 0
    16-bits = 1
    32-bits = 2

  • LLLLLLLL = Location/Address

  • VVVVVVVV = Value:
    8-bits = 000000VV
    16-bits = 0000VVVV
    32-bits = VVVVVVVV

  • RANGE_ST = Beginning of stable/reliable memory range:
    Minimum value = 0x10000000. Should be about 0x100000 smaller than the actual pointer. But you can increase or decrease it by feel. This is required to prevent inevitable freezes during loading times.

  • RANGE_EN = End of stable/reliable memory range:
    Maximum value = 0x50000000. Should be about 0x100000 bigger than the actual pointer. But you can increase or decrease it by feel. This is required to prevent inevitable freezes during loading times.

  • QQQQQQQQ = Permanent Pointer offset (signed):
    If the offset is negative write it as a signed hexadecimal integer without minus-sign. Example: -0x369C -> FFFFC964. Permanent means that the offset addition has affect on all following codes unless another pointer is loaded.

  • KKKKKKKK = Volatile Pointer offset (signed):
    Only the 00-Codetype uses unsigned offsets. Volatile means that the added offset has no affect on the following code(s).

Another great explaination can be found on bullywiiplaza.website.

RAM Write (00)

FormatExample
8bit:
00000000 LLLLLLLL
000000VV 00000000

This permanently writes the 8bit value of VV to address/location LLLLLLLL. 		Wind Waker HD: Infinite hearts (any region)
00000000 15073BC3
00000050 00000000

This permanently writes the vale of 0x50 (80) to address/location 0x15073BC3 which refers to the amount of quarter hearts.
16bit:
00010000 LLLLLLLL
0000VVVV 00000000

This permanently writes the 16bit value of VVVV to address/location LLLLLLLL.		 Twilight Princess HD: Infinite Lantern Oil (any region)
00010000 10647B52
00006000 00000000
32bit:
00020000 LLLLLLLL
VVVVVVVV 00000000

This permanently writes the 32bit value of VVVVVVVV to address/location LLLLLLLL.		 Wind Waker HD: Replace grass x1 with pigs (any region)
00020000 106EE1E4
00DCFF00 00000000
With pointer:
30000000 LLLLLLLL
RANGE_ST RANGE_EN
31000000 QQQQQQQQ
0010KKKK 000000VV
0011KKKK 0000VVVV
0012KKKK VVVVVVVV
D0000000 DEADCAFE

This permanently writes the 8-bit value of VV to the previously computed pointer (see 30 and 31 code types) + a volatile, unsigned offset of KKKK. Same for the 16-bit and 32-bit writes. KKKK only affects the write where it actually appears. The following line won't be affected by it. So all instances of KKKK represent different values. (If they would all be the same all 3 values would be written to the exact same address.)		 30000000 12345678
11000000 13000000
31000000 000035E8
00120000 3F800000
00120004 40000000
00120008 40400000
D0000000 DEADCAFE

This permantly writes 0x3F800000 to the previously computed pointer + an offset of 0x0000. Same with the values of 0x40000000 and 0x40400000 except that they have an offset of 0x0004 and 0x0008.

Patch/String Writes (01)

FormatExample
Direct address:
0100NNNN LLLLLLLL
VVVVVVVV VVVVVVVV
VVVV0000 000000FF

This permanently writes the amount of bytes defined by NNNN to LLLLLLLL. VV represents a byte. The rest of the last line must be filled with zeros where the last byte must be 0xFF (otherwise the codehandler won't know where the code ends). If VV fills the last line add 00000000 000000FF beneath it. 		Twilight Princess HD (any region) - Change Link's name to "Wolfgang"
01000008 10647CFC
576F6C66 67616E67
00000000 000000FF

This permanently writes the string of 0x576F6C6667616E67 to 0x10647CFC which effectively changes Link's name to Wolfgang.
With pointer:
30000000 LLLLLLLL
RANGE_ST RANGE_EN
31000000 QQQQQQQQ
0110NNNN KKKKKKKK
VVVVVVVV VVVVVVVV
VVVV0000 000000FF
D0000000 DEADCAFE

Same as above except that the value is being written to the previously computed pointer (see 30 and 31 code types) + a signed offset of KKKKKKKK where KKKKKKKK is volatile and has no affect on following codes.
30000000 12345678
45600000 45780000
31000000 FFFC5284
01100008 0000045C
576F6C66 67616E67
00000000 000000FF
D0000000 DEADCAFE

Same as above except that the value is being written to the previously computed pointer (see 30 and 31 code types) + a signed offset of 0x45C where 0x45C is volatile and has no affect on following codes.

Skip Writes (02)

FormatExample
8bit:
0200NNNN LLLLLLLL
000000VV YYYYYYYY
000000II 00000000

This consecutively writes the 8-bit value of VV NNNN times starting at address/location LLLLLLLL. The next write will be YYYYYYYY (signed value) remote from the previous one. The next write becomes incremented by II (signed value). If no increment is wished use 0x00 for II.
16bit:
0201NNNN LLLLLLLL
0000VVVV YYYYYYYY
0000IIII 00000000

This consecutively writes the 16-bit value of VVVV NNNN times starting at address/location LLLLLLLL. The next write will be YYYYYYYY (signed value) remote from the previous one. The next write becomes incremented by IIII (signed value). If no increment is wished use 0x0000 for IIII.
32bit:
0202NNNN LLLLLLLL
VVVVVVVV YYYYYYYY
IIIIIIII 00000000

This consecutively writes the 32-bit value of VVVVVVVV NNNN times starting at address/location LLLLLLLL. The next write will be YYYYYYYY (signed value) remote from the previous one. The next write becomes incremented by IIIIIIII (signed value). If no increment is wished use 0x00000000 for IIIIIIII.
With pointer:
30000000 LLLLLLLL
RANGE_ST RANGE_EN
31000000 QQQQQQQQ
0210NNNN KKKKKKKK
000000VV YYYYYYYY
000000II 00000000
0211NNNN KKKKKKKK
0000VVVV YYYYYYYY
0000IIII 00000000
0212NNNN KKKKKKKK
VVVVVVVV YYYYYYYY
IIIIIIII 00000000
D0000000 DEADCAFE

Same as above except that a pointer has been loaded. KKKKKKKK is a signed offset which does not affect the following cheats.

Conditional - If Equal (03)

FormatExample
8bit:
03000000 LLLLLLLL
000000VV 00000000
      . . .
D0000000 DEADCAFE

This checks if the 8bit value at LLLLLLLL equals VV. If the condition is true the next code/s (represented by . . . ) is/are executed.
16bit:
03010000 LLLLLLLL
0000VVVV 00000000
      . . .
D0000000 DEADCAFE

This checks if the 16bit value at LLLLLLLL equals VVVV. If the condition is true the next code/s (represented by . . . ) is/are executed.
32bit:
03020000 LLLLLLLL
VVVVVVVV 00000000
      . . .
D0000000 DEADCAFE

This checks if the 32bit value at LLLLLLLL equals VVVVVVVV. If the condition is true the next code/s (represented by . . . ) is/are executed.
With pointer (16bit):
30000000 LLLLLLLL
RANGE_ST RANGE_EN
31000000 QQQQQQQQ
03110000 KKKKKKKK
0000VVVV 00000000
      . . .
D0000000 DEADCAFE

This checks if the value of the previously computed pointer (see 30 and 31 code types) + a volatile, signed offset of KKKKKKKK equals VVVV. If the condition is true the next code/s (represented by . . . ) is/are executed.

Conditional - If Not Equal (04)

FormatExample
8bit:
04000000 LLLLLLLL
000000VV 00000000
      . . .
D0000000 DEADCAFE

This checks if the 8bit value at LLLLLLLL differs from VV. If the condition is true the next code/s (represented by . . . ) is/are executed.
16bit:
04010000 LLLLLLLL
0000VVVV 00000000
      . . .
D0000000 DEADCAFE

This checks if the 16bit value at LLLLLLLL differs from VVVV. If the condition is true the next code/s (represented by . . . ) is/are executed.
32bit:
04020000 LLLLLLLL
VVVVVVVV 00000000
      . . .
D0000000 DEADCAFE

This checks if the 32bit value at LLLLLLLL differs from VVVVVVVV. If the condition is true the next code/s (represented by . . . ) is/are executed.
With pointer (32bit):
30000000 LLLLLLLL
RANGE_ST RANGE_EN
31000000 QQQQQQQQ
04120000 KKKKKKKK
VVVVVVVV 00000000
      . . .
D0000000 DEADCAFE

This checks if the value of the previously computed pointer (see 30 and 31 code types) + a volatile, signed offset of KKKKKKKK differs from VVVVVVVV. If the condition is true the next code/s (represented by . . . ) is/are executed.

Conditional - If Greater Than (05)

FormatExample
8bit:
05000000 LLLLLLLL
000000VV 00000000
      . . .
D0000000 DEADCAFE

This checks if the 8bit value at LLLLLLLL is greater than VV. If the condition is true the next code/s (represented by . . . ) is/are executed.
16bit:
05010000 LLLLLLLL
0000VVVV 00000000
      . . .
D0000000 DEADCAFE

This checks if the 16bit value at LLLLLLLL is greater than VVVV. If the condition is true the next code/s (represented by . . . ) is/are executed.
32bit:
05020000 LLLLLLLL
VVVVVVVV 00000000
      . . .
D0000000 DEADCAFE

This checks if the 32bit value at LLLLLLLL is greater than VVVVVVVV. If the condition is true the next code/s (represented by . . . ) is/are executed.
With pointer (8bit):
30000000 LLLLLLLL
RANGE_ST RANGE_EN
31000000 QQQQQQQQ
05120000 KKKKKKKK
000000VV 00000000
      . . .
D0000000 DEADCAFE

This checks if the value of the previously computed pointer (see 30 and 31 code types) + a volatile, signed offset of KKKKKKKK is greater than VV. If the condition is true the next code/s (represented by . . . ) is/are executed.

Conditional - If Lower Than (06)

FormatExample
8bit:
06000000 LLLLLLLL
000000VV 00000000
      . . .
D0000000 DEADCAFE

This checks if the 8bit value at LLLLLLLL is lower than VV. If the condition is true the next code/s (represented by . . . ) is/are executed.
16bit:
06010000 LLLLLLLL
0000VVVV 00000000
      . . .
D0000000 DEADCAFE

This checks if the 16bit value at LLLLLLLL is lower than VVVV. If the condition is true the next code/s (represented by . . . ) is/are executed.
32bit:
06020000 LLLLLLLL
VVVVVVVV 00000000
      . . .
D0000000 DEADCAFE

This checks if the 32bit value at LLLLLLLL is lower than VVVVVVVV. If the condition is true the next code/s (represented by . . . ) is/are executed.
With pointer (8bit):
30000000 LLLLLLLL
RANGE_ST RANGE_EN
31000000 QQQQQQQQ
06120000 KKKKKKKK
000000VV 00000000
      . . .
D0000000 DEADCAFE

This checks if the value of the previously computed pointer (see 30 and 31 code types) + a volatile, signed offset of KKKKKKKK is lower than VV. If the condition is true the next code/s (represented by . . . ) is/are executed.

Conditional - If Greater Or Equal (07)

FormatExample
8bit:
07000000 LLLLLLLL
000000VV 00000000
      . . .
D0000000 DEADCAFE

This checks if the 8bit value at LLLLLLLL is greater than or equal VV. If the condition is true the next code/s (represented by . . . ) is/are executed.
16bit:
07010000 LLLLLLLL
0000VVVV 00000000
      . . .
D0000000 DEADCAFE

This checks if the 16bit value at LLLLLLLL is greater than or equal VVVV. If the condition is true the next code/s (represented by . . . ) is/are executed.
32bit:
07020000 LLLLLLLL
VVVVVVVV 00000000
      . . .
D0000000 DEADCAFE

This checks if the 32bit value at LLLLLLLL is greater than or equal VVVVVVVV. If the condition is true the next code/s (represented by . . . ) is/are executed.
With pointer (8bit):
30000000 LLLLLLLL
RANGE_ST RANGE_EN
31000000 QQQQQQQQ
07120000 KKKKKKKK
000000VV 00000000
      . . .
D0000000 DEADCAFE

This checks if the value of the previously computed pointer (see 30 and 31 code types) + a volatile, signed offset of KKKKKKKK is greater than or equal VV. If the condition is true the next code/s (represented by . . . ) is/are executed.

Conditional - If Lower Or Equal (08)

FormatExample
8bit:
08000000 LLLLLLLL
000000VV 00000000
      . . .
D0000000 DEADCAFE

This checks if the 8bit value at LLLLLLLL is lower than or equal VV. If the condition is true the next code/s (represented by . . . ) is/are executed.
16bit:
08010000 LLLLLLLL
0000VVVV 00000000
      . . .
D0000000 DEADCAFE

This checks if the 16bit value at LLLLLLLL is lower than or equal VVVV. If the condition is true the next code/s (represented by . . . ) is/are executed.
32bit:
08020000 LLLLLLLL
VVVVVVVV 00000000
      . . .
D0000000 DEADCAFE

This checks if the 32bit value at LLLLLLLL is lower than or equal VVVVVVVV. If the condition is true the next code/s (represented by . . . ) is/are executed.
With pointer (8bit):
30000000 LLLLLLLL
RANGE_ST RANGE_EN
31000000 QQQQQQQQ
08120000 KKKKKKKK
000000VV 00000000
      . . .
D0000000 DEADCAFE

This checks if the value of the previously computed pointer (see 30 and 31 code types) + a volatile, signed offset of KKKKKKKK is lower than or equal VV. If the condition is true the next code/s (represented by . . . ) is/are executed.

Conditional - Logical AND (09)

FormatExample
8bit:
09000000 LLLLLLLL
000000VV 00000000
      . . .
D0000000 DEADCAFE

This checks if the 8bit value at LLLLLLLL has the same true bits as VV. If the condition is true the next code/s (represented by . . . ) is/are executed.
16bit:
09010000 LLLLLLLL
0000VVVV 00000000
      . . .
D0000000 DEADCAFE

This checks if the 16bit value at LLLLLLLL has the same true bits as VVVV. If the condition is true the next code/s (represented by . . . ) is/are executed.
32bit:
09020000 LLLLLLLL
VVVVVVVV 00000000
      . . .
D0000000 DEADCAFE

This checks if the 32bit value at LLLLLLLL has the same true bits as VVVVVVVV. If the condition is true the next code/s (represented by . . . ) is/are executed.
With pointer (8bit):
30000000 LLLLLLLL
RANGE_ST RANGE_EN
31000000 QQQQQQQQ
09120000 KKKKKKKK
000000VV 00000000
      . . .
D0000000 DEADCAFE

This checks if the value of the previously computed pointer (see 30 and 31 code types) + a volatile, signed offset of KKKKKKKK has the same true bits as VV. If the condition is true the next code/s (represented by . . . ) is/are executed.

Conditional - Logical OR (0A)

FormatExample
8bit:
0A000000 LLLLLLLL
000000VV 00000000
      . . .
D0000000 DEADCAFE

This checks if the 8bit value at LLLLLLLL shares at least one true bit with VV. If the condition is true the next code/s (represented by . . . ) is/are executed.
16bit:
0A010000 LLLLLLLL
0000VVVV 00000000
      . . .
D0000000 DEADCAFE

This checks if the 16bit value at LLLLLLLL shares at least one true bit with VVVV. If the condition is true the next code/s (represented by . . . ) is/are executed.
32bit:
0A020000 LLLLLLLL
VVVVVVVV 00000000
      . . .
D0000000 DEADCAFE

This checks if the 32bit value at LLLLLLLL shares at least one true bit with VVVVVVVV. If the condition is true the next code/s (represented by . . . ) is/are executed.
With pointer (8bit):
30000000 LLLLLLLL
RANGE_ST RANGE_EN
31000000 QQQQQQQQ
0A120000 KKKKKKKK
000000VV 00000000
      . . .
D0000000 DEADCAFE

This checks if the value of the previously computed pointer (see 30 and 31 code types) + a volatile, signed offset of KKKKKKKK shares at least one true bit with VV. If the condition is true the next code/s (represented by . . . ) is/are executed.

Conditional - If Value Between (0B)

FormatExample
8bit:
0B000000 LLLLLLLL
000000VV 000000WW
      . . .
D0000000 DEADCAFE

This checks if the 8bit value at LLLLLLLL is bigger than VV and smaller than WW. If the condition is true the next code/s (represented by . . . ) is/are executed.
16bit:
0B010000 LLLLLLLL
0000VVVV 0000WWWW
      . . .
D0000000 DEADCAFE

This checks if the 16bit value at LLLLLLLL is bigger than VVVV and smaller than WWWW. If the condition is true the next code/s (represented by . . . ) is/are executed.
32bit:
0B020000 LLLLLLLL
VVVVVVVV WWWWWWWW
      . . .
D0000000 DEADCAFE

This checks if the 32bit value at LLLLLLLL is bigger than VVVVVVVV and smaller than WWWWWWWW. If the condition is true the next code/s (represented by . . . ) is/are executed.
With pointer (8bit):
30000000 LLLLLLLL
RANGE_ST RANGE_EN
31000000 QQQQQQQQ
0B120000 KKKKKKKK
000000VV 000000WW
      . . .
D0000000 DEADCAFE

This checks if the value of the previously computed pointer (see 30 and 31 code types) + a volatile, signed offset of KKKKKKKK is bigger than VV and smaller than WW. If the condition is true the next code/s (represented by . . . ) is/are executed.

Add Time-Dependency (0C)

FormatExample
0C000000 NNNNNNNN
      . . .
D2000000 CAFEBABE

All codes between this line and D2000000 CAFEBABE will only be executed if less than NNNNNNNN "frames" have passed. If you want to execute this code again you can use the 0D-Type to reset the timer.
1s ≈ 120/0x78 		0C000000 000004B0
00020000 487314D8
42000000 00000000
D2000000 CAFEBABE

This will only allow the cheat code to be executed before the framecounter has reached 1200/0x4B0.

Reset Timer (0D)

FormatExample
0D00VVVV LLLLLLLL

This resets the timer to 0 if the 16-bit value at LLLLLLLL equals VVVV so all time-dependent codes will be active again. 		0D008040 13504566

This resets the timer to 0 if the 16-bit value at 0x13504566 equals 0x4080 so all time-dependent codes will be active again.

Load Integer (10)

FormatExample
8bit:
1000000R LLLLLLLL

This loads the 8bit value located at LLLLLLLL into Integer Register R.
16bit:
1001000R LLLLLLLL

This loads the 16bit value located at LLLLLLLL into Integer Register R.
32bit:
1002000R LLLLLLLL

This loads the 32bit value located at LLLLLLLL into Integer Register R.
With pointer:
30000000 LLLLLLLL
RANGE_ST RANGE_EN
31000000 QQQQQQQQ
101S000R KKKKKKKK
D0000000 DEADCAFE

This loads the integer located at the previously computed pointer (see 30 and 31 code types) + a volatile, signed offset of KKKKKKKK into integer register R.

Store Integer (11)

FormatExample
8bit:
1100000R LLLLLLLL

This stores the 8bit value inside of Integer-Register R to the address specified in LLLLLLLL.
16bit:
1101000R LLLLLLLL

This stores the 16bit value inside of Integer-Register R to the address specified in LLLLLLLL.
32bit:
1102000R LLLLLLLL

This stores the 32bit value inside of Integer-Register R to the address specified in LLLLLLLL.
With pointer:
30000000 LLLLLLLL
RANGE_ST RANGE_EN
31000000 QQQQQQQQ
111S000R KKKKKKKK
D0000000 DEADCAFE

This stores the integer inside of Integer-Register R to the the previously computed pointer (see 30 and 31 code types) + a volatile, signed offset of KKKKKKKK.

Load Float (12)

FormatExample
Normal:
1200000R LLLLLLLL

This loads the float located at LLLLLLLL into Float-Register R.
With pointer:
30000000 LLLLLLLL
RANGE_ST RANGE_EN
31000000 QQQQQQQQ
1210000R KKKKKKKK
D0000000 DEADCAFE

This loads the float of the previously computed pointer (see 30 and 31 code types) + a volatile, signed offset of KKKKKKKK into Float Register R.

Store Float (13)

FormatExample
Normal:
1300000R LLLLLLLL

This stores the float inside of R to the address specified with LLLLLLLL.
With pointer:
30000000 LLLLLLLL
RANGE_ST RANGE_EN
31000000 QQQQQQQQ
1310000R KKKKKKKK
D0000000 DEADCAFE

This stores the float inside of R to the previously computed pointer (see 30 and 31 code types) + a volatile, signed offset of KKKKKKKK.

Integer Operations (14)

FormatExample
Operation between 2 Registers:
140T0R0Я 00000000

    T: Operation Type
  • 0 = Addition (R = R + Я)
  • 1 = Subtraction (R = R - Я)
  • 2 = Multiplication (R = R ⨯ Я)
  • 3 = Division (R = R ÷ Я)

R = First operant and destination (where the result will be placed)
Я = Second operant (what the first operant will be affected by)
Direct Value Operations:
140T0R00 VVVVVVVV

    T: Operation Type
  • 4 = Addition (R = R + VVVVVVVV)
  • 5 = Subtraction (R = R - VVVVVVVV)
  • 6 = Division (R = R ⨯ VVVVVVVV)
  • 7 = Multiplication (R = R ÷ VVVVVVVV)

R = First operant and destination (where the result will be placed)
VVVVVVVV = Second Operant (what R will be affected by)

Float Operations (15)

FormatExample
Operation between 2 Registers:
150T0R0Я 00000000

    T: Operation Type
  • 0 = Addition (R = R + Я)
  • 1 = Subtraction (R = R - Я)
  • 2 = Multiplication (R = R ⨯ Я)
  • 3 = Division (R = R ÷ Я)
  • 8 = Convert Float to Int (R = the float to be converted. The result will be put into Integer-Register Я)

R = First operant and destination (where the result will be placed)
Я = Second operant (what the first operant will be affected by)
Direct Value Operations:
150T0R00 VVVVVVVV

    T: Operation Type
  • 4 = Addition (R = R + VVVVVVVV)
  • 5 = Subtraction (R = R - VVVVVVVV)
  • 6 = Division (R = R ⨯ VVVVVVVV)
  • 7 = Multiplication (R = R ÷ VVVVVVVV)

R = First operant and destination (where the result will be placed)
VVVVVVVV = Second Operant (what R will be affected by)

Memory Fill (20)

FormatExample
Normal:
20000000 VVVVVVVV
LLLLLLLL MMMMMMMM

LLLLLLLL = Address of first value-write
MMMMMMMM = Offset between LLLLLLLL and last write.
With Pointer:
30000000 LLLLLLLL
RANGE_ST RANGE_EN
31000000 QQQQQQQQ
20100000 VVVVVVVV
KKKKKKKK MMMMMMMM
D0000000 DEADCAFE

MMMMMMMM = Offset between LLLLLLLL and last write.

Load Pointer (30)

FormatExample
Normal:
30000000 LLLLLLLL
RANGE_ST RANGE_EN

LLLLLLLL = Address of where to load the pointer.
RANGE_ST = Beginning of reliable memory range.
RANGE_EN = End of reliable memory range.
Defining the memory range is necessarrily required. Without it the system would access unmapped or wrong memory which leads to inevitable crashes. The memory range should be big enough to include any possible area the value destination can be located. For instance, if the smallest pointer destination is 0x27CE8940 and the biggest is 0x2814ED40 you could replace RANGE_ST with 0x27000000 and RANGE_EN with 0x28800000 to ensure to be using a valid and crash-free memory range.
This also loads the Pointer located at LLLLLLLL only when it refers to a range between RANGE_ST and RANGE_EN.
With Pointer (loading Pointer-into-Pointer):
30000000 LLLLLLLL
RANGE_ST RANGE_EN
31000000 QQQQQQQQ
30100000 00000000
RANGE_ST RANGE_EN
D0000000 DEADCAFE

This loads the pointer located at LLLLLLLL [30] and adds the signed offset of QQQQQQQQ to it [31]. It now loads the pointer of where the previously computed pointer refers to.

Add Offset To Pointer (31)

FormatExample
31000000 QQQQQQQQ

This adds the signed offset QQQQQQQQ to the previously loaded pointer.

Execute Assembly (C0)

FormatExample
C000NNNN 60000000
XXXXXXXX XXXXXXXX
...
3C40010F 60426AE0
7C4903A6 4E800420

This Code Type can be used to execute ANY assembly code. All GPR and FPR are available. The last 2 lines of every code of this type must be 3C40010F 60426AE0
7C4903A6 4E800420
 NNNN defines the number of lines excluding C000NNNN 60000000, but including the last 2 ones. One line consists of 2 assembly instructions (8 Bytes). If you have an odd amount of assembly instructions add 0x60000000 where the gap would be. The code will be executed about 120 times a second.
If you want to use LR don't forget to write an assembly instruction to back up it somewhere into memory and recover it later. 		C0000005 60000000
3C601234 60635678
3C80AABB 6084CCDD
90830000 60000000
3C40010F 60426AE0
7C4903A6 4E800420

Perform Cafe OS Syscalls (C1)

FormatExample
C100XXXX 00000000
This performs the system call of the value of XXXX. Visit WiiUBrew.org to find all available SysCall values. 		Request Fast Exit
C0006700 00000000
This forces the system to open the home menu.

Termination (D0)

FormatExample
D0000000 DEADCAFE

This line of code is always required in the end of a conditional code or code with pointer(s).
It effectively does nothing but tells the codehandler where to branch the cheat code execution once a condition is false or the a pointer goes out off range.

No Operation (D1)

FormatExample
D1000000 DEADC0DE

This line does absolutely nothing. But it is used by the codehandler to overwrite cheat code which will be executed only once. You probably won't ever need to use it but I'd like to mention it here since it's an actual feature of the codehandler.

Timer Termination (D2)

FormatExample
D2000000 CAFEBABE

This line of code must be used as last line of every time-depended code. This tells the codehandler where to branch when the time-depended codes have to be skipped.

Corruptor (F0)

FormatExample
F0000000 LLLLLLLL
MMMMMMMM VVVVVVVV
WWWWWWWW 00000000

This searches for every value of VVVVVVVV inside the memory range specified with LLLLLLLL (beginning) and MMMMMMMM (end) and replaces every match with WWWWWWWW. This can lead to nasty corruptions 		F0000000 11000000
18000000 3F800000
40000000 00000000

This searches for every value of 0x3F800000 inside a range of 0x11000000 and 0x18000000 and overwrites ever match with 0x40000000.

©Lawn Meower (Sophie Schmidt) 2015 - 2024