The Secrets of Professional GameShark(tm) Hacking

____ ______ ______ THE ______ ______ ____ / \ | ___| | | _____ | ___| |_ _| / \ | |__| | |__ | |__| | \ | |__ | | | |__| \ \ | __| | | | | | | __| | | \ \ _\ \ | | | |__ | / | | | | _\ \ | | | | |___ | | | | | \ | |___ | | | | | \____/ |______| |______| |___|__\ |______| |__| \____/ Of Professional Gameshark(tm) Hacking _____ 0001110101001110010110100011 ..~` a`~~.. 110100000100001000100000101000001 ..~` }100000111000110001110001100011111110 -----` /\/\/\/10100011100110000111001100001110011000 `. \\\ | 00010001001111110010011111100100111111100 ; \/\/\100100111001100001110011000011101100010 .` ___/01000111000110001110001100011100110010 ; ..~~~~```` 11011000100100100101010100100110101001 .` ..`` ; ..`` ; .` .-` .` .-` ,` "The most elaborate, in-depth hacking guide / .. . for Game Cheat Devices, ANYWHERE!" |.-`` `. \ `.| [Originally By: Kong K Rool* and Macrox] with additions by [Tolos, DGenerateKane, HyperHacker, Viper187, and Kenobi] ----------------------------------------------- Table Of Contents ----------------------------------------------- Section 1 : Foreword

I This Version II What's New III Coming Soon IV Dedication V Preface VI Acknowledgments Section 2 : Hacking VII Introduction VIII Hacking Basics - Theory

Know The Code
Systems Of Counting Or Number Base
About Most GameShark Hackers

IX. How-to Guide - Getting Started

What do I need?
What do I need to know?
Learn Your Shark - Code Types, Buttons and all.
Encryption

X. How-to Guide - The Hacking Begins

One Small Step For Man...
The Methods
The online Code Porter

XI. How-to Guide - Gameboy Hacking

Hacking Gameboy Advance Codes With Visualboy Advance
Gameboy Advance Size Modifiers How-To
Finding Gameboy Advance Enable Codes
Creating AR V3 Codes Using AR Crypt Beta8c
Hacking Non-Standard Master Codes
Gameboy Advance ASM Tutorial
GameBoy 3.0 Hacking - by Curly9od

XIII. Downloads XIV. GameShark / GameShark Pro FAQ XV. Playstation Xplorer/xploder Information

Section 4 : Legal

Section 1 : Foreword

----------------------------------------------- I) This Version ----------------------------------------------- Version Number: 5.00c Release Date: 03-25-2003 Edited by Tolos, Viper and macrox * = aka Parasyte ----------------------------------------------- II) What's New ----------------------------------------------- 03-02-04 minor update: -Hacking "unhackable" GBA master codes -Bitwise Operations info -A little basic info on using COP1 instructions (N64 ASM) -IcyGuy revamped his Image Mods and GBA Size Mods info -MAX Crypt, GCN Crypt, and GCN Code Type Helper downloads added 06-27-03 "Secrets..." goes solely HTML! -XPloder 7K decryption algorithm -New AR Crypt info added -Added PS2 encryptor program (javascript) -Added Z64 and V64 info in the GameShark FAQ -Added N64 Emulator Based Hacking guide -Updated N64 ASM Hacking -Updated the Downloads section -More Downloads Added -Image Modifiers 05-31-03 Tons of new info added: -codetypes updated/added for all systems -new N64 enabler information -More complete Button Activator/Joker info -New method of hacking N64 Button Activators -Hacking Timer codes -Quickstart/Skip Into codes -CPU <> P2 Control Modifier Codes -New Moon Jump Method -X/Y/Z Coordinate Modifiers -Floating Points info -Encryption information PS2 -AR Crypt for GBA: Program, V3 code types and guide. -PS2 hacking -Info on DC hacking -Huge N64 ASM Guide -GBA ASM Hacking tutorial -GBA Size Mods -Brought the GS FAQ up-to-date -Greatly expanded the TOC -Added a few mini-TOCs in places they'll be useful 05-21-03 Tolos finally manages to pull an update together. -Added PS2 code type info -GSA and CBA info -Added N64 control stick activator info. -Added links in the Table of Contents for easy refernce (HTML version). 01-01-03 Macrox fixed the errata of missing code types for GS and CB GBA. 05-20-02 Tolos assigned new acting editor by macrox. -Hacking GameBoy Advance enabler codes -GameBoy Advance code types -Added a tidbit on hacking debug codes -Added a section on hacking GameBoy Advance codes. 11-27-01 Interact Accessories affiliation in legal section removed. Reference to Gameshark removed from work title. The reader is to Infer the term gameshark, codebreaker and xplorer to mean cheat device where it occurs in this work. See legal section for proper credit. 04-21-01 -Revised section on N64 and XP code types -DC code types and buttons. -Comparison of GameBoy hacking devices -Reflashing a GameBoy Shark. -More on hacking enabler codes and forcing high and low mode res -DC code types: CodeBreaker, Xplorer and Gameshark. -How to Hack Speed modifiers. -Update on Keycodes list -Revised FAQ section. 11-11-00 -Reflashing a corrupted GameShark -Info on Pelican's new hack device for Game Boy, "Code Breaker" -Gameboy hacking info courtesy of Curly9od 05-06-00 -How to hack specific codes section appended -Using the memory editor has been appended -How to install the pc hacking utilities, hooking the GameShark to a PC and upgrading (flashing) the GameShark Rom added. -How to hack enabler codes -Hacking walk through walls (WTW) codes -Link to online code porter (when text viewed online). 07-22-99 -New chapter added - Chapter 4 - GameShark / GameShark Pro FAQ. -New "How-to" added, for the Big Time Hackers. -Decimal/Hexadecimal conversion formula added. -"This Version", "What's New" and "Coming Soon" sections added. -Many new code type prefixes added. ----------------------------------------------- III) Coming Soon ----------------------------------------------- Gamecube Hacking Caetla Code Types XP64 Code Types Saturn Emulator Hacking CodeBreaker2 Code Types TBA - To be announced topics. ----------------------------------------------- IV) Dedication - by Kong K. Rool ----------------------------------------------- This document, in all its entirety is dedicated to my dad. A very brilliant man in the computer/science fields. He passed away July 9th of 1999 at the age of 36. May he rest in peace. - Kong K. Rool (aka Parasyte) ----------------------------------------------- V) Preface ----------------------------------------------- First off I want to say, Macrox has semi-retired from the hacking scene. That left no one to tend this marvelous document. Then Interact suddenly stopped hosting GSCentral when they learned that their GameBoy Advance encryption code had been cracked, and the people at GSCentral were creating codes that worked with the GameBoy Advance GameShark. After GSCentral came back, we learned we could not use the word GameShark (TM), or have the Hacking Text displayed. So I volunteered to host this document. I hope I can do a good job; as well as Macrox and Parasyte: that is my aim. I also want to thank macrox, HyperHacker, and DgenerateKane for helping me along. Happy hacking, Tolos (Assigned Editor in Chief) P.S. The Hacking Text has been re-instated on GSCentral. A mirror copy of this document will be kept on Tolos’ web sites. These are the only officially endorsed sites by macrox on the most up to date versions of the text.

- macrox 1-1-2003 (Editor - retired) ----------------------------------------------- VI) Acknowledgments ----------------------------------------------- Many talented people have contributed to this work over time either directly or indirectly. To those people we say thank you for all your contributions to the world of video games and for hacking codes and sharing ideas on how to hack codes. People whom have shared ideas and contributed information for this document: Kong K. Rool (aka Parasyte) Macrox macrox_the_sage@yahoo.com Tolos tolos_magician@yahoo.com HyperHacker DGenerateKane ShadowKnight Jim Reinhart (GSCentral Founder) Code Master Kamek Freeza Subdrag Viper666(187) viper@gscentral.com Sutaz james007 Gold64007 Stinky613 Crocc Zap2 CodeBoy Savior Charizard Dr. Ian Curly9od Bleeding Gums Murphy Kola FoxDie ARHQ - our AR PRO replay affiliates. Kenobi Icy Guy Goldenboy This list goes on and on, we apologize for any omissions of people who gave of their time to advance the art. The authors want to thank everyone at GSCentral, Game Shark Zone, Game Shark (Software) Code Creators Club, Gamasutra, Dextrose, Interact, MadCatz, and Datel for fruitful discussions.

Section 2 : Hacking

