hide results

    Password Format Guide by jdratlif

    Version: 1.0 | Updated: 09/30/05 | Printable Version | Search This Guide

    -------------------------------------------------------------------------------
    | Metroid Password Format Guide
    | by John David Ratliff
    |
    | The most recent version of this guide can always be found at
    | http://games.technoplaza.net/mpg/password.txt
    |
    | Copyright (C) 2005 emuWorks (http://games.technoplaza.net/)
    |   Permission is granted to copy, distribute and/or modify this document
    |   under the terms of the GNU Free Documentation License, Version 1.2
    |   or any later version published by the Free Software Foundation;
    |   with no Invariant Sections, no Front-Cover Texts, and no Back-Cover
    |   Texts.  A copy of the license can be found at
    |   http://www.gnu.org/licenses/fdl.html
    -------------------------------------------------------------------------------
    
    -------------------------------------------------------------------------------
    | Table of Contents
    -------------------------------------------------------------------------------
    
      1.0 Introduction
      2.0 Copyright Notice
      3.0 Revision History
      4.0 Password Data
        4.1 Basics
        4.2 The Metroid Alphabet
        4.3 The Checksum
        4.4 The Shift Byte
        4.5 Known Password Bits
        4.6 Encoding
        4.7 Decoding
        4.8 The Debug Password
      5.0 mpg - The Metroid Password Generator
      6.0 Credits & Acknowledgments
      7.0 Contact Information
      
    -------------------------------------------------------------------------------
    | 1.0 Introduction
    -------------------------------------------------------------------------------
    
      This document is a guide to the password system used by Metroid for the NES.
      It applies to the original Metroid 1 released in the US and Europe. I believe
      the information is also accurate for the hidden Metroid 1 game that can be
      unlocked in Metroid Prime, and for Metroid Zero Mission for Game Boy
      Advance. I have only tested the information with the original Metroid for
      the US version of Metroid. Please contact me if you find anything to be
      inaccurate, either as it applies to the Metroid 1 for the NES or any of the
      others mentioned.
      
      This guide is not a walkthrough for Metroid, and will probably not really
      help you create passwords. This guide is a document describing the password
      format for anyone who may be interested in it. I'm writing it because there
      doesn't seem to be any document to describe the password format in and of
      itself. The only thing close is the documentation contained with SnoBro's
      metroid password generator (MetCode) and its source code.
      
      If you just want to create passwords, I suggest using a password generator.
      There are several choices, but because I have written one, it's the one I'm
      going to recommend. You can find my program, mpg (Metroid Password
      Generator), on emuWorks at http://games.technoplaza.net/mpg/. I wrote the
      program to help me learn about the password format so that I could write this
      document.
    
    -------------------------------------------------------------------------------
    | 2.0 Copyright Notice
    -------------------------------------------------------------------------------
    
      This document is Copyright (C) 2005 emuWorks (http://games.technoplaza.net/) 
        Permission is granted to copy, distribute and/or modify this document
        under the terms of the GNU Free Documentation License, Version 1.2
        or any later version published by the Free Software Foundation;
        with no Invariant Sections, no Front-Cover Texts, and no Back-Cover
        Texts.  A copy of the license can be found at
        http://www.gnu.org/licenses/fdl.html
       
      Basically, it is free documentation in much the same way software under the
      GNU General Public License is free software. You can modify it, redistribute
      it, sell it, publish it, etc.
    
    -------------------------------------------------------------------------------
    | 3.0 Revision History
    -------------------------------------------------------------------------------
    
      Version 1.0 - Friday, September 30, 2005
        - First Public Release
    
    -------------------------------------------------------------------------------
    | 4.0 Password Data
    -------------------------------------------------------------------------------
    
      This is the important section. It covers the details of the Metroid password
      format.
      
    -------------------------------------------------------------------------------
    | 4.1 Basics
    -------------------------------------------------------------------------------
    
      The Metroid Password is a string of 24 characters in the Metroid Alphabet.
      The password string is an encoded 144-bit data field, with 128 bits reserved
      for game data, 8 bits for the checksum, and 8 bits for the shift byte.
      
      Each character in the password represents 6 bits of the password (24 * 6 bits
      = 144 bits). To obtain the contiguous 144-bits, you will need to string the
      character bits together. After this has been done, you can perform operations
      on the comprising 18 individual bytes.
      
      There are 12 bits of the password data whose function is currently unknown.
      It is probable that some of the bits are unused. I have seen one in use, but
      have yet to discover it's function. If you learn the function of any of the
      bits marked Unknown in the document, I would very much appreciate an email.
      
      The remaining 116 bits are used to store data about the game. This data
      includes how many missiles Samus is carrying, what equipment Samus has in her 
      inventory (Long Beam, Maru Mari, etc), which missile containers Samus has
      picked up, which energy tanks Samus has collected, how long the game has been
      played, which red and yellow doors have been opened, Samus' starting
      location, which statues have been raised, if Samus is wearing her space suit  
      or her swimsuit, which zebetites have been destroyed, and finally which
      bosses have been killed.
      
      The password can be encrypted using a shift value, which is not part of the
      128-bit password data. It comprises the 8-bits just following the password
      data. More about the shift byte will be said in 4.4 The Shift Byte.
      
      The final 8 bits are the checksum, which is the first 136-bits added
      together. This provides Metroid a way to ensure that a valid password is
      being entered.
      
      Because the checksum is the same for every unique combination of the first
      136 bits, there are 2^136 valid Metroid passwords, which is approximately
      8.7112285931760246646623899502533e+40 passwords. Many of them are
      functionally equivalent.
      
    -------------------------------------------------------------------------------
    | 4.2 The Metroid Alphabet
    -------------------------------------------------------------------------------
    
      Passwords, as well as all text in the game are comprised from an alphabet
      of 65 characters, which include the entire alphabet A-Z (both upper and lower
      case), the numbers 0-9, and the characters dash (-), question mark (?), and
      space ( ).
      
      Each character has a distinct value in a Metroid password, and they are
      ordered as follows:
      0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz?- 
      
      The space character, which is at the end carries a special value of 255. The
      remaining characters are all numbered from 0-63. In other words, the Metroid
      character 'C' has a value of 13.
      
      These values are used to decode the password into raw bit values. Because
      (with the exception of space), they can all be expressed in 6-bits. You may
      think that this means a space has the same value as the dash, but this is not
      entirely true. Because of the way the data is converted from 6-bit values to
      8-bit values (it is not simply strung together), the space can introduce it's
      high 2 bits over the lower order bits of the character which preceeded it.
      This means the space has the potential to alter the character which came
      before it. This will be discussed more in 4.7 Decoding.
      
    -------------------------------------------------------------------------------
    | 4.3 The Checksum
    -------------------------------------------------------------------------------
    
      Metroid passwords use a simple checksum to confirm their authenticity as a
      valid Metroid password. The last 8-bits (1 byte) comprises the checksum.
      
      To calculate the checksum for a password, add the first 136 bits (17 bytes)
      together. Take the result bit-wise ANDed with 255 and you have your checksum.
      
      The checksum is not a perfect means of validation. It can only do a glib
      test stating that the data is likely to be what you meant to enter.
      
    -------------------------------------------------------------------------------
    | 4.4 The Shift Byte
    -------------------------------------------------------------------------------
    
      The 17th byte (bits 128-135) comprise the shift byte. It is used to encrypt
      the password.
      
      Basically, when the password is encoded, bits are rotated from one byte to
      the next and the bit rotated off the last byte goes onto the first byte.
      
      The shift byte determines how many times this bit rotation occurs. So, a
      value of 0 means the password is not encrypted at all.
      
      The method for bit rotation will be covered in 4.6 Encoding and 4.7 Decoding.
      
    -------------------------------------------------------------------------------
    | 4.5 Known Password Bits
    -------------------------------------------------------------------------------
    
      This section lists all the bits in the 128-bit password data that are known.
      I with I could be more specific about the locations of missile containers,
      energy tanks, and certain red doors, but without a good point of refernece
      (like a public map), this is difficult to do.
      
      There is another password generator written in Flash that contains a map and
      does a great job of telling you exactly where things are and which bit
      corresponds with what item. It is available at
      http://www.geocities.com/passgens/pages/metroid/metflash.htm. If you have
      Flash, and want to know specifics, I suggest you check it out.
      
      I'm going to list them in the order they exist in the password.
      
      Bit 0: Maru Mari Taken
      Bit 1: Missile Container (Brinstar)
      Bit 2: Red Door (Long Beam)
      Bit 3: Red Door (Tourian Bridge)
      Bit 4: Energy Tank (Brinstar)
      Bit 5: Red Door (Bombs)
      Bit 6: Bombs Taken
      Bit 7: Red Door (Ice Beam Brinstar)
      
      Bit 8: Missile Container (Brinstar)
      Bit 9: Energy Tank (Brinstar)
      Bit 10: Red Door (Varia)
      Bit 11: Varia Taken
      Bit 12: Energy Tank (Brinstar)
      Bit 13: Missile Container (Norfair)
      Bit 14: Missile Container (Norfair)
      Bit 15: Red Door (Ice Beam Norfair)
      
      Bit 16: Missile Container (Norfair)
      Bit 17: Missile Container (Norfair)
      Bit 18: Missile Container (Norfair)
      Bit 19: Missile Container (Norfair)
      Bit 20: Missile Container (Norfair)
      Bit 21: Missile Container (Norfair)
      Bit 22: Missile Container (Norfair)
      Bit 23: Red Door (High Jump Boots)
      
      Bit 24: High Jump Boots Taken
      Bit 25: Red Door (Screw Attack)
      Bit 26: Screw Attack Taken
      Bit 27: Missile Container (Norfair)
      Bit 28: Missile Container (Norfair)
      Bit 29: Red Door (Wave Beam)
      Bit 30: Energy Tank (Norfair)
      Bit 31: Missile Container (Norfair)
      
      Bit 32: Red Door (Kraid's Lair)
      Bit 33: Missile Container (Kraid's Lair)
      Bit 34: Missile Container (Kraid's Lair)
      Bit 35: Red Door (Kraid's Lair)
      Bit 36: Energy Tank (Kraid's Lair)
      Bit 37: Red Door (Kraid's Lair)
      Bit 38: Red Door (Kraid's Lair)
      Bit 39: Missile Container (Kraid's Lair)
      
      Bit 40: Missile Container (Kraid's Lair)
      Bit 41: Red Door (Kraid's Room)
      Bit 42: Energy Tank (Kraid's Room)
      Bit 43: Missile Container (Ridley's Lair)
      Bit 44: Red Door (Ridley's Lair)
      Bit 45: Energy Tank (Ridley's Lair)
      Bit 46: Missile Container (Ridley's Lair)
      Bit 47: Yellow Door (in Ridley's Room)
      
      Bit 48: Energy Tank (Room Behind Ridley)
      Bit 49: Missile Container (Ridley's Lair)
      Bit 50: Yellow Door (Tourian)
      Bit 51: Red Door (Tourian)
      Bit 52: Red Door (Tourian)
      Bit 53: Zebetite 1 Killed
      Bit 54: Zebetite 2 Killed
      Bit 55: Zebetite 3 Killed
      
      Bit 56: Zebetite 4 Killed
      Bit 57: Zebetite 5 Killed
      Bit 58: Mother Brain Killed
      Bit 59: Unknown
      Bit 60: Unknown
      Bit 61: Unknown
      Bit 62: Unknown
      Bit 63: Unknown
      
      Bit 64: Start in Norfair
      Bit 65: Start in Kraid's Lair
      Bit 66: Start in Ridley's Lair
      Bit 67: Reset
      Bit 68: Unknown
      Bit 69: Unknown
      Bit 70: Unknown
      Bit 71: Samus in Swimsuit
      
      Bit 72: Samus Has Bombs
      Bit 73: Samus Has High Jump Boots
      Bit 74: Samus Has Long Beam
      Bit 75: Samus Has Screw Attack
      Bit 76: Samus Has Maru Mari
      Bit 77: Samus Has Varia
      Bit 78: Samus Has Wave Beam
      Bit 79: Samus Has Ice Beam
      
      Bit 80: Missile Count (+1 Missile)
      Bit 81: Missile Count (+2 Missiles)
      Bit 82: Missile Count (+4 Missiles)
      Bit 83: Missile Count (+8 Missiles)
      Bit 84: Missile Count (+16 Missiles)
      Bit 85: Missile Count (+32 Missiles)
      Bit 86: Missile Count (+64 Missiles)
      Bit 87: Missile Count (+128 Missiles)
      
      Bit 88: Game Age (32-bit Value -- Low Bit)
      Bit 89: ...
      Bit 90: ...
      Bit 91: ...
      Bit 92: ...
      Bit 93: ...
      Bit 94: ...
      Bit 95: ...
      
      Bit 96: ...
      Bit 97: ...
      Bit 98: ...
      Bit 99: ...
      Bit 100: ...
      Bit 101: ...
      Bit 102: ...
      Bit 103: ...
      
      Bit 104: ...
      Bit 105: ...
      Bit 106: ...
      Bit 107: ...
      Bit 108: ...
      Bit 109: ...
      Bit 110: ...
      Bit 111: ...
      
      Bit 112: ...
      Bit 113: ...
      Bit 114: ...
      Bit 115: ...
      Bit 116: ...
      Bit 117: ...
      Bit 118: ...
      Bit 119: Game Age (32-bit Value -- High Bit)
      
      Bit 120: Unknown
      Bit 121: Unknown
      Bit 122: Unknown
      Bit 123: Unknown
      Bit 124: Ridley Killed
      Bit 125: Ridley Statue Raised
      Bit 126: Kraid Killed
      Bit 127: Kraid Statue Raised
      
      Most of these are obvious, but some require some additional explanation.
      
      The bits that say "XXX Taken", such as Maru Mari Taken, are used to determine
      whether the item will appear in the place it is supposed to be. If Samus
      doesn't have the Maru Mari (Bit 76), but Maru Mari is Taken (Bit 0), then
      Samus can never get the Maru Mari. All the beams (Long, Ice, and Wave) are
      always there.
      
      The game will not let you pick up the Ice Beam and Wave Beam simultaneously.
      If you pick up one, the other will deactivate. If you activate both bits
      yourself, you get a weird cross between the two beams. It doesn't seem to
      hurt the game.
      
      There are five valid start locations. They are specified using bits 64-66.
      To start in Brinstar, all the bits should be off. Norfair, Kraid's Lair, and
      Ridley's Lair can be specified by turning their bit on and leaving the others
      off. Tourian is specified by turning on Norfair and Kraid's Lair
      simultaneously. Any other combination of these three bits is invalid and will
      cause Metroid to reset.
      
      The reset bit is part of the start location. There are 16 possible values,
      but only 5 valid ones. Turning on the reset bit will produce and invalid
      start location and cause Metroid to reset. This is why it is called it is
      called the reset bit, because it guarantees an invalid password.
      
      If Mother Brain is dead, the door will already be there when you get to the
      end of Tourian. The bomb timer will not activate, and you will be able to
      spend as much time as you like escaping Tourian.
      
      The missile count is an 8-bit (1 byte) value ranging from 0-255. Just convert
      the number you want to binary and turn on the appropriate bits.
      
      The game age is a complicated number. It is a 32-bit value, though in
      reality, it only has a range of 2^24 * 208 because the least significant byte
      overflows at 208. This means there are 3,489,661,135 distinct values in the
      range 0 - 4,294,967,295.
      
      The game age is in what I will call 'game ticks'. The exact value of a tick
      depends upon whether you have an NTSC NES (the US Nintendo) or a PAL NES
      (the European Nintendo). If you have an NTSC NES, then 1 game tick = (256 /
      60) seconds or approximately 4.2666666666666666666666666666667 seconds. For a
      PAL NES, 1 game tick = (256 / 50) seconds or 5.12 seconds. Where did these
      values come from? 1 game tick is actually the amount of time it takes to
      draw 256 frames. Because the NTSC NES draws 60 frames per second, you get
      (256 / 60). The PAL NES draws 50 frames per second, so you get (256 / 50).
      The difference is related to television signal differences between North
      American (NTSC) and Europe (PAL).
      
    -------------------------------------------------------------------------------
    | 4.6 Encoding
    -------------------------------------------------------------------------------
    
      Here comes the good part; taking the password data from its raw format and
      creating a Metroid password from it.
      
      The encode is a fairly simple process, although it involves a lot of tedious
      math. If you actually want to encode raw data, I highly recommend using a
      password generator, such as mpg (http://games.technoplaza.net/mpg/).
      
      The encoding process involves four steps.
        1. Calculate the checksum
        2. Encode the password data using the shift byte
        3. Convert the 18 8-bit blocks to 24 6-bit blocks
        4. Translate the 6-bit blocks into a readable password
        
      Step 1 - Calculate the Checksum
      
        Calculating the checksum is a fairly simple process. Take the first 136
        bits and add them together. Take the result and bit-wise and it with 255.
        The result if the checksum.
        
        The checksum should be stored in the last byte (bits 136-143).
        
      Step 2 - Encode the Password Data Using the Shift Byte
      
        This is the part where the password gets encrypted using bit rotation. Here
        is how it works.
        
        You need two variables, which I will call carry (1 bit) and copy (8 bits).
        
        As many times as the shift byte indicates, do the following
          Save the first byte of the password data in copy.
          
          For each byte of the password data (0-15 starting at 0) do the following
            Rotate the password byte right one bit.
              The least significant bit of the password byte should become the new
                carry value.
              The most significant bit of the password byte should be the old carry
                value.
              
          Rotate the copy byte right one bit.
            The least significant bit of copy should become the new carry value.
            The most significant bit of copy should be the old carry value.
          Overwrite the first byte of the password data with the copy byte.
          
        Very simply, we are rotating bits down the password data from byte to byte.
        The copy is needed because the last byte's rotated bit has to become the
        high bit of the first byte. I use the name carry because there is an
        instruction in x86 assembly which can perform this task using the carry
        flag internally. If you take a look at SnoBro's password generator MetCode,
        his x86 assembly source is much more compact than my C++ source for mpg.
        
      Step 3 - Convert the 18 8-bit Blocks to 24 6-bit Blocks
      
        Now that we have our password encoded using the shift byte, we can
        translate to the Metroid alphabet.
        
        Because each letter of the Metroid alphabet can be represented in 6-bits,
        the encoding process will never produce a password with spaces. You can
        read more about spaces in 4.7 Decoding.
        
        To convert from 8-bit blocks to 6-bit blocks, all we need to do is take
        every 6 bits in order. So just take your 144-bit string and separate it
        into 24 6-bit segments.
        
      Step 4 - Translate the 6-bit Blocks into a Readable Password
      
        Since each letter can be represented in 6-bits, converting between the
        6-bit blocks and the western alphabet is trivial. Convert each 6-bit
        value to a decimal number, and take that as the offset from 0 in the
        Metroid alphabet.
        
        In other words, 000000 binary = 0 decimal = '0'
                        111111 binary = 63 decimal = '-'
                        
        You can fill in the rest from 4.2 The Metroid Alphabet.
        
      That's all there is to it. The math is rote, but hard to do by hand. I highly
      recommend using a password generator if you want to actually encode Metroid
      passwords.
      
    -------------------------------------------------------------------------------
    | 4.7 Decoding
    -------------------------------------------------------------------------------
    
      Decoding is nearly a mirror image of encoding, but there are a couple of
      minor differences that are important to note.
      
      Decoding, like encoding, is a four step process. Just like encoding, I
      recommend using a password generator if you really want to decode Metroid
      passwords.
      
        1. Convert the password to the Metroid alphabet
        2. Convert the 24 characters to 18 8-bit blocks
        3. Decode the password data using the shift byte
        4. Verify the checksum
        
      Step 1 - Convert the Password to the Metroid Alphabet
      
        This is basically the same as step 4 in the original, but we have to be
        careful, because we are not dealing with 6-bit blocks here. Although 64 of
        the 65 characters in the Metroid alphabet can be represented in 6-bits,
        the final character (space) cannot. Therefore, we must use 24 8-bit blocks,
        rather than 6-bit blocks.
        
        All the characters use their same values except for space which uses 255.
        In a minute, we will see how this causes spaces in passwords to sometimes
        affect the character that came before it.
        
      Step 2 - Convert the 24 characters to 18 8-bit blocks.
      
        Although we have 8-bit blocks now, we need to have 18 contiguous 8-bit
        blocks, and since most of the characters (if any) won't be spaces, we will
        have the upper two bits of every character off.
        
        If you have no spaces in the password, then you can just remove the leading
        two bits from each character and create a 144-bit string.
        
        If you have spaces, it gets more complicated. The character that preceeds
        the space must be altered to have its lowest two bits turned on. After
        that, you can treat the space like a dash.
        
        If you take a look at the source code for mpg, you can glean a more
        mathematical reason for why you have to do this with spaces, but for this
        document, I'm just doing to tell you that it has to be done.
        
      Step 3 - Decode the Password Data Using the Shift Byte
      
        This is the same process we did for encoding, but in reverse. Instead of
        rotating right, we rotate left, and we swap least significant bit and
        most significant bit. Here is the whole process.
        
        As many times as the shift byte indicates, do the following
          Save the last byte of the password data (byte 15) in copy.
          
          For each byte of the password data (15-0 starting at 15) do the following
            Rotate the password byte left one bit.
              The most significant bit of the password byte should become the new
                carry value.
              The least significant bit of the password byte should be the old
                carry value.
              
          Rotate the copy byte left one bit.
            The most significant bit of copy should become the new carry value.
            The least significant bit of copy should be the old carry value.
          Overwrite the last byte of the password data with the copy byte.
          
      Step 4 - Verify the Checksum
      
        Finally, we have our password data. Now we need to verify the checksum.
        
        All we have to do is calculate the checksum on the data we have, and make
        sure it's equal to byte 18 (bits 137-144). If not, then the password is
        not valid and will be rejected by Metroid.
        
      That's all there is to decoding.
      
    -------------------------------------------------------------------------------
    | 4.8 The Debug Password
    -------------------------------------------------------------------------------
    
      One password, which I will call the debug password, and is also known as the
      NAR PASSWORD, is a special password which does not use the shift byte or the
      checksum. This is because it is hard coded into Metroid and the password data
      has no meaning. It simply triggers a debugging mode in Metroid that was used
      to help test the US version of the game.
      
      The NAR PASSWORD, which if written completely is
      
      NARPAS SWORD0
      0000
      
      The last 8 characters can be anything and are not checked at all. This is
      because 16 * 6 = 96 bits = 12 bytes = 3 quads. I don't know if this is
      specifically why you need the last 5 zeros, but it is my theory.
      
      Why 3 quads? I don't know, but it's a nice number from a computer science
      point of view. If not 3 quads, then 12 characters which would be 12 * 6 =
      72 bits = 9 bytes would have been pretty easy to check in 6502 assembly.
      
      It is also possible they simply wanted to restrict the number of passwords
      that would trigger debug mode, and requiring 5 zeros at the end is one way it
      could have been done. However, if that is the reason, why not require they
      all be zeros? Why have any wildcard characters at all?
      
      Blanks are interpreted as 0's in the Metroid password screen, so you never
      need to enter more than NARPAS SWORD anyways. (That's blank, meaning no
      character present, not space, which looks identical to, but is interpreted
      very differently from a blank).
      
      What does NAR mean? There are a few theories, but no one knows for sure. The
      three most popular are as follows:
      
        1. NAR = North American Release
           The Japanese version did not have passwords and used the FDS (Famicom
           Disk System) to store Metroid save games.
           
        2. NAR = Not a Real (as in Not a Real Password)
           
        3. NAR = Tohru Narihito
           Tohru Narihito designed and implemented the password system in Metroid.
           Maybe he named the debug password after himself.
           
    -------------------------------------------------------------------------------
    | 5.0 mpg - The Metroid Password Generator
    -------------------------------------------------------------------------------
    
      As I have mentioned many times, it is inconvenient to use the methods
      described here by hand. This document wasn't written so people would try to
      do this by hand. Rather it was written to further the understanding of the
      Metroid password format.
      
      I wrote a program called mpg (The Metroid Password Generator) as a
      replacement for a program I had seen called MetCode (the first Metroid
      password creation tool written by SnoBro). SnoBro only updated it within
      his MetEdit (Metroid Editor) program, and the program itself leaves quite a
      lot to be desired. SnoBro did not have complete information on the password
      format, so many bits in the password that I learned about were blank in his
      program. It was also Windows only and has what I consider to be a less than
      optimal interface.
      
      mpg is a replacement for SnoBro's MetCode. It takes the basic idea and turns
      it into a nicer program. It runs on Windows, Linux, and Mac OS X for sure,
      but should also run on any unix supporting the GTK+ toolkit.
      
      mpg also takes inspiration from a program called metpass by tapper, which was
      written to aid in the creation of Metroid passwords as strings of words. If
      you want to spell words in Metroid Passwords, you could use metpass to fix
      the checksum so the password would work in Metroid. I thought the two ideas
      should be combined, so I added the features of metpass into mpg.
      
      I have spent a lot of time refining the interface, and although there are at
      least 5 other programs that create metroid passwords, I truly feel that mine
      is better than all of them. The one thing that it doesn't have that one of
      the others does is a reference map for where each item, red door, energy
      tank, and missile container is. It is written in Flash and will run in a
      web browser if you have the Flash plugin. You can find it at
      http://www.geocities.com/passgens/pages/metroid/metflash.htm. Despite his
      nice map, I still feel I have a better overall program.
      
      If you would like to use mpg, it is available for download at
      http://games.technoplaza.net/mpg/. It is free software under the GNU General
      Public License, comes with full source, and runs on nearly every platform.
    
    -------------------------------------------------------------------------------
    | 6.0 Credits & Acknowledgments
    -------------------------------------------------------------------------------
    
      While I have learned a great deal on my own about the password format used in
      Metroid, much of my information comes originally from others. I will try to
      acknowledge everyone who has lead to the creation of this document here.
      
      SnoBro (aka Kent Hansen)
        Creator of SnoBro's Metroid Password Generator (MetCode) and MetEdit, an
        editor for Metroid ROMs. He did the original work on Metroid and learned
        the checksum and shift byte meanings, along with decoding the Metroid
        alphabet. I'm 99% positive that every Metroid password generator owes its
        existence to SnoBro and the original data he shared in his readme and
        source code. This include mpg. Thanks SnoBro!
        
      tapper (aka Sebastian Pettersson)
        Creator of metpass, a checksum generation utility that helps turn strings
        of words into valid Metroid passwords. His program inspired me to improve
        mpg beyond what I had originally envisioned and his readme contained
        information that helped me learn more about the password format.
        
      Xodnizel
        Creator of FCEU, an NES emulator with a debugger. I was able to confirm
        many of my theories about the password data using the debugger in FCEU.
    
    -------------------------------------------------------------------------------
    | 7.0 Contact Information
    -------------------------------------------------------------------------------
    
      The author (John Ratliff) can be contacted at
      webmaster [AT] technoplaza [DOT] net. Replace as necessary.
      
      I can also be reached via an online feedback form at
      http://www.technoplaza.net/feedback.php