How Jokering Works

I DO NOT TAKE CREIT FOR THIS


Made by TheEliteOne.

Loading and storing:

Moves data into a register, this data can be a value, address, offset, or pointer.

Storing:
Moves the contents of a register into a address, offset, or pointer.
Definitions On Commands Used In Jokers:


Lui - Load Upper Immediate
Loads 16 Bits into a register
Example: Lui t0 $1234
Loads the value 1234 into the register t0

Addiu - Add Immediate Unsigned
Adds the contents of a register to a value and stores the result into another register
Examplte: Addiu t0 t1 $1234
Adds 1234 to the contents of t1 and stores the result into t0

Lw - Load Word
Loads up to 32 Bits into a register
Example:
Lui t0 $1234
Lw t1 $5678(t0)
Loads 12345678 into t0, they (t0) says to load the contents of t0 also

Sw - Store Word
Stores the contents of a register into a offset, or address
Example:
Lui t0 $1234
Lw t0 $5678(t0)
Lui t1 $1337
Sw t0 $1337(t1)
Stores the value 12345678 into the address 13371337

Nop - No Operation
Kills space, this is needed after a jump.
Example: Nop

J - Jump
Jumps to a address
Example: J $08801234
Jumps to the address 00001234

Jr ra - Jump register Return Address
Returns the address's values back to there original state, turning routines off.
Example: Jr ra

Bne - Branch If Not Equal
Jumps to the target address if two registers are not equal
Example: Bne t0 t1 $08801234
Jumps to the address 00001234 if t0 doesn't equal t1

Beq - Branch If Equal
Jumps to the target address if two registers are equal
Example: Beq t0 t1 $08801234
Jumps to the address 00001234 if t0 doesn't equal t1
And please note the the register "zero" always holds the value 0.

So here is the tempalte made by Sly XRoss:


Lui t0 $XXXX
Lui t1 $XXXX
Lw t1 $XXXX(t1)
Addiu t2 zero $XXXX
Addiu t3 zero $XXXX
Lui t4 $XXXX
Addiu t5 t4 $XXXX
Lui t6 $XXXX
Addiu t6 t6 $XXXX
Bne t1 t2 $XXXXXXXX
Nop
Sw t5 $XXXX(t0)
Bne t1 t3 $XXXXXXXX
Nop
Sw t6 $XXXX(t0)
Jr ra
All the X's are things you are supposed to fill in, so here is how the joker works:


Lui t0 $Loads the first 16 Bits of are Code address +0880 into t0, Negative Rule
Lui t1 $Loads the first 16 Bits of are Controller address +0880 into t1
Lw t1 $Loads the last 16 Bits of are controller address into t1(t1)
Addiu t2 zero $Adds the button to turn your hack on to zero and stores the result into t2
Addiu t3 zero $Adds the button to turn your hack off to zero and stores the result inot t3
Lui t4 $Loads the first 16 Bits are hacked value into t4, Negative Rule
Addiu t5 t4 $Adds the last 16 Bits of are hacked value to the contents of t4 and stores the result into t5
Lui t6 $Loads the first 16 Bits of are default value into t6, Negative Rule
Addiu t6 t6 $Adds the last 16 Bits of are defualt value to the contents of t6 and stores the result into t6
Bne t1 t2 $Branches to the next bne, so if t1 doesn't equal t2 it jumps to the next bne
Nop
Sw t5 $Stores the contents of t5 to the last 16 Bits of the Code address(t0)
Bne t1 t3 $Branches to the jr ra, so if t1 doesn't equal t3 it jumps to the jr ra
Nop
sw t6 $Stores the contents of t6 to the last 16 Bits of the Code address(t0)
Jr ra
J $Jumps to the start of are routine, this is what keeps are subroutine on after the jr ra has taken place
So some people might not get that that well, all I can say to those people is read this more and try and understand it the best you

can, here is some information on what is going on:


Lui t0 $XXXX
This makes t0 now hold the first 16 Bits of are Code address +0880

Lui t1 $XXXX
This makes t1 now hold the first 16 Bits of are Controller address +0880

Lw t1 $XXXX(t1)
This makes t1 now hold the full Controller address

Addiu t2 zero $XXXX
This makes t2 hold the button value to turn your hack on

Addiu t3 zero $XXXX
This makes t3 hold the button value to turn your hack off

Lui t4 $XXXX
This makes t4 hold the first 16 Bits of are hacked value

Addiu t5 t4 $XXXX
This makes t5 hold the full hacked value

Lui t6 $XXXX
This makes t6 hold the first 16 Bits of are default value

Addiu t6 t6 $XXXX
This makes t6 hold the full default value

Bne t1 t2 $XXXXXXXX
This is here so if the Controller Address doesn't equal the button to turn are hack on it jumps to the next bne

Nop
This is needed after a jump, like bne

Sw t5 $XXXX(t0)
This stores the contents of t5 to the second half of the code address and to the contents of (t0) Which is the first half of the code

address. So if the bne t1 t2 doesn't jump the routine will read this and it will change the current value of the address to the

hacked value, but if the branch does jump it will skip this part.

Bne t1 t3 $XXXXXXXX
If the first bne does jump it will go here, if the button you said to use to turn off are hack it will jump to the jr ra which will

end are routine

Nop
This is needed after a jump

Sw t6 $XXXX(t0)
Stores the contents of t6 to the second half of the code address and to the contents of (t0) which is the first half of the code

address. This will turn are hack off.

Jr ra
This returns the address's values back to there default values making are joker turn off

J $XXXXXXXX
This is are hook, it's used to jump back to the top of are joker, keeping are joker on (Read on the Jr ra to know why it was "off")

and able to turn are hack on or off at any time.
I hope this helps any one who needed it