----------------------------------------------- VII) Introduction ----------------------------------------------- Welcome to the GameShark World. In this document, you will learn several different ways to hack your own codes. These methods range in degree of difficulty from easy to difficult and yield various results. As you read you are encouraged to practice the methods that are described in this document. This way, you will learn by your activities. There is more than one way to hack codes. This ranges from guessing, to a secret hacking system, which not everyone will understand. Again, as you read, try the ideas mentioned. It has been proven that people learn easier and faster when they are active in a project. It is the authors wish that the material presented here meets the anticipated needs of the reader's wishes to learn to hack GameShark codes. You might even come up with another variation of these methods to hack codes. If you do, let us know and we will consider including it in future versions of this document. ----------------------------------------------- VIII) Hacking Basics ----------------------------------------------- A) Know the Code Offsets Offsets(or RAM addresses) are typically found by examination of the game memory by using advanced hacking equipment such as a GS Pro, Shark Link or hex viewer on a ROM. Basically, an offset is a "memory holder" in which it (usually) holds a byte of memory(a two digit hexadecimal code). If you find an offset that holds the health digits when using a ROM and hex viewer, you can be certain that it isn't the GS code(if you find the health at offset "012203" the GS code usually won't be "80012203 FFFF".) There is less than a 1% chance of finding an offset and it actually being the code. The reason the offset and the offset digits in a GS code are not the same is this - There are MANY, MANY offsets which are used to tell the platform what type of game it is(size, language, title, checksum values, etc.), and other operation codes which will assign all the offsets to do what they are meant to do. There are offsets that hold the hex values that make up the pictures you see in the game, the coordination's of the character you control, mathematical operations... The list goes on and on... The header(tells the machine what type of game you're are booting) might take up all offsets past "012203" itself! There is a block of info that tells where the quantifier-offsets(the byte of memory which you change through GS codes begin and which are usually things such as number of an item you have or level of health you have). This block is called RAM(Random Access Memory), which does exactly what it says. RAM is memory that will be changed all throughout its processing. Score and health are good examples of RAM, the values for both will be changed while you're game is running. So think of GameShark as a RAM Editor. More information about offsets is beyond the scope of this document and will not be included in future editions of this text. B) Systems of counting or number base B-1) Decimal Decimal Notation, based on ten digits, is something you already know. Count to 50 like you normally count. You can count using decimal notation. B-2) Binary Binary, or dual counting, is based on two digits. It's really easy to understand and use. You'll need to know the following - There are two characters used in binary - 0,1 (Think of it as a switch). A "1" means the switch is turned ON. A "0" means the switch is turned OFF. That's what binary is, a bunch of switches. I won't go into any more detail about switches now, but will return to this topic later in the document. A four-digit string of code written in binary is called a "word".(this is also the same in hex[1-digit]) Four Binary Digits(bits - 'BInary digiTS') equals 1 digit hex. Three bits equals 1 digit octal. Now that you know that, hex and octal should seem easier to learn. In this document, we will refer to any and all hex values with "-h" and decimal values with "-d". So value "100" decimal will read like this - "100-d" and "64-h". How do you convert from bits to hex and back? Look at this chart - Hex Binary Hex Binary 0 - 0000 8 - 1000 1 - 0001 9 - 1001 2 - 0010 A - 1010 3 - 0011 B - 1011 4 - 0100 C - 1100 5 - 0101 D - 1101 6 - 0110 E - 1110 7 - 0111 F - 1111 If you notice, there are no more 4-digit combinations of "0,1" left. Now for the conversion part. Look at the 4 bits, each of the numbers have a value assigned to them. We will call these values, "Bit Values". Number in Hex 6 Number in Binary 0110 Bit Value 8421 (The Bit Value will ALWAYS be this! So remember it!) You are going to learn to convert by using multiplication. Math is a great tool to use when working with the GameShark. You can represent the binary word by letting "0110"(8421) = "IJKL" and thus you get "1xL + 2xK + 4xJ + 8xI" = "L+2K+4J+8I"(in algebraic terms). Now substitute the binary back in, you would get "1x0 + 2x1 + 4x1 + 8x0" = "0+2+4+0" which adds up to six. Six is what the hex value was in the beginning. To convert back to binary, use the formula "L+2K+4J+8K", find the numbers, which add up to six. In this case, "4 and 2". Remember, "IJKL" = the bit value. Then substitute the binary back in - "1x0 + 2x1 + 4x1 + 8x0" = "0110". Why do that when there's an easier way? Because there is no use in converting when you don't understand why it is done in that way. You will learn an easier way soon, in fact, make one up! Octal conversions are the same as hex-to-bit. Only, octal goes up to "7". So the bit value looks like this - Octal 3 Binary 011 Bit value 421 The Bit Value will NEVER change. The bit value is actually the value assigned for each bit. If you have an 8-bit value, the bit value would look like this - (128)(64)(32)(16)(8)(4)(2)(1) Notice that every time a new bit is added(to the beginning, no doubt), the last bits' value will double. Further explanation is beyond the scope of this text. To convert between hex and decimal, use this formula - yz = 2-digit value hex (when) z = "A-hex", A = "10-dec" (when) z = "B-hex", B = "11-dec" (when) z = "C-hex", C = "12-dec" (when) z = "D-hex", D = "13-dec" (when) z = "E-hex", E = "14-dec" (when) z = "F-hex", F = "15-dec" (if) z = #, skip next step z-hex = z-dec, z-dec = q (if) y = #, skip next step y-hex = y-dec, y-dec = r y*6 = s yz+s = yz-dec This looks confusing, I know, but I'll explain it as if I were talk to a 10-year-old child. First, "yz" represents a 2-digit hex value. Our value will be "64"(y=6, z=4). When "z" is an "A", A equals "10-d". Understand that so far? If "z"(in the 'yz' hex value) is a number, skip the next step(4 is a number, so we skip this next step). Transfer "z" to decimal(look at the "when's"). If "y" is a number, skip the next step(6 is also a number, we skip the next step). Transfer "y" to decimal(look at the "when's"). Multiply value "y" by 6, the factor is "s". 6*6 = 36, s=36. Add value yz and value s. 64+36 = 100 64-h = 100-d. Now let's do it short-hand - "yz" = C8 C = 12, yz = (12)8 12*6 = 72 (12)8 + 72 [7]2 -- 72-d +(12)8 -- C8-h ------ [20]0 -- 200-d C8 = 200 If this doesn't make sense, I didn't explain it well enough. It is important to understand how to do the number base conversions before continuing. If you do not understand, the reader is encouraged to review the material already presented. B-3) Bitwise Operations You may hear about "Bitwise Operators" and wonder what some of them actually do. They're used for doing binary math, for lack of a better explanation. & (AND) The AND operation can best be understood like addition.. only there's no adding or carrying involved... really the only similarity is that you work with each digit the same as you do with addition... Like this: 1000 +0001 ------ 1001 Just add each digit downward. Well, AND requires you to work with each digit downward as well. Here are the rules: 1 & 1 = 1 1 & 0 = 0 0 & 1 = 0 0 & 0 = 0 That means the result will be a 1 ONLY if both comparing digits are 1 Think of it as true and false.. if TRUE & TRUE, then TRUE. 1100 &1010 ------ 1000 Starting from the left-most digits, 0 & 0 = 0, 0 & 1 = 0, 1 & 0 = 0, 1 & 1 = 1.... and there's your result. You can use bitwise AND for a technique called MASKING. Masking allows you to strip certain bits, while saving others. Say you wanted to strip the upper nybble of a byte, and save only the lower nybble... Well, you AND that byte with 00001111b. When you do that, the upper 4 bits will be completely stripped, because 0 & anything is always equal to 0 and the lower four bits will copied over directly, because 1 & anything = bits that were set. This can be useful when dealing with hex numbers as well. Say you have AC1B02FF and you want the lower four bits for some reason. AC1B32ED AND 0000FFFF = 000032ED | (OR) When using OR, TRUE or anything = TRUE The rules: 1 OR 1 = 1 1 OR 0 = 1 0 OR 1 = 1 0 OR 0 = 0 OR is used to set bits... whereas AND is used to clear. So, if you wanted to set the least significant bit, your could do "BYTE OR 00000001" XOR XOR means EXCLUSIVE OR. it's purpose is to inverse bits. The rules: 1 XOR 1 = 0 1 XOR 0 = 1 0 XOR 1 = 1 0 XOR 0 = 0 Pretty simple here... it works just like OR, with the exception that 1 XOR 1 = 0. Say you have a flag, and you want to toggle it on and off. You can do "VAR XOR 00000001" and it will inverse it; it will turn it on if it's off, or it will turn it off if it's on. That's much easier than doing "if VAR = 0 then VAR = 1, else if VAR = 1 then VAR = 0." Just a simple XOR operation and you're done. Much faster. NOT NOT works EXACTLY like XOR with the mask completely filled with 1's NOT will inverse the variable completely. All 1's are changed to 0 in the result, and all 0's are changed to 1 in the result 10101010 XOR 11111111 = 01010101 NOT 10101010 = 01010101 What's the difference? As you can see, NOT does not have a mask... so you just say "NOT VAR" and you know it's the same as "VAR XOR 11111111" The difference could be speed. Especially in assembly, where you might have to load 0xFFFFFFFF into a register to perform the XOR; you could just do a simple NOT instead. Inversing is great because you can negate numbers with it NOT VAR + 1 = -VAR Take for example... NOT 00000001 = 11111110 11111110 + 1 = 11111111 and of course, 11111111 = FF, FF is -1 << (Left Shift) Shifting left works like multiplication when you shift left, all right-most bits get shifted over to the left, and 0's get shifted into the blank spaces. Here are some examples: 00111111 << 2 = 11111100 00000001 << 3 = 00001000 10000000 << 1 = 00000000 Just shifting digit places. So, shift left by 1 is the same as multiplying by 2, left shift by 2 is the same as multiplying by 4. shift left by 3 is the same as multiplying by 8, etc. Left shit works best as a means to multiply by a power of 2. 2^1 = 2, 2^2 = 4, 2^3 = 8, etc. Shift left x is the same as multiply by 2^x. >> (Right Shift) Right shift works the same, only opposite, so it's like dividing. When right shifting, bits shifted off of the right side are completely lost, and bits shifted in from the left come in as 0. Well, they usually shift in as 0 when right shifting. In MIPS, you may have noticed "Shift Right Arithmetic (SRA)" and "Shift Right Logical (SRL)." Shifting right logical will ALWAYS shift 0's into the new spaces. Shifting right arithmetic will shift the MSB (most signifigant bit) into the new spaces. The MSB is treated as a sign bit with arithmetic right shift. That's a way to preserve the sign when you divide a negative number. Here are some examples... SRA = Shift Right Arithmetic, SRL = Shift Right Logical: 10000000,00000000,00000000,00000000 SRA 4 = 11111000,00000000,00000000,00000000 10000000,00000000,00000000,00000000 SRL 4 = 00001000,00000000,00000000,00000000 B-4) Hexadecimal Hexadecimal is a programming 'language' you must know in order to hack GameShark codes. So, what is it? Hex is what your GameShark codes are written in. There are sixteen characters used in a GS code. The characters are as follows - 0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F Let's learn to count in hex. If you look above, you'll see how to count to fifteen in hex. What's sixteen? "10-h" is sixteen. By the way, don't say "ten," say, "one, zero" for '10-h'. Let's see what you've learned. What comes after 19? What comes after 3F? If you said, "1A" for question #1, that is correct. If you said, "40" for question #2, you should know how to count in hex! B-5) Octal Octal is just another way to write binary(like hex), but octal words are longer than hex words. What you've already read is enough to know about octal. You do not need to know octal to hack GS codes. B-6) ASCII ASCII is what you are looking at right now. ANYTHING that can be typed on the keyboard is ASCII. ASCII is useful to know when hacking in my secret way. It is also useful for using the text editor search option in hacking devices such as the GameShark PRO. You don't need to know the assignments for ASCII characters(although you might need to know them when hacking text editing codes). B-7) Floating Points Floating Points are a hexidecimal representation of "real numbers", usually following the IEEE-754 standard. This could be considered an advanced topic, if nothing else, because even some long time hackers I've mentioned it to have never heard of them. However, even those who haven't heard of them, have most likely dealt with them in one game or another. To put it in the simplest terms possible: Floating Points are numbers with decimal points. 100.0 and 100 are common values used by games to represent your max health. The difference is 100 is 64 in hex; 100.0 is 42C80000 in hex. In hacking terms, Floating Points can make it difficult to find some things, if you're only using 8-Bit comparisons. I'm not saying 32-Bit comparisons are required though. Most things that use Floating Points are still found by 16-bit searches. So how can you convert those hex values like 42C80000 to their decimal form? This is a question I've been asking for a while now. I'm told it involves advanced math functions like Shifts and XORs. Don't get worried though. As with most things that require much thinking, somebody wrote a program to do the conversions for us. You can get FloatConvert here. Nobody really knows who wrote this, but I thank that person whoever they are. It's not required you know anything about Floating Points to hack most codes, but they are a major part of games and certain, more advanced, code types can be harder to find if don't have a little understanding of this. C) About Most GameShark Hackers Most hackers use more than one way to hack. Most know programming languages such as binary/hex/octal, HTML and Perl, scripting languages, R300 Instruction sets, etc. HTML and Perl is included here because many hackers want to use this language to create a website that has all their codes displayed. You don't need to learn many of the things other than binary and hexadecimal to "hack better than the Pros." Here are some ways you can hack(1 star[*] by the name is easy, 2 is harder, etc.) - Guessing**** This isn't easy, because you don't always find a code this way. It's not only troublesome, but risky at some times. Some guessed codes can corrupt game data and corrupt hacking devices. Modifying Codes* One of the easiest things to do. Change a number on an existing code, you make a new code. (Only works when you have a basis[base code] to work with.) This technique was and still is widely used. Looking At The Source[Code]*** Hard, but most effective. Worth a shot. This technique requires the reader to have a working knowledge of dissembler programs and is currently beyond the scope of this work. Using Hacking Equipment* - ***(Code Generators; i.e. GS PRO) Another way to get codes. It might not be very easy, but it doesn't take much time. Plus, it's the second most effective way to hack. Can be used to get easy to hard code types. Porting** Porting is taking a code from one version of a game, and making it work on another version of that same game. This does not always work. The reason is the same reason that they make more than one version. Possibly to fix a minor bug. So the offsets will be in a higher or lower position, or even moved to a totally different location. You can use the "GS Code Porter"(available at GameShark Central) to port any code for you. Hence you can make a code before anyone else gets the chance! See FAQ section. Combination Hacking* - *** All you need to do is hack using two or more methods at once, for a greater chance of finding a code. (!!!!!There is a slight risk of loosing saved data on your GS when turning the system on and off while guessing or modifying codes.) ----------------------------------------------- IX) How-to Guide - Getting Started ----------------------------------------------- A) What do I need? You need a Game Platform(N64, PSX, Dreamcast, Game Boy, etc.), you need a game to hack, and you need a GameShark,GameShark PRO or GameShark CDX and/or other hacking devices such as the Blaze Xplorer/Xploder or Pelican CodeBreaker. You will also need other things to hack in other ways such as a hex editor and calculator can do hex math or perhaps an emulator that can capture memory dumps or can do game saves all of which can be analyzed later by some hex editor program. A will to learn, basic math skills, patience, endurance, practice and this using this document are the things you need. B) What do I need to Know? If you've managed to read everything above, then you know about basis of everything you'll need to know about hacking. The remainder is learning to use hacking equipment and the software for it and to master the basics as presented here and then from there to be resolved to try as best you can to hack the harder code types. C) Learn Your "Shark" and code types There are a few things you'll need to know about your GameShark before we begin hacking. You'll discover how the GameShark codes work. This is the layout of all N64/PSX 'Shark codes - XXYYYYYY ZZZZ This is the layout of all GB 'Shark codes - XXZZYY-YY This format is called endian. Most Memory ram dumps are in this format. The GB Gameshark rewrites the code to reversed endian format as XXZZYYY. The Pelican CodeBreaker uses unencrypted endian format. The Xploder uses both encrypted and decoded reverse endian formats. "X" digits is the 'prefix', used to tell the GS what kind of code you are using. "Y" digits are the 'Offset Digits', used to locate the offset digits you want to change. "Z" digits are the 'Quantity Digits', used to change the quantity of the chosen offset. The reason there is a hyphen between the Y's in the GB code layout is because the Y's are actually set up backwards. The first two Y's should be behind the second two. Of course, you only need to know this if you are going to use my hacking method... You ARE going to try it, right? Note: GameShark and Action Replay code types are the same.

