Cafe Codetype Documentation

The Cafe Codetypes for the Wii U make the equivalent to the Wii's Gecko- or GCN's Action Replay Codetypes.
You may have noticed that the codetypes look a little bit obfuscating compared the Wii ones. This is because the address now occupies the space that was previously used to define the codetype. The codetype now has it's own 32 bits of space. Besides the codetype you can also define the value size and pointer state there.


The general scheme looks like following:

CCPS0000 LLLLLLLL
VVVVVVVV 00000000


As you can see the first byte (CC) defines the code type. 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:





The Cafe Codetypes + PPC code handler are developed by me.



  
  

  

RAM Write [00]

Formatting Example
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.

String Write [01]

Formatting Example
Direct address:
0100NNNN LLLLLLLL
VVVVVVVV VVVVVVVV
VVVV
0000 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
VVVV
0000 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- & Incremental Write [02]

Formatting Example
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.


Important note about Conditional/If Codes:

The last code affected by the condition must be D0000000 DEADCAFE. Otherwise you will cause a faulty cheat code execution. This line tells the codehandler where to branch the execution if the condition is false.

If Equal [03]

Formatting Example
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.

If Not Equal [04]

Formatting Example
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.

If Greater Than [05]

Formatting Example
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.

If Lower Than [06]

Formatting Example
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.

If Greater Than Or Equal [07]

Formatting Example
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.

If Lower Than Or Equal [08]

Formatting Example
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.


Important note about logical AND:

An AND-comparision checks if 2 (or more) values feature the same bit/s with a state of 1 (true). If you compare 0x400 with 0x600 you'd become a true condition because 0x400 is a full member of 0x600. You can see this quite well after converting the values into binaries:
0x400 > 10000000000
0x600 > 11000000000
10000000000 is included in 11000000000.
This type of comparision is recommendable for button activators. So it doesn't matter if more than the wanted button/s is/are being pressed to trigger the following code.

Conditional: Logical AND [09]

Formatting Example
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.


Important note about logical OR:

An OR-comparision checks if 2 (or more) values feature at least 1 bit with a state of 1 (true). If you compare 0x400 with 0x600 you'd become a true condition because 0x400 and 0x600 share a true bit. You can see this quite well after converting the values into binaries:
0x400 > 10000000000
0x600 > 11000000000
The green 1 indicates the relevant bit.
With this Code Type you can trigger the following codes if at least one of the required values is present. Simply add them together and replace VVVVVVVV by the sum. For instance you want to trigger a code if the A-, B-, X-, or Y-Button is being pressed. Add all button values together (0x8000 + 0x4000 + 0x2000 + 0x1000) and use them as VVVV (0xF000). Now the condition would return true if one or more than one of the involved buttons are being pressed.

Conditional: Logical OR [0A]

Formatting Example
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.

If Value Between [0B]

Formatting Example
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-Dependence [0C]

Formatting Example
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]

Formatting Example
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.


Important note about registers:

The following 6 Code Types are capable of loading values into registers, doing basic maths with them and storing them somewhere in memory. There are loading, storing and operation Types for floats and integers. You can use up to 8 registers for each datatype. Floats do not use the same registers as integers. So loading something into integer-register 0 won't overwrite the value inside of float-register 0. Registers are numbered from 0 - 7.

Load Integer [10]

Formatting Example
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]

Formatting Example
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]

Formatting Example
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]

Formatting Example
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 Operation [14]

Formatting Example
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)

Floating Point Operation [15]

Formatting Example
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 = Multiplication (R = R ⨯ VVVVVVVV)
  • 7 = Division (R = R ÷ VVVVVVVV)

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

Fill Memory Area [20]

Formatting Example
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]

Formatting Example
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]

Formatting Example
31000000 QQQQQQQQ

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

Execute ASM [C0]

Formatting Example
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 (EXPERIMENTAL) [C1]

Formatting Example
C100XXXX 00000000
This performs the system call of the value of XXXX. Visit WiiUBrew.org to find all available SysCall values. This Codetype is in an experimental state, so most syscall won't work.
Request Fast Exit
C1006700 00000000
This forces the system to open the home menu.

Patch Assembly (EXPERIMENTAL) [C2]

Formatting Example
C2000000 LLLLLLLL
VVVVVVVV 00000000


This allows you to write data to the executable memory range without freezing the system. This Codetype only works with JGecko U and BullyWiiPlaza's tcpgecko.elf.
Disable health decrement.
C2000000 0136EDCC
60000000 00000000

Terminator [D0]

Formatting Example
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]

Formatting Example
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]

Formatting Example
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]

Formatting Example
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.