*Nintendo 64 Code Types*		Compatibility
8-bit Constant Write	Constantly writes the value specified by YY to address XXXXXX. This and its 16-Bit counterpart below are the most used code types on N64. You'll probably be making most of your new codes with them.	GS/XP64
80XXXXXX 00YY

16-bit Constant Write	Constantly writes the 16-Bit value specified by YYYY to address XXXXXX.	GS/XP64
81XXXXXX YYYY

8-bit Uncached Write	Constantly writes the value specified by YY to the uncached address XXXXXX.	GS/XP64
A0XXXXXX 00YY

16-bit Uncached Write	Constantly writes the 16-Bit value specified by YYYY to the uncached address XXXXXX.	GS/XP64
A1XXXXXX YYYY

8-bit GS Button	Writes the value YY to address XXXXXX ONLY when the GS Button is pressed.	GS/XP64
88XXXXXX 00YY

16-bit GS Button	16bit version of the above. Writes the value YYYY to address XXXXXX ONLY when the GS Button is pressed.	GS/XP64
89XXXXXX YYYY

8-Bit Equal To Activator	Execute the following code (ZZZZZZZZ ZZZZ) ONLY when the value stored in address XXXXXX is equal to YY.	GS/XP64
D0XXXXXX 00YY ZZZZZZZZ ZZZZ
16-Bit Equal To Activator	Same as above, only it reads a 16bit value. GS Pro 3.0+ ONLY!	GS/XP64
D1XXXXXX YYYY ZZZZZZZZ ZZZZ
8-Bit Different To Activator	Execute the following code (ZZZZZZZZ ZZZZ) ONLY when the value stored in address XXXXXX is NOT equal to YY.	GS 3.0+
D2XXXXXX 00YY ZZZZZZZZ ZZZZ
16-Bit Different To Activator	Same as above, only it reads a 16bit value.	GS 3.0+
D3XXXXXX YYYY ZZZZZZZZ ZZZZ
Disable Expansion Pack	Keeps the game from using the expansion pack if it is present. Also used on some older non-expansion pack games to increase compatibility with the code generator.	GS Pro 3.2+
EE000000 0000
Disable Expansion Pack	Disabled the expansion pack (if present) using a secondary method.	GS Pro 3.2+
DD000000 0000
Disable Expansion Pack	Disabled the expansion pack (if present) using a 3rd method.	GS Pro 3.2+
CC000000 0000
Enable Code	Tells the GameShark where the value "3C0880" is in the RAM. This type of code does not write a value to the given address. It sets the entry point which the GS will use to start the game. Games which require that code have a specific protection chip which will set the entry point upon booting the N64.	GS 1.08+
DEXXXXXX 0000
Enable Code / 8-Bit Write Once	Tells the GameShark what address is causing malfunction with it, and writes the supplied value to that address. Writes the value YY to the address XXXXXX once on boot. F0\F1 codes write to RAM before starting the game. This way, the codes take effect before the code handler is executed.	GS Pro 3.0+ / XP64
F0XXXXXX 00YY
Enable Code / 16-Bit Write Once	16-Bit version of the above.	GS Pro 3.0+ / XP64
F1XXXXXX YYYY
Set Store Location For Active Codes	Sets the location in RAM where active codes are stored. Usually only used on games that utilize the expansion pack.	GS Pro 3.3+
FFXXXXXX 0000
Enable Code - Xploder64	The same as an F1 enabler on GS Pro.	XP64
2AXXXXXX YYYY
Enable Code - Xploder64	The exact use of this code type is unknown as of now.	XP64
3CXXXXXX YYYY
Patch Code	Patch codes, aka Serial Repeaters, are used to make a code string shorter. EG, You have five codes put together to give you "all weapons." Use the patch to shorten it to two codes. XX is the number of addresses to write; YY is the amount (offset) to add to each address; ZZ is the amount to add to each value.	GS Pro 3.3+
5000XXYY 00ZZ TTTTTTTT VVVV

*Playstation Code Types*		Compatibility
GameShark
8-bit Constant Write	Constantly writes the value specified by YY to address XXXXXX. This and its 16-bit counterpart below are the most used code types on PSX. You'll probably be making most of your new codes with them.	GS x.x
30XXXXXX 00YY
16-bit Constant Write	Constantly writes the value specified by YY to address XXXXXX. This and its 16-bit counterpart below are the most used code types on PSX. You'll probably be making most of your new codes with them.	GS x.x
80XXXXXX 00YY
8-bit Equal To Activator	When the value for the given address is equal to the supplied value, activate the following code.	GS 2.2+
E0XXXXXX 00YY
8-bit Different To Activator	When the value for the given address is different to the supplied value, activate the following code.	GS 2.2+
E1XXXXXX 00YY
8-bit Less Than Activator	When the value for the given address is less than the supplied value, activate the following code.	GS 2.2+
E2XXXXXX 00YY
8-bit Greater Than Activator	When the value for the given address is greater than the supplied value, activate the following code.	GS 2.2+
E3XXXXXX 00YY
16-bit Equal To Activator	When the value for the given address is equal to the supplied value, activate the following code.	GS x.x
D0XXXXXX 00YY
16-bit Different To Activator	When the value for the given address is different to the supplied value, activate the following code.	GS 2.2+
D1XXXXXX 00YY
16-bit Less Than Activator	When the value for the given address is less than the supplied value, activate the following code.	GS 2.2+
D2XXXXXX 00YY
16-bit Greater Than Activator	When the value for the given address is greater than the supplied value, activate the following code.	GS 2.2+
D3XXXXXX 00YY
16-bit Universal Activator	Same as D0 except not RAM dependent. More easily used as a button activator.	GS 2.41+
D4000000 YYYY
16-bit All-code Button Activator	When buttons pressed equal YYYY then activate all codes.	GS 2.41+
D5000000 YYYY
16-bit Universal De-Activator	When buttons pressed equal YYYY then de-activate all codes.	GS 2.41+
D6000000 YYYY
16-bit Increment Value	Add value(16-bit) code. Use with D/E activators. Example - (adds value "1007" to address "001221" when address "110012" equals value "5") D0110012 0005 10001221 1007	GS 2.2+
10XXXXXX 00YY
16-bit Decrement Value	Subtract value(16-bit) code. Use only with D/E activators. Example - (subtracts value "102" from address "001221" when address "110012" equals value "6") D0110012 0006 11001221 0102	GS 2.2+
11XXXXXX 00YY
8-bit Increment Value	Add value(8-bit) code. Use with D/E activators. Example - (adds value "7" to address "001221" when address "110012" equals value "5") D0110012 0005 20001221 0007	GS 2.2+
20XXXXXX 00YY
8-bit Decrement Value	Subtract value(8-bit) code. Use only with D/E activators. Example - (subtracts value "2" from address "001221" when address "110012" equals value "6") D0110012 0006 21001221 0002	GS 2.2+
21XXXXXX 00YY
Patch Code	Patch codes, aka Serial Repeaters, are used to make a code string shorter. EG, You have five codes put together to give you "all weapons." Use the patch to shorten it to two codes. XX is the number of addresses to write; YY is the amount (offset) to add to each address; ZZ is the amount to add to each value.	GS 2.41+
5000XXYY 00ZZ TTTTTTTT VVVV
Activate All Codes	Works like the D0/E0 code type, but affects ALL codes. Use as an (M) Must Be On if the game won't load with codes turned on.	GS 2.2+
C0XXXXXX YYYY
Activate All Codes On Delay	Works like the D0/E0 code type, but affects ALL codes. This is like a timer. A value of around 4000 or 5000 will usually give you a good 20-30 second delay before codes are activated. Use as an (M) Must Be On if the game won't load with codes turned on.	GS 2.41+
C1000000 YYYY
Copy Bytes	Copy's YYYY bytes from location XXXXXX to location ZZZZZZ. Example use would be: C2040450 0008 80040680 0000 That would copy 8 bytes from 40450 to 40680.	GS 2.41+
C2XXXXXX YYYY 80ZZZZZZ 0000
Xplorer/Xploder -- see explorer FAQ for more info
8-bit Constant Write	Writes value YY to address XXXXXX.	Xplorer
30XX XXXX 00YY
16-bit Constant Write	Writes value YYYY to address XXXXXX.	Xplorer
80XX XXXX YYYY
Slow Motion Code	Delays CPU by X per cycle. Best used with activator.	Xplorer
4000 0000 000X
Text Replace Code	Writes any number of bytes ZZ to address XXXXXX. YYYY is the number of bytes to write.	Xplorer
50XX XXXX YYYY ZZZZ ZZZZ ZZZZ ZZZZ ZZ.. ....
Do on Event Code	CPU breaks at address AAAAAAAA; YYYY is number of bytes used (XX's); FFFFFFFF is the break point mask; CCCC is the type of break point, which can be E180 (instruction gotton by CPU but not yet implemented), EE80 (data to be read or written), E680 (data to be read), EA80 (data to be wrtten) or EF80 (instruction).	Xplorer
6000 0000 YYYY AAAA AAAA CCCC FFFF FFFF XXXX XXXX XXXX XXXX
Do-if-True Code	If address XXXXXX is equal to value YYYY execute following code.	Xplorer
70XX XXXX YYYY
Do-if-False Code	If address XXXXXX is not equal to value YYYY execute following code.	Xplorer
90XX XXXX YYYY
Patch Code	nn is the number of repetitions (plus one); AAAA is the size of the address step; BBBB is the increase in the data value per step; XXXXXX is the initial address; YYYY is the inital value.	Xplorer
B0nn AAAA BBBB 10XX XXXX YYYY
Do-if-True Code (c-code)	Same as 7-code, but only functions from 0010 0000 to 01FF FFFF.	Xplorer
C0XX XXXX YYYY
Do-if-True Code (d-code)	Same as 7-code. but only functions from 0000 0000 to 000F FFFF.	Xplorer
D0XX XXXX YYYY
Auto-Activating Code	Automatically activates other selected codes if address XXXXXX is equal to YYYY.	Xplorer
F0XX XXXX YYYY
32-Bit Constant Write	32-bit constant write to XXXXXX address (0000YYYY)	Xplorer
00XX XXXX YYYY

*Playstation 2 Code Types - Courtesy hellion (hellion00.thegfcc.com)*
Note that all the code types below are in RAW form. RAW codes must be encrypted to work on the Gameshark™ for Playstation 2.
8-bit Constant Write	This command will constantly write the value specified by dd to the address specified by aaaaaaa.
0aaaaaaa 000000dd
16-bit Constant Write	This command will constantly write the value specified by dddd to the address specified by aaaaaaa.
1aaaaaaa 0000dddd
32-bit Constant Write	This command will constantly write the value specified by dddddddd to the address specified by aaaaaaa.
2aaaaaaa dddddddd
Increment/Decrement Commands
8-bit Increment	This command adds the value specified by nn to the value stored at the address aaaaaaaa.
301000nn aaaaaaaa
8-bit Decrement	This command subtracts the value specified by nn to the value stored at the address aaaaaaaa.
302000nn aaaaaaaa
16-bit Increment	This command adds the value specified by nnnn to the value stored at the address aaaaaaaa.
3030nnnn aaaaaaaa
16-bit Decrement	This command subtracts the value specified by nnnn to the value stored at the address aaaaaaaa.
3040nnnn aaaaaaaa
32-bit Increment	This command adds the value specified by nnnnnnnn to the value stored at the address aaaaaaaa.
30500000 aaaaaaaa nnnnnnnn 00000000
32-bit Decrement	This command subtracts the value specified by nnnnnnnn to the value stored at the address aaaaaaaa.
30600000 aaaaaaaa nnnnnnnn 00000000
Test Commands
16-bit Equal	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.
Daaaaaaa 0000dddd
16-bit Not Equal	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.
Daaaaaaa 0010dddd
16-bit Less Than	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.
Daaaaaaa 0020dddd
16-bit Greater Than	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.
Daaaaaaa 0030dddd
16-bit Equal : Multiple Skip	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.
Ennndddd 0aaaaaaa
16-bit Not Equal : Multiple Skip	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.
Ennndddd 1aaaaaaa
16-bit Less Than : Multiple Skip	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.
Ennndddd 2aaaaaaa
16-bit Greater Than : Multiple Skip	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.
Ennndddd 3aaaaaaa
Miscellaneous Commands
Copy Bytes (GS2 v2.0 or higher)	a = Address to copy from b = Address to copy to n = Number of bytes to copy
5aaaaaaa nnnnnnnn bbbbbbbb 00000000
32-bit Multi-Address Write	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. Also known as a "Patch Code."
4aaaaaaa xxxxyyyy dddddddd 00000000
Untested Commands
3000nnnn dddddddd aaaaaaaax(n-1)	32-bit Multiple Address Write?
8aaaaaaa bbbbbbbb cccccccc 00000000	Master Command
Aaaaaaaa dddddddd	32-bit Write Once?
B0000000 nnnnnnnn	Timer Command
Caaaaaaa dddddddd	32-bit Equal?
Faaaaaaa bbbbbbbb	Master Command
DEADFACE xxxxxxxx	"DEADFACE" Master Command - changes encryption seeds

*Sega Dreamcast Code Types*
The following are what decrypted or raw code types look like. Xploder and Codebreaker use this format. Gameshark uses an encrypted format for the first line of the code (the address) while all use the second line as is (offset or quantifier). Dreamcast has 32 bit codes. These codes will require 8 digits for the offset and 8 digits for the quantifier, 2^32= FFFFFFFF in hex. Example, XXYYYYYY ZZZZZZZZ. Note: It is not unusual for manufacturers of cheating devices to encrypt their codes. Fire International (Blaze USA) has encrypted codes in both its N64 and Game Boy Xploder/Xplorer, while Interact has employed encryption in its DC Shark, GameBoy Advance Shark, and Playstation 2 Shark. If the code begins with a '0', then it is in decrypted format. As in any encryption there always is a crack to defeat it. Codebreaker and Xploder both have the built in ability to accept DC gameshark codes in decipher them. It is left to the reader to explore the decryption further.
Code Value	Description
00xxxxxx 000000vv	Write 8bit (byte) value "vv" to memory address 8cxxxxxx. That is, 8 bit constant write.
01xxxxxx 0000vvvv	Write 16bit (2byte) value "vvvv" to memory address 8cxxxxxx. That is, 16 bit constant write.
02xxxxxx vvvvvvvv	Write 32bit (4byte) value "vvvvvvvv" to memory address 8cxxxxxx. That is, 32 bit constant write.
0300nnnn aaaaaaaa	Group write code. nn specifies how many 32 bit values follow. aaaaaaaa is the addrsss to write to. The values following this code are written to address aaaaaaaa. E.g: 03000004 8c012000 11111111 22222222 33333333 44444444 The effect is as follows: With a count of 00000004 codes, to address 8c012000: 8c012000 = 11111111 8c012004 = 22222222 8c012008 = 33333333 8c01200c = 44444444
030100vv aaaaaaaa	Increment code. Add the 8bit value vv to the value at address aaaaaaaa
030200vv aaaaaaaa	Decrement code. Subtract the 8bit value vv from the value at address aaaaaaaa
0303vvvv aaaaaaaa	Increment code. Add the 16bit value vvvv to the value at address aaaaaaaa
0304vvvv aaaaaaaa	Decrement code. Subtract the 16bit value vvvv from the value at address aaaaaaaa
03050000 aaaaaaaa vvvvvvvv	Increment code. Add the 32bit value vvvvvvvv to the value at address aaaaaaaa Note that this code is 3 lines long and so will require an 0exxxxxx condition (not a 0dxxxxxx) if you're using it with a condition code.
03060000 aaaaaaaa vvvvvvvv	Decrement code. Subtract the 32bit value vvvvvvvv from the value at address aaaaaaaa Note that this code is 3 lines long and so will require an 0exxxxxx condition (not a 0dxxxxxx) if you're using it with a condition code.
04xxxxxx rrrrssss vvvvvvvv	Repeat/Filler code. Writes to address 8Cxxxxxx. Writes the 32bit value vvvvvvvv. Repeats this rrrr time, each time increasing the address by ssss (actually ssss x 4). That is, 32-Bit Constant Serial Write E.g: 04007a30 00030001 12345678 Effect: 8c007a30 = 12345678 8c007a34 = 12345678 8c007a38 = 12345678
05xxxxxx dddddddd nnnnnnnn	Copy bytes code. Copy nnnnnnnn bytes from the address 8cxxxxxx to the address dddddddd. That is, constant copy bytes
071000XX	Change Decryption Type
0b0xxxxx	Delay putting on codes for xxxxx cycles. Default 1000 (0x3e7)
0cxxxxxx vvvvvvvv	If the value at address 8Cxxxxxx is equal to vvvvvvvv, execute ALL codes; otherwise no codes are executed. Useful for waiting until game has loaded.
0dxxxxxx 0000vvvv	If the value at address 8Cxxxxxx is equal to vvvv, execute the following code. Can be used with code types 00, 01 and 02 only. To use this type of control with other codes use an 0e code.
0dxxxxxx 0001vvvv	If the value at address 8Cxxxxxx is different to vvvv, execute the following code. Can be used with code types 00, 01 and 02 only. To use this type of control with other codes use an 0e code.
0dxxxxxx 0002vvvv	If the value at address 8Cxxxxxx is less than vvvv (unsigned), execute the following code. Can be used with code types 00, 01 and 02 only. To use this type of control with other codes use an 0e code.
0dxxxxxx 0003vvvv	If the value at address 8Cxxxxxx is greater than vvvv (unsigned), execute the following code. Can be used with code types 00, 01 and 02 only. To use this type of control with other codes use an 0e code.
0ennvvvv 00aaaaaa	If the value at address 8caaaaaa is equal to vvvv, execute the following nnnn lines of codes. E.g: 0e04abcd 00012000 02300040 ffffffff 02300050 eeeeeeee if address 8c012000==abcd, execute the 04 lines of codes following. The 4 lines of codes being two "02xxxxxx" codes "02300040=ffffffff" and "02300050=eeeeeeee".
0ennvvvv 01aaaaaa	If the value at address 8caaaaaa is different to vvvv, execute the following nnnn lines of codes.
0ennvvvv 02aaaaaa	If the value at address 8caaaaaa is less than vvvv (unsigned), execute the following nnnn lines of codes.
0ennvvvv 03aaaaaa	If the value at address 8caaaaaa is greater than vvvv (unsigned), execute the following nnnn lines of codes.
0F-XXXXXX 0000YYYY	16-Bit Write Once Immediately. (Activator code)

*Sega Saturn Code Types - Courtesy Leo/AGSCC and CodeMaster*
16-bit Constant Write	Just what it implies. Continuously writes YYYY value to XXXXXXX address.
1XXXXXXX YYYY
8-bit Constant Write	Continuous write of YY value to address XXXXXXX.
3XXXXXXX 00YY
16-bit Write Once	Writes YYYY value to XXXXXXX address once on boot up. Same as F0/F1 on N64
0XXXXXXX YYYY
16-bit Equal To Activator	Activates the code on the line directly beneath it ONLY when XXXXXXX address is YYYY value.
DXXXXXXX YYYY
16-Bit Enable Code	Enable Code
FXXXXXXX YYYY

*Gameboy/Gameboy Color Code Types*
8-bit Constant Write	The most common GS code prefix for Gameboy is "01". This means the code resides in the first bank of the address line. Codebreaker users will find that 00 and 01 are equally used code types. The "00" simply means the code resides in the zero bank and "01" as above, the first bank. There are no known other code types for gameboy as there are for N64, Playstation and Dreamcast. Z is the data bank; XXXX is the address; YY is the value.
0ZYYXXXX

Gameboy Advance Gameshark V1/V2 Code Types - by Parasyte (Additions by DGenerateKane)
Note that all the code types below are in RAW form. RAW codes must be encrypted to work on the Gameshark for Gameboy Advance.
8-bit Constant Write	Continuously writes the value xx to the RAM address aaaaaaa.
0aaaaaaaa 000000xx
16-bit Constant Write	Continuously writes the 16-Bit value xxxx to the RAM address aaaaaaa. Address must be aligned to 2 (must end with one of the following digits - 0,2,4,6,8,A,C,E).
1aaaaaaaa 0000xxxx
32-bit Constant Write	Continuously writes the 32-Bit value xxxxxxxx to the RAM address aaaaaaa. Address must be aligned to 4 (must end with one of the following digits - 0,4,8,C).
2aaaaaaaa xxxxxxxx
32-bit Group Write	Writes data to the following "count" (cccc) addresses. (xxxxxxxx value is also concidered an address, not really a problem, just a very stupid bug -- thanks Datel!!) Many addresses can follow. Example: 30000004 01010101 03001FF0 03001FF4 03001FF8 00000000 (write 01010101 to 3 addresses - 01010101, 03001FF0, 03001FF4, and 03001FF8. '00000000' is used for padding, to ensure the last code encrypts correctly)
3000cccc xxxxxxxx aaaaaaaa
16-bit ROM Patch	This type allows GSA to intercept ROM reads and returns the value xxxx. The address is shifted to the right by 1 (divided by 2). You can either manually shift the address left by 1, or multiply by 2 to get the real address. GSAcrypt (Win32 version) has an option to automatically shift the address for you. Note: V1\V2 hardware can only have up to 1 user-defined rom patch max. V3 can have up to 4. some enable code types can shorten the amount of user-defined rom patches available.
6aaaaaaa 0000xxxx
16-bit ROM Patch	Similar to first ROM patch code, except patch is enabled before the game starts, instead of waiting for the code handler to enable the patch. (address >> 1)
6aaaaaaa 1000xxxx
16-bit ROM Patch	16-bit ROM Patch ? (address >> 1)
6aaaaaaa 2000xxxx
8-bit GS Button Code	8-Bit RAM write only when the GS Button is pressed.
8a1aaaaa 000000xx
16-bit GS Button Code	16-Bit RAM write only when the GS Button is pressed.
8a2aaaaa 000000xx
Slowdown On GS Button	Slow down on GS Button. This type will put the GBA into a loop for "xxxx" number of times, each time the code handler is run. This slows the game down.
80F00000 0000xxxx
16-Bit 'If Equal To' Activator	Activate the code on the next line ONLY when the value of address 'aaaaaaa' is Equal To xxxx.
Daaaaaaa 0000xxxx
16-Bit 'If Equal To' Activator (Multi-Line)	16-Bit activate the multi lines if-true. If the value at address is equal to xxxx, execute following 'zz' lines.
E0zzxxxx aaaaaaaa
Hook Routine (For Enablers)	Used to insert the GS code handler routine where it will be executed at least 20 times per second. Without this code, GSA can not write to RAM. xxxx: 0001 - Executes code handler without backing up the $lr register. Must turn GSA off before loading game. 0002 - Executes code handler and backs up the $lr register. Must turn GSA off before loading game. 0003 - Replaces a 32-bit pointer used for long-branches. Must turn GSA off before loading game. 0101 - Executes code handler without backing up the $lr register. 0102 - Executes code handler and backs up the $lr register. 0103 - Replaces a 32-bit pointer used for long-branches.
Faaaaaaa 0000xxxx
ID Code (For Enablers)	Used by GSA only for auto-detecting the inserted game.
xxxxxxxx 001DC0DE
DEADFACE - Change Encryption Seeds	"Deadface" is used to change the encryption seeds. It's original intent was probably to re- encrypt codes if someone figured out the normal encryption. (Very similiar to the CBA's '9' code type.)
DEADFACE 0000xxxx

Gameboy Advance Codebreaker Code Types - by Parasyte (Additions by DGenerateKane)
Note that all the code types below are in RAW form. RAW codes must be encrypted to work on the Codebreaker for Gameboy Advance.
Master Code #1	xxxx is the CRC value (the "Game ID" converted to hex) Flags ("yyyy"): 0008 - CRC Exists (CRC is used to autodetect the inserted game) 0002 - Disable Interupts
0000xxxx yyyy
Master Code #2	'y' is the CBA Code Handler Store Address (0-7) [address = ((d << 0x16) + 0x08000100)] 1000 - 32-bit Long-Branch Type (Thumb) 2000 - 32-bit Long-Branch Type (ARM) 3000 - 8-bit(?) Long-Branch Type (Thumb) 4000 - 8-bit(?) Long-Branch Type (ARM) 0020 - Unknown (Odd Effect)
1aaaaaaa xxxy
8-Bit Constant RAM Write	Continuosly writes the 8-Bit value specified by 'yy' to address aaaaaaa.
3aaaaaaa 00yy
Slide Code	This is one of those two-line codes. The "yyyy" set is the data to store at the address (aaaaaaa), with xxxxxxxx being the number of addresses to store to, and iiii being the value to increment the addresses by. The codetype is usually use to fill memory with a certain value.
4aaaaaaa yyyy xxxxxxxx iiii
16-Bit Logical AND	Performs the AND function on the address provided with the value provided. I'm not going to explain what AND does, so if you'd like to know I suggest you see the instruction manual for a graphing calculator. This is another advanced code type you'll probably never need to use.
6aaaaaaa yyyy
16-Bit 'If Equal To' Activator	If the value at the specified RAM address (aaaaaaa) is equal to yyyy value, active the code on the next line.
7aaaaaaa yyyy
16-Bit Constant RAM Write	Continuosly writes yyyy values to the specified RAM address (aaaaaaa).
8aaaaaaa yyyy
Change Encryption Seeds (When 1st Code Only!)	Works like the DEADFACE on GSA. Changes the encryption seeds used for the rest of the codes.
9yyyyyyy yyyy
16-Bit 'If Not Equal' Activator	Basicly the opposite of an 'If Equal To' Activator. Activates the code on the next line if address xxxxxxx is NOT equal to yyyy
Axxxxxxx yyyy
16-Bit Conditional RAM Write	No Description available at this time.
D00000xx yyyy

*AR V3 Codes Types*
About the Code Types Numbers
Let's take for exemple : Type E3 3.0.3.1.x : 00XXXXXX : (00000130 -> C7000130) ZZZZZZZZ : Write the Word ZZZZZZZZ to the address $4XXXXXX 3.0.3.1.x : 1st number = 3 = Data size (0 to 3) 2nd number = 0 = Code Type (0 to 7) 3rd number = 3 = Cude subtype (0 to 3) 4th number = 1 = Special bit (0 to 1) 5th number : x = Unused bit (0 to 3) 3.0.3.1.0 gives these (bit speaking) = 11.000.11.1.00 reverse it : 00.1.11.000.11 = 0011100011 = E3 = The code type. I choose to take this numbering to make it that the Ram 8bits write (Type 0), Ram 16bits write Type 1 andRam 32bits write (Type 2) have the same type number than for AR/GS V1/2. Moreover, If I didn't "reverse" the numbers, we've gotten almost only even code type number, which, IMHO, sounds really strange...
1) Normal RAM Write Codes
Type 00 0.0.0.x.x	(02024EA4 -> 00224EA4) Fill area (XXXXXXXX) to (XXXXXXXX+YYYYYY) with Byte ZZ.
XXXXXXXX YYYYYYZZ
Type 01 1.0.0.x.x	(02024EA4 -> 02224EA4) Fill area (XXXXXXXX) to (XXXXXXXX+YYYY*2) with Halfword ZZZZ.
XXXXXXXX YYYYZZZZ
Type 02 2.0.0.x.x	(02024EA4 -> 04224EA4) Write the Word ZZZZZZZZ to address XXXXXXXX.
XXXXXXXX ZZZZZZZZ
2) Pointer RAM Write Codes
Type 20 0.0.1.x.x	(02024EA4 -> 40224EA4) Writes Byte ZZ to ([the address kept in XXXXXXXX]+[YYYYYY]).
XXXXXXXX YYYYYYZZ
Type 21 1.0.1.x.x	(02024EA4 -> 4224EA4) Writes Halfword ZZZZ ([the address kept in XXXXXXXX]+[YYYY*2]).
XXXXXXXX YYYYZZZZ
Type 22 2.0.1.x.x	(02024EA4 -> 4424EA4) Writes the Word ZZZZZZZZ to [the address kept in XXXXXXXX].
XXXXXXXX ZZZZZZZZ
3) Add Codes
Type 40 0.0.2.x.x	(02024EA4 -> 80224EA4) Add the Byte ZZ to the Byte stored in XXXXXXXX.
XXXXXXXX 000000ZZ
Type 41 1.0.2.x.x	(02024EA4 -> 82224EA4) Add the Halfword ZZZZ to the Halfword stored in XXXXXXXX.
XXXXXXXX 0000ZZZZ
Type 42 2.0.2.x.x	(02024EA4 -> 84224EA4) Add the Word ZZZZ to the Halfword stored in XXXXXXXX.
XXXXXXXX ZZZZZZZZ
4) Write to $4000000 (IO Registers!)
Type 63 3.0.3.0.x	(00000130 -> C6000130) Write the Halfword ZZZZ to the address $4XXXXXX
00XXXXXX 0000ZZZZ
Type E3 3.0.3.1.x	(00000130 -> C7000130) Write the Word ZZZZZZZZ to the address $4XXXXXX
00XXXXXX ZZZZZZZZ
5) If Equal Code (= Joker Code)
Type 04 0.1.0.x.x	(02024EA4 -> 08224EA4) If Byte at XXXXXXXX = ZZ then execute next code.
XXXXXXXX 000000ZZ
Type 24 0.1.1.x.x	(02024EA4 -> 48224EA4) If Byte at XXXXXXXX = ZZ then execute next 2 codes.
XXXXXXXX 000000ZZ
Type 44 0.1.2.x.x	(02024EA4 -> 88224EA4) If Byte at XXXXXXXX = ZZ execute all the codes below this one in the same row (else execute none of the codes below).
XXXXXXXX 000000ZZ
Type 64 0.1.3.x.x	(02024EA4 -> C8224EA4) While Byte at XXXXXXXX <> ZZ turn off all codes.
XXXXXXXX 000000ZZ
Type 05 1.1.0.x.x	(02024EA4 -> 0A224EA4) If Halfword at XXXXXXXX = ZZZZ then execute next code.
XXXXXXXX 0000ZZZZ
Type 05 1.1.0.x.x	(02024EA4 -> 0A224EA4) If Halfword at XXXXXXXX = ZZZZ then execute next code.
XXXXXXXX 0000ZZZZ
Type 25 1.1.1.x.x	(02024EA4 -> 4A224EA4) If Halfword at XXXXXXXX = ZZZZ then execute next 2 codes.
XXXXXXXX 0000ZZZZ
Type 45 1.1.2.x.x	(02024EA4 -> 8A224EA4) If Halfword at XXXXXXXX = ZZZZ execute all the codes below this one in the same row (else execute none of the codes below).
XXXXXXXX 0000ZZZZ
Type 65 1.1.3.x.x	(02024EA4 -> CA224EA4) While Halfword at XXXXXXXX <> ZZZZ turn off all codes.
XXXXXXXX 0000ZZZZ
Type 06 2.1.0.x.x	(02024EA4 -> 0C224EA4) If Word at XXXXXXXX = ZZZZZZZZ then execute next code.
XXXXXXXX ZZZZZZZZ
Type 26 2.1.1.x.x	(02024EA4 -> 4C224EA4) If Word at XXXXXXXX = ZZZZZZZZ then execute next 2 codes.
XXXXXXXX ZZZZZZZZ
Type 46 2.1.2.x.x	(02024EA4 -> 8C224EA4) If Word at XXXXXXXX = ZZZZZZZZ execute all the codes below this one in the same row (else execute none of the codes below).
XXXXXXXX ZZZZZZZZ
Type 66 2.1.3.x.x	(02024EA4 -> CC224EA4) While Word at XXXXXXXX <> ZZZZZZZZ turn off all codes.
XXXXXXXX ZZZZZZZZ
6) If Different Code
Type 08 0.2.0.x.x	(02024EA4 -> 10224EA4) If Byte at XXXXXXXX <> ZZ then execute next code.
XXXXXXXX 000000ZZ
Type 28 0.2.1.x.x	(02024EA4 -> 50224EA4) If Byte at XXXXXXXX <> ZZ then execute next 2 codes.
XXXXXXXX 000000ZZ
Type 48 0.2.2.x.x	(02024EA4 -> 90224EA4) If Byte at XXXXXXXX <> ZZ execute all the codes below this one in the same row (else execute none of the codes below).
XXXXXXXX 000000ZZ
Type 68 0.2.3.x.x	(02024EA4 -> D0224EA4) While Byte at XXXXXXXX = ZZ turn off all codes.
XXXXXXXX 000000ZZ
Type 09 1.2.0.x.x	(02024EA4 -> 12224EA4) If Halfword at XXXXXXXX <> ZZZZ then execute next code.
XXXXXXXX 0000ZZZZ
Type 29 1.2.1.x.x	(02024EA4 -> 52224EA4) If Halfword at XXXXXXXX <> ZZZZ then execute next 2 codes.
XXXXXXXX 0000ZZZZ
Type 49 1.2.2.x.x	(02024EA4 -> 92224EA4) If Halfword at XXXXXXXX <> ZZZZ disable all the codes below this one.
XXXXXXXX 0000ZZZZ
Type 69 1.2.3.x.x	(02024EA4 -> D2224EA4) While Halfword at XXXXXXXX = ZZZZ turn off all codes.
XXXXXXXX 0000ZZZZ
Type 0A 2.2.0.x.x	(02024EA4 -> 14224EA4) If Word at XXXXXXXX <> ZZZZZZZZ then execute next code.
XXXXXXXX ZZZZZZZZ
Type 2A 2.2.1.x.x	(02024EA4 -> 54224EA4) If Word at XXXXXXXX <> ZZZZZZZZ then execute next 2 codes.
XXXXXXXX ZZZZZZZZ
Type 4A 2.2.2.x.x	(02024EA4 -> 94224EA4) If Word at XXXXXXXX <> ZZZZZZZZ disable all the codes below this one.
XXXXXXXX ZZZZZZZZ
Type 6A 2.2.3.x.x	(02024EA4 -> D4224EA4) While Word at XXXXXXXX = ZZZZZZZZ turn off all codes.
XXXXXXXX ZZZZZZZZ
7) [If Byte at address XXXXXXXX is lower than ZZ] (signed) Code
Signed means : For bytes : values go from -128 to +127. For Halfword : values go from -32768/+32767. For Words : values go from -2147483648 to 2147483647. For exemple, for the Byte comparison, 7F (127) will be > to FF (-1).
Type 0C 0.3.0.x.x	(02024EA4 -> 18224EA4 or 28224EA4) If ZZ > Byte at XXXXXXXX then execute next code.
XXXXXXXX 000000ZZ
Type 2C 0.3.1.x.x	(02024EA4 -> 58224EA4 or 68224EA4) If ZZ > Byte at XXXXXXXX then execute next 2 codes.
XXXXXXXX 000000ZZ
Type 4C 0.3.2.x.x	(02024EA4 -> 98224EA4 or A8224EA4) If ZZ > Byte at XXXXXXXX then execute all following codes in the same row (else execute none of the codes below).
XXXXXXXX 000000ZZ
Type 6C 0.3.3.x.x	(02024EA4 -> D8224EA4 or E8224EA4) While ZZ <= Byte at XXXXXXXX turn off all codes.
XXXXXXXX 000000ZZ
Type 0D 1.3.0.x.x	(02024EA4 -> 1A224EA4 or 2A224EA4) If ZZZZ > Halfword at XXXXXXXX then execute next line.
XXXXXXXX 0000ZZZZ
Type 2D 1.3.1.x.x	(02024EA4 -> 5A224EA4) If ZZZZ > Halfword at XXXXXXXX then execute next 2 lines.
XXXXXXXX 0000ZZZZ
Type 4D 1.3.2.x.x	(02024EA4 -> 9A224EA4) If ZZZZ > Halfword at XXXXXXXX then execute all following codes in the same row (else execute none of the codes below).
XXXXXXXX 0000ZZZZ
Type 6D 1.3.3.x.x	(02024EA4 -> DA224EA4) While ZZZZ <= Halfword at XXXXXXXX turn off all codes.
XXXXXXXX 0000ZZZZ
Type 0E 2.3.0.x.x	(02024EA4 -> 1C224EA4) If ZZZZZZZZ > Word at XXXXXXXX then execute next line.
XXXXXXXX ZZZZZZZZ
Type 2E 2.3.1.x.x	(02024EA4 -> 5C224EA4) If ZZZZZZZZ > Word at XXXXXXXX then execute next 2 lines.
XXXXXXXX ZZZZZZZZ
Type 4E 2.3.2.x.x	(02024EA4 -> 9C224EA4) If ZZZZZZZZ > HWord at XXXXXXXX then execute all following codes in the same row (else execute none of the codes below).
XXXXXXXX ZZZZZZZZ
Type 6E 2.3.3.x.x	(02024EA4 -> DC224EA4) While ZZZZZZZZ <= Word at XXXXXXXX turn off all codes.
XXXXXXXX ZZZZZZZZ
8) [If Byte at address XXXXXXXX is higher than ZZ] (signed) Code
Signed means : For bytes : values go from -128 to +127. For Halfword : values go from -32768/+32767. For Words : values go from -2147483648 to 2147483647. For exemple, for the Byte comparison, 7F (127) will be > to FF (-1).
Type 10 0.4.0.x.x , 0.6.0.x.x	(02024EA4 -> 20224EA4 or 30224EA4) If ZZ < Byte at XXXXXXXX then execute next code.
XXXXXXXX 000000ZZ
Type 30 0.4.1.x.x	(02024EA4 -> 60224EA4 or 70224EA4) If ZZ < Byte at XXXXXXXX then execute next 2 codes.
XXXXXXXX 000000ZZ
Type 50 0.4.2.x.x , 0.6.2.x.x	(02024EA4 -> A0224EA4 or B0224EA4) If ZZ < Byte at XXXXXXXX then execute all following codes in the same row (else execute none of the codes below).
XXXXXXXX 000000ZZ
Type 70 0.4.3.x.x	(02024EA4 -> E0224EA4 or F0224EA4) While ZZ => Byte at XXXXXXXX turn off all codes.
XXXXXXXX 000000ZZ
Type 11 1.4.0.x.x, 1.6.0.x.x	(02024EA4 -> 22224EA4 or 32224EA4) If ZZZZ < Halfword at XXXXXXXX then execute next line.
XXXXXXXX 0000ZZZZ
Type 31 1.4.1.x.x	(02024EA4 -> 62224EA4) If ZZZZ < Halfword at XXXXXXXX then execute next 2 lines.
XXXXXXXX 0000ZZZZ
Type 51 1.4.2.x.x, 1.6.2.x.x	(02024EA4 -> A2224EA4 or B2224EA4) If ZZZZ < Halfword at XXXXXXXX then execute all following codes in the same row (else execute none of the codes below).
XXXXXXXX 0000ZZZZ
Type 71 1.4.3.x.x	(02024EA4 -> E2224EA4) While ZZZZ => Halfword at XXXXXXXX turn off all codes.
XXXXXXXX 0000ZZZZ
Type 12 2.4.0.x.x, 2.6.0.x.x	(02024EA4 -> 24224EA4 or 34224EA4) If ZZZZ < Halfword at XXXXXXXX then execute next line.
XXXXXXXX 0000ZZZZ
Type 32 2.4.1.x.x	(02024EA4 -> 64224EA4) If ZZZZ < Halfword at XXXXXXXX then execute next 2 lines.
XXXXXXXX 0000ZZZZ
Type 52 2.4.2.x.x,2.6.2.x.x	(02024EA4 -> A4224EA4 or B4224EA4) If ZZZZ < Halfword at XXXXXXXX then execute all following codes in the same row (else execute none of the codes below).
XXXXXXXX 0000ZZZZ
Type 72 2.4.3.x.x	(02024EA4 -> E4224EA4) While ZZZZ => Halfword at XXXXXXXX turn off all codes.
XXXXXXXX 0000ZZZZ
9) [If Value at adress XXXXXXXX is lower than...] (unsigned) Code
Unsigned means : For bytes : values go from 0 to +255. For Halfword : values go from 0 to +65535. For Words : values go from 0 to 4294967295. For exemple, for the Byte comparison, 7F (127) will be < to FF (255).
Type 14 0.5.0.x.x	(02024EA4 -> 28224EA4) If ZZZZZZZZ > Byte at XXXXXXXX then execute next line.
XXXXXXXX ZZZZZZZZ
Type 34 0.5.1.x.x	(02024EA4 -> 68224EA4) If ZZZZZZZZ > Byte at XXXXXXXX then execute next 2 lines.
XXXXXXXX ZZZZZZZZ
Type 54 0.5.2.x.x	(02024EA4 -> A8224EA4) If ZZZZZZZZ > Byte at XXXXXXXX then execute all following codes in the same row (else execute none of the codes below).
XXXXXXXX ZZZZZZZZ
Type 74 0.5.3.x.x	(02024EA4 -> E8224EA4) While ZZ <= Byte at XXXXXXXX turn off all codes.
XXXXXXXX ZZZZZZZZ
Type 15 1.5.0.x.x	(02024EA4 -> 2A224EA4) If ZZZZZZZZ > Halfword at XXXXXXXX then execute next line.
XXXXXXXX ZZZZZZZZ
Type 35 1.5.1.x.x	(02024EA4 -> 6A224EA4) If ZZZZZZZZ > Halfword at XXXXXXXX then execute next 2 lines.
XXXXXXXX ZZZZZZZZ
Type 55 1.5.2.x.x	(02024EA4 -> AA224EA4) If ZZZZZZZZ > Halfword at XXXXXXXX then execute all following codes in the same row (else execute none of the codes below).
XXXXXXXX ZZZZZZZZ
Type 75 1.5.3.x.x	(02024EA4 -> EA224EA4) While ZZZZZZZZ <= Halfword at XXXXXXXX turn off all codes.
XXXXXXXX ZZZZZZZZ
Type 16 2.5.0.x.x	(02024EA4 -> 2C224EA4) If ZZZZZZZZ > Word at XXXXXXXX then execute next line.
XXXXXXXX ZZZZZZZZ
Type 36 2.5.1.x.x	(02024EA4 -> 6C224EA4) If ZZZZZZZZ > Word at XXXXXXXX then execute next 2 lines.
XXXXXXXX ZZZZZZZZ
Type 56 2.5.2.x.x	(02024EA4 -> AC224EA4) If ZZZZZZZZ > Word at XXXXXXXX then execute all following codes in the same row (else execute none of the codes below).
XXXXXXXX ZZZZZZZZ
Type 76 2.5.3.x.x	(02024EA4 -> EC224EA4) While ZZZZZZZZ <= Word at XXXXXXXX turn off all codes.
XXXXXXXX ZZZZZZZZ
10) [If Value at adress XXXXXXXX is higher than...] (unsigned) Code
Unsigned means For bytes : values go from 0 to +255. For Halfword : values go from 0 to +65535. For Words : values go from 0 to 4294967295. For exemple, for the Byte comparison, 7F (127) will be < to FF (255).
Type 18 0.6.0.x.x	(02024EA4 -> 30224EA4) If ZZZZZZZZ < Byte at XXXXXXXX then execute next line..
XXXXXXXX ZZZZZZZZ
Type 38 0.6.1.x.x	(02024EA4 -> 70224EA4) If ZZZZZZZZ < Byte at XXXXXXXX then execute next 2 lines.
XXXXXXXX ZZZZZZZZ
Type 58 0.6.2.x.x	(02024EA4 -> B0224EA4) If ZZZZZZZZ < Byte at XXXXXXXX then execute all following codes in the same row (else execute none of the codes below).
XXXXXXXX ZZZZZZZZ
Type 78 0.6.3.x.x	(02024EA4 -> F0224EA4) While ZZZZZZZZ => Byte at XXXXXXXX turn off all codes.
XXXXXXXX ZZZZZZZZ
Type 19 1.6.0.x.x	(02024EA4 -> 32224EA4) If ZZZZZZZZ < Halfword at XXXXXXXX then execute next line.
XXXXXXXX ZZZZZZZZ
Type 39 1.6.1.x.x	(02024EA4 -> 72224EA4) If ZZZZZZZZ < Halfword at XXXXXXXX then execute next 2 lines.
XXXXXXXX ZZZZZZZZ
Type 59 1.6.2.x.x	(02024EA4 -> B2224EA4) If ZZZZZZZZ < Halfword at XXXXXXXX then execute all following codes in the same row (else execute none of the codes below).
XXXXXXXX ZZZZZZZZ
Type 79 1.6.3.x.x	(02024EA4 -> F2224EA4) While ZZZZZZZZ => Halfword at XXXXXXXX turn off all codes.
XXXXXXXX ZZZZZZZZ
Type 1A 2.6.0.x.x	(02024EA4 -> 34224EA4) If ZZZZZZZZ < Halfword at XXXXXXXX then execute next line.
XXXXXXXX ZZZZZZZZ
Type 3A 2.6.1.x.x	(02024EA4 -> 74224EA4) If ZZZZZZZZ < Halfword at XXXXXXXX then execute next 2 lines.
XXXXXXXX ZZZZZZZZ
Type 5A 2.6.2.x.x	(02024EA4 -> B4224EA4) If ZZZZZZZZ < Halfword at XXXXXXXX then execute all following codes in the same row (else execute none of the codes below).
XXXXXXXX ZZZZZZZZ
Type 7A 2.6.3.x.x	(02024EA4 -> F4224EA4) While ZZZZZZZZ => Halfword at XXXXXXXX turn off all codes.
XXXXXXXX ZZZZZZZZ
11) If AND Code
Type 1C 0.7.0.x.x	(02024EA4 -> 38224EA4) If ZZ AND Byte at XXXXXXXX <> 0 (= True) then execute next code.
XXXXXXXX 000000ZZ
Type 3C 0.7.1.x.x	(02024EA4 -> 78224EA4) If ZZ AND Byte at XXXXXXXX <> 0 (= True) then execute next 2 codes.
XXXXXXXX 000000ZZ
Type 5C 0.7.2.x.x	(02024EA4 -> B8224EA4) If ZZ AND Byte at XXXXXXXX <> 0 (= True) then execute all following codes in the same row (else execute none of the codes below).
XXXXXXXX 000000ZZ
Type 7C 0.7.3.x.x	(02024EA4 -> F8224EA4) While ZZ AND Byte at XXXXXXXX = 0 (= False) then turn off all codes.
XXXXXXXX 000000ZZ
Type 1D 1.7.0.x.x	(02024EA4 -> 3A224EA4) If ZZZZ AND Halfword at XXXXXXXX <> 0 (= True) then execute next code.
XXXXXXXX 0000ZZZZ
Type 3D 1.7.1.x.x	(02024EA4 -> 7A224EA4) If ZZZZ AND Halfword at XXXXXXXX <> 0 (= True) then execute next 2 codes.
XXXXXXXX 0000ZZZZ
Type 5D 1.7.2.x.x	(02024EA4 -> BA224EA4) If ZZZZ AND Halfword at XXXXXXXX <> 0 (= True) then execute all following codes in the same row (else execute none of the codes below).
XXXXXXXX 0000ZZZZ
Type 7D 1.7.3.x.x	(02024EA4 -> FA224EA4) While ZZZZ AND Halfword at XXXXXXXX = 0 (= False) then turn off all codes.
XXXXXXXX 0000ZZZZ
Type 1E 2.7.0.x.x	(02024EA4 -> 3C224EA4) If ZZZZZZZZ AND Word at XXXXXXXX <> 0 (= True) then execute next code.
XXXXXXXX ZZZZZZZZ
Type 3E 2.7.1.x.x	(02024EA4 -> 7C224EA4) If ZZZZZZZZ AND Word at XXXXXXXX <> 0 (= True) then execute next 2 codes.
XXXXXXXX ZZZZZZZZ
Type 5E 2.7.2.x.x	(02024EA4 -> BC224EA4) If ZZZZZZZZ AND Word at XXXXXXXX <> 0 (= True) then execute all following codes in the same row (else execute none of the codes below).
XXXXXXXX ZZZZZZZZ
Type 7E 2.7.3.x.x	(02024EA4 -> FC224EA4) While ZZZZZZZZ AND Word at XXXXXXXX = 0 (= False) then turn off all codes.
XXXXXXXX ZZZZZZZZ
12) "Always..." Codes
For the "Always..." codes: -XXXXXXXX can be any authorised address BUT 00000000 (use 02000000 if you don't know what to choose). -ZZZZZZZZ can be anything. -The "y" in the code data must be in the [1-7] range (which means not 0).
Type 07 3.y.0.x.x	(02024EA4 -> 0E224EA4) Always skip next line.
XXXXXXXX ZZZZZZZZ
Type 27 3.y.1.x.x	(02024EA4 -> 4E24EA4) Always skip next 2 lines.
XXXXXXXX ZZZZZZZZ
Type 47 3.y.2.x.x	(02024EA4 -> 8E224EA4) Always Stops executing all the codes below.
XXXXXXXX ZZZZZZZZ
Type 67 3.y.3.x.x	(02024EA4 -> CE224EA4) Always turn off all codes.
XXXXXXXX ZZZZZZZZ
13) 1 Line Special Codes (= starting with "00000000")
Type z00 0.0.0.0.0	End of the code list (even if you put values in the 2nd line).
00000000
Type z04 x.1.0.x.x	AR Slowdown : loops the AR XX times
0800XX00
14) 2 Lines Special Codes (= starting with '00000000' and padded (if needed) with "00000000")
Note: You have to add the 0es manually, after clicking the "create" button.
Type z08 0.2.0.x.x	(02024EA4 -> 10224EA4) Writes Byte ZZ to address XXXXXXXX when AR button is pushed.
XXXXXXXX 000000ZZ
Type z09 1.2.0.x.x	(02024EA4 -> 12224EA4) Writes Halfword ZZZZ to address XXXXXXXX.
XXXXXXXX 0000ZZZZ
Type z0A 2.2.0.x.x	(02024EA4 -> 14224EA4) Writes Word ZZZZZZZZ to address XXXXXXXX.
XXXXXXXX ZZZZZZZZ
Type z0C 0.3.0.x.x	(02024EA4 -> 18224EA4) Patches ROM address (XXXXXXXX << 1) with Halfword ZZZZ.
XXXXXXXX 0000ZZZZ
Type z0D 1.3.0.x.x	(02024EA4 -> 1A224EA4) Patches ROM address (XXXXXXXX << 1) with Halfword ZZZZ. Does not work on V1/2 upgraded to V3. Only for a real V3 Hardware?
XXXXXXXX 0000ZZZZ
Type z0E 2.3.0.x.x	(02024EA4 -> 1C224EA4) Patches ROM address (XXXXXXXX << 1) with Halfword ZZZZ. Does not work on V1/2 upgraded to V3. Only for a real V3 Hardware?
XXXXXXXX 0000ZZZZ
Type z0F 3.3.0.x.x	(02024EA4 -> 1E224EA4) Patches ROM address (XXXXXXXX << 1) with Halfword ZZZZ. Does not work on V1/2 upgraded to V3. Only for a real V3 Hardware?
XXXXXXXX 0000ZZZZ
Type z20 x.0.1.x.x	(00000000 -> 40000000) (SP = 0) (means : stops the "then execute all following codes in the same row" and stops the "else execute none of the codes below)".
00000000 00000000
Type z30 x.4.1.x.x	(00000000 -> 60000000) (If SP <> 2 -> SP = 1) (means : start to execute all codes until end of codes or SP = 0). (bypass the number of codes to executes set by the master code).
00000000 00000000
Type z40 0.0.2.x.x	(02024EA4 -> 80224EA4) Writes Byte YY at address XXXXXXXX. Then makes YY = YY + Z1, XXXXXXXX = XXXXXXXX + Z3Z3, Z2 = Z2 - 1, and repeats until Z2 < 0.
XXXXXXXX 000000YY Z1Z2Z3Z3
Type z41 1.0.2.x.x	(02024EA4 -> 82224EA4) Writes Halfword YYYY at address XXXXXXXX. Then makes YYYY = YYYY + Z1, XXXXXXXX = XXXXXXXX + Z3Z3*2,
XXXXXXXX 0000YYYY Z1Z2Z3Z3
Type z42 2.0.2.x.x	(02024EA4 -> 84224EA4) Writes Word YYYYYYYY at address XXXXXXXX. Then makes YYYYYYYY = YYYYYYYY + Z1, XXXXXXXX = XXXXXXXX + Z3Z3*4, Z2 = Z2 - 1, and repeats until Z2<0.
XXXXXXXX YYYYYYYY Z1Z2Z3Z3
WARNING: There is a BUG on the REAL AR (v2 upgraded to v3, and maybe on real v3) with the 32Bits Increment Slide code. You HAVE to add a code (best choice is 80000000 00000000 : add 0 to value at address 0) right after it, else the AR will erase the 2 last 8 digits lines of the 32 Bits Inc. Slide code when you enter it !!!
15) Special Codes
-Master Code- Type 62 2.0.3.x.x	(address to patch -> address to patch AND $1FFFFFE) Master Code settings.
XXXXXXXX 0000YYYY
-ID Code- Type 62 2.0.3.x.x	word at address 080000AC Must always be 001DC0DE
XXXXXXXX 001DC0DE
-DEADFACE-	Must always be DEADFACE New Encryption seed.
DEADFACE 0000XXXX
Final Notes
SP = 0 : normal (execute n codes before giving back the hand to the game). SP = 1 : execute all codes until SP <>1 (or end of codes). SP = 2 : don't execute anymore codes. Each time the GSA starts to execute codes (= each time "it has the hand"), SP = 0. The 'execute all the codes below this one in the same row' makes SP = 1. The '(else execute none of the codes below)' makes SP = 2. The 'turn off all codes' makes an infinite loop (that can't be broken, unless the condition becomes True).

D) Button Activators What is a Button Activator? Most, if not all systems have the ability to use Button Activators. A Button Activator is a code that will activate another code when you a button on the controller. These codes use the D0/D1 prefix. NOTE: Activators *usually* only activate only the code directly beneath them. There are some special cases though. The digits and such for these codes vary by system... What is a Control Stick Activator? A Control Stick Activator is the same as a Button Activator, but it is unknown at this time if they can be used in the same way on the console itself (only tested on emulator). Based on N64 testing, the reason for this difference is the range of values that the control stick can have (e.g. pushing the stick all the way left on the emulator makes the activator value 82, but odds are it's slightly different on the console). I know at the very least, these will work on the console to activate codes when the stick is moved any direction if you change, for example, an 'Equal To Activator' to a 'Not Equal To Activator' and use 0 for the value. This could be useful for the THQ wrestling games where the only thing the stick does is cause your wrestler to taunt; you could use the control stick to activate the Always Special or Full Spirit code for your player whenever you taunt. I invite whatever hackers we have left here to experiment with these on the console and post their findings on the messageboards. What good are they? Activators are used when you only want to have a certain code active at a certain time, rather than it always being active. Activators on Nintendo 64 Activators on N64 come in a few varieties: 8-Bit and 16-Bit. This is also the only system to see Control Stick Activators thus far.

Button Activator 1 (8-Bit) values:

00 - No Buttons 01 - D-Pad Right 02 - D-Pad Lefft 04 - D-Pad Down 08 - D-Pad Up 10 - Start 20 - Z 40 - B 80 - A You can combine these for multiple buttons. I.E. D-Pad Left and B would be 42.

Button Activator 2 (8-Bit) values:

00 - No Buttons 01 - C-Right 02 - C-Lefft 04 - C-Down 08 - C-Up 10 - R 20 - L You can combine these for multiple buttons. I.E. C-Left and R would be 12.

Dual (16-Bit) Activator values:

Dual Activators are nothing more than the above 2 Activators together. They have 4 digits instead of 2. the first 2 digits use Activator 1 values and the 2nd 2 use Activator 2 values. This allows for more button combos for activating codes without having to use both Activators seperately. I.E. L + R + Z would be 2030.

Control Stick Activator 1 (8-Bit) values (Nemu 64 only):

00 - Nothing/Centered 45 - 55% Right 7E - 100% Right BB - 55% Left 82 - 100% Left

Control Stick Activator 2 (8-Bit) values (Nemu 64 only):

00 - Nothing/Centered 45 - 55% Up 7E - 100% Up BB - 55% Down 82 - 100% Down

Control Stick Activator 1 (8-Bit) values (Project64 only):

00 - Nothing/Centered 7E - 100% Right 81 - 100% Left 50 - 100% Right on Axispad B0 - 100% Left on Axispad

Control Stick Activator 2 (8-Bit) values (Project64 only):

00 - Nothing/Centered 7E - 100% Up 81 - 100% Down 50 - 100% Up on Axispad B0 - 100% Down on Axispad

Dual (16-Bit) Control Stick Activator values:

I would hope you can figure this one out. ;-) (Same as Dual Button Activators) Gameboy Advance Codebreaker Activator Digits: START 0x0008 SELECT 0x0004 A 0x0001 B 0x0002 UP 0x0040 DOWN 0x0080 LEFT 0x0020 RIGHT 0x0010 Left Trigger 0x0200 Right Trigger 0x0100 Playstation Joker Commands Button Activators on Playstation are known as "Joker Commands"; don't ask me why. You'll see Playstation Jokers in four forms (all are 16-Bit). The reason there are 4 forms is that, apparetly, game makers never agreed on a common way to store values when keeping track of what buttons are being pressed. Digits here were provided by GSCCC

Normal Joker Command Digits:

0000 - No Buttons 0001 - L2 Button 0002 - R2 Button 0004 - L1 Button 0008 - R1 Button 0010 - Triangle Button 0020 - Circle Button 0040 - X Button 0080 - Square Button 0100 - Select Button 0800 - Start Button 1000 - Up Direction 2000 - Right Direction 4000 - Down Direction 8000 - Left Direction Multi Buttons - Just combine (add) the values. i.e. Up + R1 would be 1008.

Reverse Joker Command Digits:

0000 - No Buttons 0100 - L2 Button 0200 - R2 Button 0400 - L1 Button 0800 - R1 Button 1000 - Triangle Button 2000 - Circle Button 4000 - X Button 8000 - Square Button 0001 - Select Button 0008 - Start Button 0010 - Up Direction 0020 - Right Direction 0040 - Down Direction 0080 - Left Direction Multi Buttons - Just combine (add) the values. i.e. Up + R1 would be 0810.

Max Normal Joker Command Digits:

FFFF - No Buttons FFFE - L2 Button FFFD - R2 Button FFFB - L1 Button FFF7 - R1 Button FFEF - Triangle Button FFDF - Circle Button FFBF - X Button FF7F - Square Button FEFF - Select Button F7FF - Start Button EFFF - Up Direction DFFF - Right Direction BFFF - Down Direction 7FFF - Left Direction Multi Buttons - Combining these is a little harder. L1 + Select would be FEFB.

Max Reverse Joker Command Digits:

FFFF - No Buttons FEFF - L2 Button FDFF - R2 Button FBFF - L1 Button F7FF - R1 Button EFFF - Triangle Button DFFF - Circle Button BFFF - X Button 7FFF - Square Button FFFE - Select Button FFF7 - Start Button FFEF - Up Direction FFDF - Right Direction FFBF - Down Direction FF7F - Left Direction Multi Buttons - Combining these is a little harder. L1 + Select would be FBFE. Playstayion 2 Joker Command Digits - Courtesy hellion (hellion00.thegfcc.com): 0001 - Select 0002 - L3 0004 - R3 0008 - Start 0010 - Up 0020 - Right 0040 - Down 0080 - Left 0100 - L2 0200 - R2 0400 - L1 0800 - R1 1000 - Triangle 2000 - Circle 4000 - X 8000 - Square Multi Buttons - Add the values. 8200 - Square + R2 Dreamcast: Indices For DC Pad Commands - By UL1 The 'good' thing is: for the DC there are commands available that allow you to activate a code in the game by pressing one or more buttons on your pad. The 'bad' thing is : It isn't as easy as it is for the PSX... The BUTTON COMMAND is easy to use because you just insert the values and that's it. You can combine different buttons - just subtract the given values from FFFF. With the L / R COMMANDS it's a bit difficult... There are two types :

The ANALOG-L/R COMMAND

For the A-L/R COMMAND the values for the buttons differ depending on how strong you push the button(s). So just the value for the default position of the buttons can be given - you can activate the code by saying : Code active if button isn't moved (use '0' instead of the question mark) or Code active if button is moved (use '1' instead of the question mark). Alternatively, if you want to activate the code(s) when pressing button(s) to the max, use FF00 for 'L', 00FF for 'R' or FFFF for both.

The DIGITAL L/R COMMAND

This one is easy to use because you use it the same way as the BUTTON COMMANDS. The ANALOG STICK COMMAND is similar to the A-L/R COMMAND but here you have two different values for the default position of the stick : 0000 or 8080 and there is no value for a max position. XXXXXXXX always represents the code address. Most of times the BUTTON and the L/R COMMAND addresses are placed consecutive in the memory, e.g. : BUTTON COMMAND 01000000 0000FFFB L/R COMMAND 01000002 0000FFFD so you also could use a combination of the two commands. That would read like this : 01000000 FFFDFFFB NOTE : Because SEGA / the developers use almost all buttons for game play it's sometimes difficult to find a combination that doesn't affect other functions in the game. So I suggest to use the second Pad for activating codes in such cases.

BUTTON COMMAND

XXXXXXXX 0000???? A = FFFB B = FFFD X = FBFF Y = FDFF START = FFF7 D-UP = FFEF D-DOWN = FFDF D-LEFT = FFBF D-RIGHT = FF7F

A-L/R COMMAND

XXXXXXXX 000?0000 0 = active when none of the two buttons is pressed 1 = active when one or both buttons are pressed L = FF00 R = 00FF

D-L/R COMMAND

XXXXXXXX 0000???? L = FFFD R = FFFE

A-STICK COMMAND

XXXXXXXX 000?0000 or XXXXXXXX 000?8080 0 = active when A-Stick isn't moved 1 = active when A-Stick is moved E) Patch Codes How do Patch Codes Work? Patch codes are used to make a code string shorter. EG, You have five codes put together to give you "all weapons." Use the patch to shorten it to two codes. This is how it works - 50000A02 0000 + 80844CF0 FF5F EXAMPLE ONLY! NOT A REAL CODE! The first code is the patch, the second is the first code of the expanded STRING(a string is where the offsets will go up only a few digits for each code, EG. 100000, 100002, 100004, etc). The patch does not use an address, yet it is an instruction for the GameShark. The seventh and eighth digit in the patch tells how many numbers the second code will raise to get to the next code in the string. In this case, "2" is used, meaning the next code in the string must be "80844CF2 FF5F." Then the next code would also go up by two. So would the next one, and so on. The fifth and sixth digits of the patch are the digits that tell the GameShark how many codes are in the string. "0A" is used in the example, so ten codes are being used at once with only two codes! Also note, the codes within the string MUST have the same quantity digits!!!! It's possible to have as many as 255 codes used at once using this format. Maybe even more in the future. You can also change the quantity digits in the patch to make the values of each code in the string raise by a certain value. This is what the above code would look like with out a patch - 80844CF0 FF5F 80844CF2 FF5F 80844CF4 FF5F 80844CF6 FF5F 80844CF8 FF5F EXAMPLE ONLY! NOT A REAL CODE! 80844CFA FF5F 80844CFC FF5F 80844CFE FF5F 80844D00 FF5F 80844D02 FF5F Which would you want to use? Okay now to put a new twist on the Patch Codes. I'll use the materia modifier for Final Fantasy 7 as an example. slot 1: 3009CE60 FFxx slot 2: 3009CE64 FFxx There are 200 slots but there are only 90 different types materia so to get them all that's how many codes you'll need. the quantity digits for those range from 00-5A and 5A equals 90 in decimal. The codes go up by 4 so we have: 50005A04 0000 + 3009CE60 FFxx Is that the code to give you all the materia? NO! That code will give you the same materia in 90 different slots. To get all the materia we need to make the XX go up by one with each code. We do that the same way we make the first half of the code. So here it is: 50005A04 0001 + 3009CE60 FF00 We just did the same thing with the last four digits as we did for the rest of the code. So which is better 2 codes or 90? F) Encryption F-1) Playstation 2 Encryption - Courtesy hellion & kpdavatar (hellion00.thegfcc.com) There are 3 types of encryption that the PS2 Gameshark (and AR) V1/V2 use. The encryption type is determined by the (M) Must Be On code for each game. You may have noticed in looking through some codes that some games have a 1 line (M) code and some games have a 2 line. That extra line sets different encryption seeds. After seeing "DEADFACE" on GBA, I would've expected this extra line to have more than just 2 ways of encrypting. I'm guessing we'll see that in the V3 shark if anyone gets around to studying it. The Codebreaker for PS2 only has 1 encryption type that we're aware of. No detailed information about the encryption itself is available at this time, but kpdavatar's encryptor/decryptor supports them.

The "1456E7A5" Encryption Scheme

This was the original encryption method -- your 1 line (M) code. You may have seen codes like "3CA2B610 1456B00C" on some sites. The "1456E7A5" name was derived from the fact that it's commonly used in the values on encrypted codes. 1456E7A5, when used in that part of a code, decrypts to 00000000. The other 2 encryption types are the same wway. Here are the equations that are used for the encryption. The input to the encryption is denoted as a0a1a2a3 d0d1d2d3, and the output is denoted as A0A1A2A3 D0D1D2D3. Each a0, a1, etc is a two digit hex number. In the equations below, the '$' means that the following number is a hexidecimal number. XOR is a binary operation that can be performed on hex numbers using Windows Calculator in Scientific Mode. Note: If you're not into equations, there's an encryptor created by kpdavatar. :) A0 = (a0 XOR $A6) - $6A A1 = (a1 XOR $96) - $FF A2 = (a2 XOR $01) - $7E A3 = (a3 XOR $82) - $5A D0 = (d0 XOR $D9) - $C5 D1 = (d1 XOR $3B) - $E5 D2 = (d2 XOR $1B) - $34 D3 = (d3 XOR $CC) - $27

The "BCA99B83" Encryption Scheme

This encryption is used for games that have certain two-line (M) Must Be On codes. The first line of the (M) code should be "0E3C7DF2 1853E59E". Here are the equations that are used for the encryption. The input to the encryption is denoted as a0a1a2a3 d0d1d2d3, and the output is denoted as A0A1A2A3 D0D1D2D3 . Each a0, a1, etc is a two digit hex number. In the equations below, the '$' means that the following number is a hexidecimal number. XOR is a binary operation that can be performed on hex numbers using Windows Calculator in Scientific Mode. A0 = (a0 - $69) XOR $69 or A0 = (a0 - $E9) XOR $E9 A1 = (a1 - $4F) XOR $4F or A1 = (a1 - $CF) XOR $CF A2 = (a2 - $7B) XOR $7B or A2 = (a2 - $FB) XOR $FB A3 = (a3 - $45) XOR $45 or A3 = (a3 - $C5) XOR $C5 D0 = d0 + $BC or D0 = d0 - $43 D1 = d1 + $A9 or D1 = d1 - $56 D2 = d2 + $9B or D2 = d2 - $64 D3 = d3 + $83 or D3 = d3 - $7C

The "F8FCFEFE" Encryption Scheme

This encryption is used for games that hav