/**********************************************************
 * mame2003-plus control description data stuctures
 *
 * Originally dervied from
 * controls.dat Version=0.141.1, Time=2011-01-05 18:17:26, Generated by=SirPoonga
 *********************************************************/

 /* By default we assume that multiplayer games use the same button names for the different
  * players, although there are exceptions. The approach is to use case statements with the
  * highest player numbers first so that the Player 1 labels can serve as default.
  */

#include "controls.h"
#include "inptport.h"

/***********************************************************
  PRIVATE HELPER FUNCTIONS
 ***********************************************************/

static const char *joy2way_labels(int type);
static const char *joy4way_labels(int type);

static const char *joy2way_labels(int type)
{
  switch(type)
  {
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */ 
  
  return "";  
}

static const char *joy4way_labels(int type)
{
  switch(type)
  {
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */ 
  
  return "";  
}

/***********************************************************
  CONTROLS METADATA
 ***********************************************************/
 
const struct ControlInfo generic_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "",    /* control_details */
  &generic_ctrl_label /* button labeler function */ 
};
 
const struct ControlInfo a88games_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This is a 4 player team type game where 2 players compete each time.", /* control_details */
  &a88games_get_ctrl_name
};

const char *a88games_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Run";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "Run";
  } /* end of switch */

  return "";
}

const struct ControlInfo a005_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &a005_get_ctrl_name
};

const char *a005_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo a10yardj_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &a10yardj_get_ctrl_name
};

const char *a10yardj_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Pass / Hike";
    case IPT_BUTTON2: return BTN2 "Lateral";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo gtmr_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This game has several options regarding the control type. It has an optional brake pedal/button as well as the option to play the game with either a 270 wheel or an 8way joystick. The controls shown here are the ones used on the dedicated model. Notice the lack of the brake pedal. It seems that the brake pedal was used in conversion kits as the dedicated cabinet didn't have one.", /* control_details */
  &gtmr_get_ctrl_name
};

const char *gtmr_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Accelerate";
    case IPT_PADDLE: return "Left";
    case (IPT_PADDLE + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo a1941_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &a1941_get_ctrl_name
};

const char *a1941_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Loop";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo a1942_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &a1942_get_ctrl_name
};

const char *a1942_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Loop";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo a1943kai_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "A - Fire, B - Bomb Pressing both buttons will allow the plane to loop", /* control_details */
  &a1943kai_get_ctrl_name
};

const char *a1943kai_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "A";
    case IPT_BUTTON2: return BTN2 "B";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo a1943_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Press both buttons together to cause the plane to loop.", /* control_details */
  &a1943_get_ctrl_name
};

const char *a1943_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Special";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo a1944_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &a1944_get_ctrl_name
};

const char *a1944_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo a19xx_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "If you hold down the shoot button, your weapon powers up and gives you a homing missle in addition to you normal weapon.", /* control_details */
  &a19xx_get_ctrl_name
};

const char *a19xx_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo openice_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &openice_get_ctrl_name
};

const char *openice_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Turbo";
    case IPT_BUTTON2: return BTN2 "Shoot / Block";
    case IPT_BUTTON3: return BTN3 "Pass / Steal";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo a39in1_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This is a bootleg pcb that contains many classic vertical arcade games. Because of this the 'alternating play' flag is invalid and will vary from game to game. The game kit is a pcb only and thus lacks any official labels. The manual for this version lists the buttons as 1P-S1 thru 2P-S3. However, these are simply the jamma pinouts. Every control panel overlay manufacturer that has since released a overlay for this unit has either left the labels blank or labeled them A, B and C respectively.", /* control_details */
  &a39in1_get_ctrl_name
};

const char *a39in1_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "A";
    case IPT_BUTTON2: return BTN2 "B";
    case IPT_BUTTON3: return BTN3 "C";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo a4enraya_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &a4enraya_get_ctrl_name
};

const char *a4enraya_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Down";
    case IPT_BUTTON2: return BTN2 "Shot";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo a4in1_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &a4in1_get_ctrl_name
};

const char *a4in1_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo a4dwarrio_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &a4dwarrio_get_ctrl_name
};

const char *a4dwarrio_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo a64street_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Pressing both buttons will do a special attack", /* control_details */
  &a64street_get_ctrl_name
};

const char *a64street_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo a720_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "OTHER: The 720 controller is unique. It is an optical sensed spinner with a joystick handle. The controller had two encoder wheels on the same axis /* control_details */ one was like a normal spinner encode wheel with 72 spokes & 72 gaps, the other encoder wheel had only two gaps spaced as far as alternating gaps on the normal encoder wheel (ie: instead of gap, spoke, gap, spoke, gap like on the normal wheel, the middle gap was part of the one fat spoke seperating the two gaps on the ends). The normal encoder wheel turns the character in the game, the other encoder wheel is to help keep the stick calibrated with the screen, on each rotation of the stick. Mame only emulates the normal wheel as a dial type input; the other is ignored. The character in the game can face 16 directions: the 4 cardinal directions, the 4 normal diagonals, and the 8 directions inbetween the cardinals and the diagonals. The Kick button makes the character skate faster (in case that's not clear). Both buttons are mirrored on opposite sides of the 'joystick' spinner, but like most mirror cases, they are wired as a total of only two buttons.", /* control_details */
  &a720_get_ctrl_name
};

const char *a720_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Kick";
    case IPT_BUTTON2: return BTN2 "Jump";
    case (IPT_DIAL + IPT_EXTENSION): return "Rotate Right";
    case IPT_DIAL: return "Rotate Left";
  } /* end of switch */

  return "";
}

const struct ControlInfo a7jigen_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &a7jigen_get_ctrl_name
};

const char *a7jigen_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo ace_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The 2-way horizontal stick is a trigger stick, pushing left rotates the plane anticlockwise, pushing right rotates the plane clockwise", /* control_details */
  &ace_get_ctrl_name
};

const char *ace_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_UP: return "Speed Up";
    case IPT_JOYSTICK_DOWN: return "Slow Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo acrobatm_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Hold down Fire button to increase power", /* control_details */
  &acrobatm_get_ctrl_name
};

const char *acrobatm_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo actfancr_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &actfancr_get_ctrl_name
};

const char *actfancr_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo hatena_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &hatena_get_ctrl_name
};

const char *hatena_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "1";
    case IPT_BUTTON2: return BTN2 "2";
    case IPT_BUTTON3: return BTN3 "3";
    case IPT_BUTTON4: return BTN4 "4";
  } /* end of switch */

  return "";
}

const struct ControlInfo aerofgt_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Pressing bomb button drops bomb and plane also loops. There are no labels on the CP.", /* control_details */
  &aerofgt_get_ctrl_name
};

const char *aerofgt_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo aburner2_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The 'unknown' button is emulated in MAME but has no real purpose. As far as I can tell from the drivers, it was used for some sort of feedback in the simulation cockpits.", /* control_details */
  &aburner2_get_ctrl_name
};

const char *aburner2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Vulcan";
    case IPT_BUTTON3: return BTN3 "Unknown";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "Down";
    case IPT_AD_STICK_Y: return "Up";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "Right";
    case IPT_AD_STICK_X: return "Left";
    case IPT_AD_STICK_Z: return "Slow";
    case (IPT_AD_STICK_Z + IPT_EXTENSION): return "Fast";
  } /* end of switch */

  return "";
}

const struct ControlInfo koshien_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "A - Power-up B - Hit/Throw C - Unknown action during game", /* control_details */
  &koshien_get_ctrl_name
};

const char *koshien_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "A";
    case IPT_BUTTON2: return BTN2 "B";
    case IPT_BUTTON3: return BTN3 "C";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo airbustr_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Only 1 button on the CP but MAME has 2 mapped (both doing the same thing)", /* control_details */
  &airbustr_get_ctrl_name
};

const char *airbustr_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo airduel_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Pinout shows 3 buttons (Fire1, Fire2, Fire3), the flyer shows 2 buttons, Mame has 4 buttons mapped and only 2 seem to work", /* control_details */
  &airduel_get_ctrl_name
};

const char *airduel_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Gun";
    case IPT_BUTTON2: return BTN2 "Guided Bomb";
    case IPT_BUTTON3: return BTN3 "Unknown";
    case IPT_BUTTON4: return BTN4 "Unknown";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo airwolf_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Button 2 acts differently based on the position on the screen. In the lower half of the screen button 2 will shoot diagonally down to the ground. In the top half it will drop a bomb", /* control_details */
  &airwolf_get_ctrl_name
};

const char *airwolf_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo ajax_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &ajax_get_ctrl_name
};

const char *ajax_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Machine Gun";
    case IPT_BUTTON2: return BTN2 "Missle";
    case IPT_BUTTON3: return BTN3 "Super Weapon";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo alexkidd_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "I cold not find what the 3rd button did nor did I immediately notice where it is written in the driver (I think it's one of those generic drivers)", /* control_details */
  &alexkidd_get_ctrl_name
};

const char *alexkidd_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "Unknown";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo alibaba_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Drop is not the button label (couldn't find one). It drops something behind your character which blocks the path of the Captain Thief which allows you to get away", /* control_details */
  &alibaba_get_ctrl_name
};

const char *alibaba_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Drop";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo astorm_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &astorm_get_ctrl_name
};

const char *astorm_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Roll";
    case IPT_BUTTON3: return BTN3 "Special";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo aliensyn_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &aliensyn_get_ctrl_name
};

const char *aliensyn_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo avsp_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The default dipswitch is two player mode /* control_details */ you need to F2 into the game's service mode and change it to three player mode to play with 3 players. Each character has special moves.", /* control_details */
  &avsp_get_ctrl_name
};

const char *avsp_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_BUTTON2: return BTN2 "Attack";
    case IPT_BUTTON3: return BTN3 "Jump (Dash)";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Move Left";
    case IPT_JOYSTICK_RIGHT: return "Move Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo alien3_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "There isn't much info about the 'real' name for the second button on the guns. If you have any info feel free to corect.", /* control_details */
  &alien3_get_ctrl_name
};

const char *alien3_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Secondary Weapon";
    case IPT_LIGHTGUN_X: return "Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Right";
    case IPT_LIGHTGUN_Y: return "Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo aliens_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &aliens_get_ctrl_name
};

const char *aliens_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot 1";
    case IPT_BUTTON2: return BTN2 "Shoot 2";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo aafb_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The joystick controls the player movement while the kicker is for kicking and passing.", /* control_details */
  &aafb_get_ctrl_name
};

const char *aafb_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Action";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_AD_STICK_X: return "Aim Left";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "Aim Right";
    case IPT_AD_STICK_Y: return "Short";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "Long";
  } /* end of switch */

  return "";
}

const struct ControlInfo alleymas_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Probably the oddest bowling game out there, this game uses a football kicker stick to bowl!", /* control_details */
  &alleymas_get_ctrl_name
};

const char *alleymas_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Left";
    case IPT_BUTTON2: return BTN2 "Right";
    case IPT_AD_STICK_X: return "Left";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "Right";
    case IPT_AD_STICK_Y: return "Up";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo alphaho_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &alphaho_get_ctrl_name
};

const char *alphaho_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Accelerate";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo alpinerd_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "This game uses a dedicated platform shaped like a pair of skiis. It basically acts like a giant analog stick. The player navigates via three, lighted, navigational buttons. (Left, Right and Decision)  The Decision button also changes view during gameplay. The 'sweep' and 'edge' descriptions were taken directly from the game's cryptic i/o test menu. Knowing nothing about skiiing, the way the terms 'sweep' and 'edge' were used may be incorrect.", /* control_details */
  &alpinerd_get_ctrl_name
};

const char *alpinerd_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Decision";
    case IPT_BUTTON2: return BTN2 "Left (Select)";
    case IPT_BUTTON3: return BTN3 "Right (Select)";
    case IPT_AD_STICK_X: return "Sweep Left";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "Sweep Right";
    case IPT_AD_STICK_Y: return "Increase Edge ";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "Decrease Edge";
  } /* end of switch */

  return "";
}

const struct ControlInfo alpine_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The cpo depicted a simple arrow pointing up for the button label. Upon research I found that this button makes you go down the hill faster. I modified the caption accordingly to avoid confusion. For left and right, the cpo shows a picture of a skiier going left and right respectively. I added the 'ski' part of the caption to prepare for the upcoming icon support in the viewer. As the game doesn't have a true caption, this shouldn't be any less accurate.", /* control_details */
  &alpine_get_ctrl_name
};

const char *alpine_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Ski Faster";
    case IPT_JOYSTICK_RIGHT: return "Ski Right";
    case IPT_JOYSTICK_LEFT: return "Ski Left";
  } /* end of switch */

  return "";
}

const struct ControlInfo altbeast_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &altbeast_get_ctrl_name
};

const char *altbeast_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Punch";
    case IPT_BUTTON2: return BTN2 "Kick ";
    case IPT_BUTTON3: return BTN3 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo maze_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &maze_get_ctrl_name
};

const char *maze_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo horshoes_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &horshoes_get_ctrl_name
};

const char *horshoes_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Angle";
    case IPT_BUTTON2: return BTN2 "Grip";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo amspdwy_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &amspdwy_get_ctrl_name
};

const char *amspdwy_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Accelerate";
    case IPT_DIAL: return "Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo amerdart_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "To play, aim with the trackball, press the 'lock' button to set the position and then roll to throw.", /* control_details */
  &amerdart_get_ctrl_name
};

const char *amerdart_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Lock";
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo amidar_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &amidar_get_ctrl_name
};

const char *amidar_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo angelkds_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Left joy controls the left kid, right controls the right kid", /* control_details */
  &angelkds_get_ctrl_name
};

const char *angelkds_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICKLEFT_UP: return "Up";
    case IPT_JOYSTICKLEFT_DOWN: return "Down";
    case IPT_JOYSTICKLEFT_LEFT: return "Left";
    case IPT_JOYSTICKLEFT_RIGHT: return "Right";
    case IPT_JOYSTICKRIGHT_UP: return "Up";
    case IPT_JOYSTICKRIGHT_DOWN: return "Down";
    case IPT_JOYSTICKRIGHT_LEFT: return "Left";
    case IPT_JOYSTICKRIGHT_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo anteater_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Not sure if the label is correct but that's what it does. Couldn't find a pic of the panel", /* control_details */
  &anteater_get_ctrl_name
};

const char *anteater_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Tongue Return";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo apb_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "", /* control_details */
  &apb_get_ctrl_name
};

const char *apb_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Siren / Start";
    case IPT_BUTTON2: return BTN2 "Fire";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
    case IPT_DIAL: return "Left";
    case IPT_PEDAL: return "Accelerate";
  } /* end of switch */

  return "";
}

const struct ControlInfo apparel_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &apparel_get_ctrl_name
};

const char *apparel_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo aquajack_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "In mame a dial is also emulated. This dial has no apparent function and isn't used in the game at all. It could be reminants of a hack or something.", /* control_details */
  &aquajack_get_ctrl_name
};

const char *aquajack_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Machine Gun";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "Vulcan";
    case IPT_BUTTON4: return BTN4 "Thrust";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo aquarium_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "You can choose at the start of the game whether you would like to use 1 or 2 buttons Type A - 2 buttons Type B - 1 button No pic available, labelled on what they do", /* control_details */
  &aquarium_get_ctrl_name
};

const char *aquarium_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Rotate Right";
    case IPT_BUTTON2: return BTN2 "Rotate Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo arabian_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &arabian_get_ctrl_name
};

const char *arabian_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Kick";
    case IPT_JOYSTICK_RIGHT: return "Walk";
    case IPT_JOYSTICK_LEFT: return "Walk";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo arbalest_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &arbalest_get_ctrl_name
};

const char *arbalest_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Special";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo arcadecl_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &arcadecl_get_ctrl_name
};

const char *arcadecl_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire / Left Missile";
    case IPT_BUTTON2: return BTN2 "Fire / Center Missile";
    case IPT_BUTTON3: return BTN3 "Fire / Right Missile";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_X: return "Left";
  } /* end of switch */

  return "";
}

const struct ControlInfo archrivl_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The control panel for this game had two pass buttons, but they were merely wired to the same input as only one pass is wired in the schematics. The controls actually used 49-way joysticks for this game, which can be thought of as corse analog sticks.", /* control_details */
  &archrivl_get_ctrl_name
};

const char *archrivl_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot/Jump";
    case IPT_BUTTON2: return BTN2 "Pass/Punch";
    case IPT_AD_STICK_X: return "Left";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "Right";
    case IPT_AD_STICK_Y: return "Up";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo area51_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "As with many of the lightgun games at the time, Area 51 requires you to fire off screen to reload. Mame has hacked this to where you fire at the absolute edge of the screen to reload. This is good for people who don't use lightguns but very bad for those of us who do.", /* control_details */
  &area51_get_ctrl_name
};

const char *area51_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Down";
    case IPT_LIGHTGUN_Y: return "Up";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Right";
    case IPT_LIGHTGUN_X: return "Left";
  } /* end of switch */

  return "";
}

const struct ControlInfo area51mx_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &area51mx_get_ctrl_name
};

const char *area51mx_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Down";
    case IPT_LIGHTGUN_Y: return "Up";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Right";
    case IPT_LIGHTGUN_X: return "Left";
  } /* end of switch */

  return "";
}

const struct ControlInfo a51site4_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Shoot off-screen to reload. Note:  many pc lightguns have a dedicated reload button, which mame supports.", /* control_details */
  &a51site4_get_ctrl_name
};

const char *a51site4_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_LIGHTGUN_X: return "Aim Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Aim Right";
    case IPT_LIGHTGUN_Y: return "Aim Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Aim Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo argus_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Fire button shoots flying objects, the laser hits the ground units", /* control_details */
  &argus_get_ctrl_name
};

const char *argus_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Laser";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo arkarea_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "To change direction hold the direction button down while using the joystick", /* control_details */
  &arkarea_get_ctrl_name
};

const char *arkarea_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Direction";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo arkanoid_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &arkanoid_get_ctrl_name
};

const char *arkanoid_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_DIAL: return "Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo arknoid2_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &arknoid2_get_ctrl_name
};

const char *arknoid2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_DIAL: return "Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo arlingtn_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Sirp Please fix me.... vertical 2 ways have the wrong labels showing up and there isn't a directional 2 way button (vertical), which is what I use.", /* control_details */
  &arlingtn_get_ctrl_name
};

const char *arlingtn_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "WIN";
    case IPT_BUTTON2: return BTN2 "PLACE";
    case IPT_BUTTON3: return BTN3 "SHOW";
    case IPT_BUTTON4: return BTN4 "COLLECT";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo armwrest_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "This Game only uses 3 directions of the 4 way stick. Down is not used.", /* control_details */
  &armwrest_get_ctrl_name
};

const char *armwrest_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Power";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "";
    case IPT_JOYSTICK_UP: return "Pull";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo armedf_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Button 3 is mapped in driver armedf.c but isn't used", /* control_details */
  &armedf_get_ctrl_name
};

const char *armedf_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Special";
    case IPT_BUTTON3: return BTN3 "Unknown";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo armora_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Something of note is this game is pretty much unplayable in Mame without the artwork pack that goes with the rom. Be sure to download it.", /* control_details */
  &armora_get_ctrl_name
};

const char *armora_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Forward";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
  } /* end of switch */

  return "";
}

const struct ControlInfo armorcar_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "I think a bit of how to play info might be necessary. The sawhorse button releases a police barrier to crash cars. The 2nd gear button makes you go faster, but only while it is held.", /* control_details */
  &armorcar_get_ctrl_name
};

const char *armorcar_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Sawhorse";
    case IPT_BUTTON2: return BTN2 "2nd Gear";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo ashura_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &ashura_get_ctrl_name
};

const char *ashura_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo aso_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &aso_get_ctrl_name
};

const char *aso_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Laser";
    case IPT_BUTTON2: return BTN2 "Missile";
    case IPT_BUTTON3: return BTN3 "Power Up";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo assault_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "Mame-wise, this game is really odd. The original game uses dual 4-way trigger sticks. However the author of the mame driver also hacked in an optional 1 stick control scheme so you can play the game with a regular single stick. Unfortunately, this hack interferes with the real inputs so you have to clear one or the other to play properly. It should also be noted that you can not rapid roll with the hack as the game requires you to press both sticks left or right at once to do a roll. Also there is a phantom button defined that is useless. Gameplay Tips:  To rapid roll push both sticks in the same direction. (Left or right only)  To launch a grenade push both sticks to the outside and fire when ready.", /* control_details */
  &assault_get_ctrl_name
};

const char *assault_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICKRIGHT_RIGHT: return "Rapid Roll Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo asterix_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Watch the attract screen to view general and special moves", /* control_details */
  &asterix_get_ctrl_name
};

const char *asterix_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo asteroid_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &asteroid_get_ctrl_name
};

const char *asteroid_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "FIRE";
    case IPT_BUTTON2: return BTN2 "THRUST";
    case IPT_BUTTON3: return BTN3 "HYPER SPACE";
    case IPT_JOYSTICK_LEFT: return "Rotate Left";
    case IPT_JOYSTICK_RIGHT: return "Rotate Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo astdelux_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &astdelux_get_ctrl_name
};

const char *astdelux_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "FIRE";
    case IPT_BUTTON2: return BTN2 "THRUST";
    case IPT_BUTTON3: return BTN3 "SHIELDS";
    case IPT_JOYSTICK_RIGHT: return "ROTATE RIGHT";
    case IPT_JOYSTICK_LEFT: return "ROTATE LEFT";
  } /* end of switch */

  return "";
}

const struct ControlInfo astrob_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Don't think Star Trek when you see the warp button. It activates a 10 second time warp which slows the enemies down. So who ever said that Binx was innovative was about 20 years too late.", /* control_details */
  &astrob_get_ctrl_name
};

const char *astrob_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Warp";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
  } /* end of switch */

  return "";
}

const struct ControlInfo astrof_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &astrof_get_ctrl_name
};

const char *astrof_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Missile";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
  } /* end of switch */

  return "";
}

const struct ControlInfo astinvad_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &astinvad_get_ctrl_name
};

const char *astinvad_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "FIRE";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
  } /* end of switch */

  return "";
}

const struct ControlInfo asuka_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &asuka_get_ctrl_name
};

const char *asuka_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo asylum_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &asylum_get_ctrl_name
};

const char *asylum_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo abaseb_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Action button depends if batting or fielding - selects hit, swings bat, selects pitch, throws etc", /* control_details */
  &abaseb_get_ctrl_name
};

const char *abaseb_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Action";
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo atarifb_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "There are 4 plays (well, four offense, four defense) per player displayed as part of the control panel with an LED for each play and selected with the action button. You cannot play against the computer: this game has to be played with two players. There is a four player version with four trackballs /* control_details */ that version has to be played with 4 players. **Update**  I looked in the mame cpo pack and found a pic to fill in the button label. Rebel, if you need a copy of the cpo pack please contact me, it's very helpful.", /* control_details */
  &atarifb_get_ctrl_name
};

const char *atarifb_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Play Select:  Press to Pass / Kick";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_X: return "Left";
  } /* end of switch */

  return "";
}

const struct ControlInfo ataxx_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &ataxx_get_ctrl_name
};

const char *ataxx_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Select";
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo athena_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &athena_get_ctrl_name
};

const char *athena_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jump";
    case IPT_BUTTON2: return BTN2 "Attack";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo atehate_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &atehate_get_ctrl_name
};

const char *atehate_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "1";
    case IPT_BUTTON2: return BTN2 "2";
    case IPT_BUTTON3: return BTN3 "3";
    case IPT_BUTTON4: return BTN4 "4";
  } /* end of switch */

  return "";
}

const struct ControlInfo atomicp_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "If a falling block has one block flashing you can press the second button and you get four choices. One of these it to get to select what the next shape will be. Mame has this as a 8-way in the system16.c driver but while playing acts like a 4-way", /* control_details */
  &atomicp_get_ctrl_name
};

const char *atomicp_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Rotate";
    case IPT_BUTTON2: return BTN2 "Special";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo robokid_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &robokid_get_ctrl_name
};

const char *robokid_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Weapon Select";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo aurail_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Special sends out remote attack drones", /* control_details */
  &aurail_get_ctrl_name
};

const char *aurail_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Sepcial";
    case IPT_BUTTON3: return BTN3 "Shield";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo av2mj1bb_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &av2mj1bb_get_ctrl_name
};

const char *av2mj1bb_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo av2mj2rg_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &av2mj2rg_get_ctrl_name
};

const char *av2mj2rg_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo avalnche_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &avalnche_get_ctrl_name
};

const char *avalnche_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Serve";
    case IPT_PADDLE: return "Left";
    case (IPT_PADDLE + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo avengers_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Button A - Punch Button B - Kick", /* control_details */
  &avengers_get_ctrl_name
};

const char *avengers_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "A";
    case IPT_BUTTON2: return BTN2 "B";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo avspirit_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Button A - Fire Button B - Jump", /* control_details */
  &avspirit_get_ctrl_name
};

const char *avspirit_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "A";
    case IPT_BUTTON2: return BTN2 "B";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo aztarac_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &aztarac_get_ctrl_name
};

const char *aztarac_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Radar";
    case IPT_AD_STICK_X: return "Left";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "Right";
    case IPT_AD_STICK_Y: return "Up";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "Down";
    case IPT_DIAL: return "Aim Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Aim Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo azurian_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &azurian_get_ctrl_name
};

const char *azurian_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo baddudes_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Holding down attack while standing still will charge up a super punch. Pressing jump and attack at once will do a super kick at the expense of some of your energy.", /* control_details */
  &baddudes_get_ctrl_name
};

const char *baddudes_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo badlands_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &badlands_get_ctrl_name
};

const char *badlands_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Gas";
    case IPT_BUTTON2: return BTN2 "Fire";
    case IPT_DIAL: return "Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bagman_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &bagman_get_ctrl_name
};

const char *bagman_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Action";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bkrtmaq_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This will display in mame as a 4 player even though it is only 2 player.", /* control_details */
  &bkrtmaq_get_ctrl_name
};

const char *bkrtmaq_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "1";
    case IPT_BUTTON2: return BTN2 "2";
    case IPT_BUTTON3: return BTN3 "3";
    case IPT_BUTTON4: return BTN4 "4";
  } /* end of switch */

  return "";
}

const struct ControlInfo bakutotu_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "All buttons do the same thing", /* control_details */
  &bakutotu_get_ctrl_name
};

const char *bakutotu_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Fire";
    case IPT_BUTTON3: return BTN3 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo ballbomb_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &ballbomb_get_ctrl_name
};

const char *ballbomb_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo ballbros_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Mame has 3 buttons mapped but the game only has 1.", /* control_details */
  &ballbros_get_ctrl_name
};

const char *ballbros_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Rotate";
    case IPT_BUTTON2: return BTN2 "Unknown";
    case IPT_BUTTON3: return BTN3 "Unknown";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo baluba_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &baluba_get_ctrl_name
};

const char *baluba_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bangball_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &bangball_get_ctrl_name
};

const char *bangball_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Throw";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bang_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &bang_get_ctrl_name
};

const char *bang_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_LIGHTGUN_X: return "Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Right";
    case IPT_LIGHTGUN_Y: return "Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo bankp_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &bankp_get_ctrl_name
};

const char *bankp_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot Door 1";
    case IPT_BUTTON2: return BTN2 "Shoot Door 2";
    case IPT_BUTTON3: return BTN3 "Shoot Door 3";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo baraduke_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &baraduke_get_ctrl_name
};

const char *baraduke_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo barricad_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Panel had directional buttons but of course mame is mapped to the normal joystick inputs", /* control_details */
  &barricad_get_ctrl_name
};

const char *barricad_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo barrier_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mame has the original directional buttons mapped to the normal mame movement buttons  Buttons are used to select skill level", /* control_details */
  &barrier_get_ctrl_name
};

const char *barrier_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Beginner";
    case IPT_BUTTON2: return BTN2 "Intermediate";
    case IPT_BUTTON3: return BTN3 "Expert";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bsktball_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "On the real machine this game had the start button wired onto the action button and the true caption reads 'Start, Shoot  & Jump'  However it appears that the start button has been split out in mame.", /* control_details */
  &bsktball_get_ctrl_name
};

const char *bsktball_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot & Jump";
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo batman_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &batman_get_ctrl_name
};

const char *batman_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Action";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo batsugun_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &batsugun_get_ctrl_name
};

const char *batsugun_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo battlnts_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &battlnts_get_ctrl_name
};

const char *battlnts_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bkraidj_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "At the ship select screen: To select a 'main shot power type' fighter, select your ship with A button, To select a 'Bomber power type', select your ship with B button, To select a 'Side shot power type', select your ship with C button, To select a 'Speed up type', select your ship with Start button. During game A - Shoot, B - Bomb", /* control_details */
  &bkraidj_get_ctrl_name
};

const char *bkraidj_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "A";
    case IPT_BUTTON2: return BTN2 "B";
    case IPT_BUTTON3: return BTN3 "C";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo battlex_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &battlex_get_ctrl_name
};

const char *battlex_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bcruzm12_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Should be just a horizontal 2-way joystick as shown on the coinop link. However mame driver marineb.c has as 8-way", /* control_details */
  &bcruzm12_get_ctrl_name
};

const char *bcruzm12_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
  } /* end of switch */

  return "";
}

const struct ControlInfo btlkroad_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &btlkroad_get_ctrl_name
};

const char *btlkroad_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Light Punch";
    case IPT_BUTTON2: return BTN2 "Middle Punch";
    case IPT_BUTTON3: return BTN3 "Heavy Punch";
    case IPT_BUTTON4: return BTN4 "Light Kick";
    case IPT_BUTTON5: return BTN5 "Middle Kick";
    case IPT_BUTTON6: return BTN6 "Heavy Kick";
    case IPT_JOYSTICK_UP: return "Jump";
    case IPT_JOYSTICK_DOWN: return "Duck";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo battlane_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &battlane_get_ctrl_name
};

const char *battlane_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Missile";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo atlantis_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &atlantis_get_ctrl_name
};

const char *atlantis_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo battlera_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &battlera_get_ctrl_name
};

const char *battlera_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "Grenade";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bshark_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "This game uses a one of a kind periscope control and you look into the periscope to see the screen similar to battlezone. For all intensive purposes it's a glorified star wars yoke though.", /* control_details */
  &bshark_get_ctrl_name
};

const char *bshark_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_AD_STICK_X: return "Left";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "Right";
    case IPT_AD_STICK_Y: return "Up";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo btoads_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This game is either set to 2 player, where you can select your toad, or 3 player, where the toads are hard-wired to the panel. You can adjust this setting in the dipswitches.", /* control_details */
  &btoads_get_ctrl_name
};

const char *btoads_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Start / Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bzone_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "Both handles have holes for a trigger switch, but generally only one has a button.", /* control_details */
  &bzone_get_ctrl_name
};

const char *bzone_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICKLEFT_UP: return "Left Tread Forward";
    case IPT_JOYSTICKLEFT_DOWN: return "Left Tread Backward";
    case IPT_JOYSTICKRIGHT_UP: return "Right Tread Forward";
    case IPT_JOYSTICKRIGHT_DOWN: return "Right Tread Backward";
  } /* end of switch */

  return "";
}

const struct ControlInfo bayroute_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &bayroute_get_ctrl_name
};

const char *bayroute_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo beaminv_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &beaminv_get_ctrl_name
};

const char *beaminv_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_PADDLE: return "Left";
    case (IPT_PADDLE + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bbusters_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &bbusters_get_ctrl_name
};

const char *bbusters_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Grenade";
    case IPT_LIGHTGUN_Y: return "Up";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Right";
    case IPT_LIGHTGUN_X: return "Left";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo beathead_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Jump - player jumps to the adjacent block in the desired direction Big Jump - plyers jumps over the adjacent block and lands on the next", /* control_details */
  &beathead_get_ctrl_name
};

const char *beathead_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jump";
    case IPT_BUTTON2: return BTN2 "Big Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bm1stmix_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This game uses a musical 'keyboard' and Turntable. The keyboard is actually 5 trivia buttons rotated 90 degrees, arranged like a section of a piano.    This game has a 6th button next to the start buttons on the control panel labeled 'Effector'. The button is mapped to start3 in mame because of it's physical position and this seems to make the most sense. As the button doesn't really impact gameplay, we'll simply ignore it for now.", /* control_details */
  &bm1stmix_get_ctrl_name
};

const char *bm1stmix_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "White 1";
    case IPT_BUTTON2: return BTN2 "Black 1";
    case IPT_BUTTON3: return BTN3 "White 2";
    case IPT_BUTTON4: return BTN4 "Black 2";
    case IPT_BUTTON5: return BTN5 "White 3";
    case (IPT_DIAL + IPT_EXTENSION): return "Scratch";
    case IPT_DIAL: return "Scratch";
  } /* end of switch */

  return "";
}

const struct ControlInfo bm2ndmix_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This game uses a musical 'keyboard' and Turntable. The keyboard is actually 5 trivia buttons rotated 90 degrees, arranged like a section of a piano.    This game has a 6th button next to the start buttons on the control panel labeled 'Effector'. The button is mapped to start3 in mame because of it's physical position and this seems to make the most sense. As the button doesn't really impact gameplay, we'll simply ignore it for now.", /* control_details */
  &bm2ndmix_get_ctrl_name
};

const char *bm2ndmix_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "White 1";
    case IPT_BUTTON2: return BTN2 "Black 1";
    case IPT_BUTTON3: return BTN3 "White 2";
    case IPT_BUTTON4: return BTN4 "Black 2";
    case IPT_BUTTON5: return BTN5 "White 3";
    case (IPT_DIAL + IPT_EXTENSION): return "Scratch";
    case IPT_DIAL: return "Scratch";
  } /* end of switch */

  return "";
}

const struct ControlInfo bm4thmix_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This game uses a musical 'keyboard' and Turntable. The keyboard is actually 5 trivia buttons rotated 90 degrees, arranged like a section of a piano.    This game has a 6th button next to the start buttons on the control panel labeled 'Effector'. The button is mapped to start3 in mame because of it's physical position and this seems to make the most sense. As the button doesn't really impact gameplay, we'll simply ignore it for now.", /* control_details */
  &bm4thmix_get_ctrl_name
};

const char *bm4thmix_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "White 1";
    case IPT_BUTTON2: return BTN2 "Black 1";
    case IPT_BUTTON3: return BTN3 "White 2";
    case IPT_BUTTON4: return BTN4 "Black 2";
    case IPT_BUTTON5: return BTN5 "White 3";
    case (IPT_DIAL + IPT_EXTENSION): return "Scratch";
    case IPT_DIAL: return "Scratch";
  } /* end of switch */

  return "";
}

const struct ControlInfo bm5thmix_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This game uses a musical 'keyboard' and Turntable. The keyboard is actually 5 trivia buttons rotated 90 degrees, arranged like a section of a piano.    This game has a 6th button next to the start buttons on the control panel labeled 'Effector'. The button is mapped to start3 in mame because of it's physical position and this seems to make the most sense. As the button doesn't really impact gameplay, we'll simply ignore it for now.", /* control_details */
  &bm5thmix_get_ctrl_name
};

const char *bm5thmix_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "White 1";
    case IPT_BUTTON2: return BTN2 "Black 1";
    case IPT_BUTTON3: return BTN3 "White 2";
    case IPT_BUTTON4: return BTN4 "Black 2";
    case IPT_BUTTON5: return BTN5 "White 3";
    case (IPT_DIAL + IPT_EXTENSION): return "Scratch";
    case IPT_DIAL: return "Scratch";
  } /* end of switch */

  return "";
}

const struct ControlInfo bm6thmix_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This game uses a musical 'keyboard' and Turntable. The keyboard is actually 5 trivia buttons rotated 90 degrees, arranged like a section of a piano.    This game has a 6th button next to the start buttons on the control panel labeled 'Effector'. The button is mapped to start3 in mame because of it's physical position and this seems to make the most sense. As the button doesn't really impact gameplay, we'll simply ignore it for now.", /* control_details */
  &bm6thmix_get_ctrl_name
};

const char *bm6thmix_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "White 1";
    case IPT_BUTTON2: return BTN2 "Black 1";
    case IPT_BUTTON3: return BTN3 "White 2";
    case IPT_BUTTON4: return BTN4 "Black 2";
    case IPT_BUTTON5: return BTN5 "White 3";
    case (IPT_DIAL + IPT_EXTENSION): return "Scratch";
    case IPT_DIAL: return "Scratch";
  } /* end of switch */

  return "";
}

const struct ControlInfo bmcompmx_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This game uses a musical 'keyboard' and Turntable. The keyboard is actually 5 trivia buttons rotated 90 degrees, arranged like a section of a piano.    This game has a 6th button next to the start buttons on the control panel labeled 'Effector'. The button is mapped to start3 in mame because of it's physical position and this seems to make the most sense. As the button doesn't really impact gameplay, we'll simply ignore it for now.", /* control_details */
  &bmcompmx_get_ctrl_name
};

const char *bmcompmx_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "White 1";
    case IPT_BUTTON2: return BTN2 "Black 1";
    case IPT_BUTTON3: return BTN3 "White 2";
    case IPT_BUTTON4: return BTN4 "Black 2";
    case IPT_BUTTON5: return BTN5 "White 3";
    case (IPT_DIAL + IPT_EXTENSION): return "Scratch";
    case IPT_DIAL: return "Scratch";
  } /* end of switch */

  return "";
}

const struct ControlInfo bmcompm2_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This game uses a musical 'keyboard' and Turntable. The keyboard is actually 5 trivia buttons rotated 90 degrees, arranged like a section of a piano.    This game has a 6th button next to the start buttons on the control panel labeled 'Effector'. The button is mapped to start3 in mame because of it's physical position and this seems to make the most sense. As the button doesn't really impact gameplay, we'll simply ignore it for now.", /* control_details */
  &bmcompm2_get_ctrl_name
};

const char *bmcompm2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "White 1";
    case IPT_BUTTON2: return BTN2 "Black 1";
    case IPT_BUTTON3: return BTN3 "White 2";
    case IPT_BUTTON4: return BTN4 "Black 2";
    case IPT_BUTTON5: return BTN5 "White 3";
    case (IPT_DIAL + IPT_EXTENSION): return "Scratch";
    case IPT_DIAL: return "Scratch";
  } /* end of switch */

  return "";
}

const struct ControlInfo bmcorerm_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This game uses a musical 'keyboard' and Turntable. The keyboard is actually 5 trivia buttons rotated 90 degrees, arranged like a section of a piano.    This game has a 6th button next to the start buttons on the control panel labeled 'Effector'. The button is mapped to start3 in mame because of it's physical position and this seems to make the most sense. As the button doesn't really impact gameplay, we'll simply ignore it for now.", /* control_details */
  &bmcorerm_get_ctrl_name
};

const char *bmcorerm_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "White 1";
    case IPT_BUTTON2: return BTN2 "Black 1";
    case IPT_BUTTON3: return BTN3 "White 2";
    case IPT_BUTTON4: return BTN4 "Black 2";
    case IPT_BUTTON5: return BTN5 "White 3";
    case IPT_DIAL: return "Scratch";
    case (IPT_DIAL + IPT_EXTENSION): return "Scratch";
  } /* end of switch */

  return "";
}

const struct ControlInfo bmdct_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This game uses a musical 'keyboard' and Turntable. The keyboard is actually 5 trivia buttons rotated 90 degrees, arranged like a section of a piano.    This game has a 6th button next to the start buttons on the control panel labeled 'Effector'. The button is mapped to start3 in mame because of it's physical position and this seems to make the most sense. As the button doesn't really impact gameplay, we'll simply ignore it for now.", /* control_details */
  &bmdct_get_ctrl_name
};

const char *bmdct_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "White 1";
    case IPT_BUTTON2: return BTN2 "Black 1";
    case IPT_BUTTON3: return BTN3 "White 2";
    case IPT_BUTTON4: return BTN4 "Black 2";
    case IPT_BUTTON5: return BTN5 "White 3";
    case IPT_DIAL: return "Scratch";
    case (IPT_DIAL + IPT_EXTENSION): return "Scratch";
  } /* end of switch */

  return "";
}

const struct ControlInfo beezer_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &beezer_get_ctrl_name
};

const char *beezer_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo bel_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Mame has 4 buttons for this game, but it's leftover from the generic model 2 driver. Only the trigger button and grenade button, both monunted on the gun, exist.", /* control_details */
  &bel_get_ctrl_name
};

const char *bel_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Grenade";
    case IPT_LIGHTGUN_X: return "Aim Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Aim Right";
    case IPT_LIGHTGUN_Y: return "Aim Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Aim Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo blswhstl_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Both buttons do the same thing. The review on gamefaqs says there is only 1 button, but the game is using the tmnt.c driver which has 2 buttons as default for all games", /* control_details */
  &blswhstl_get_ctrl_name
};

const char *blswhstl_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo berabohm_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Original game has 2 pressure sensitive buttons but mame is hacked to 4 buttons. To do the hard attack, press buttons 1 and 2 together, for high jump, press buttons 3 and 4 together. Taken from the driver (namcos1.c)   Notes: The berabohm buttons don't work too well. The real thing has a special pressure sensitive button, with two switches. The harder you push the button, the faster the two switches are closed one after another. Due to MAME's limited input sample rate (once per frame) it is difficult to measure the time between the two. Buttons (pressure sensitive) each button has two switches: the first is closed as soon as the button is pressed, the second a little later, depending on how hard the button is pressed. 	bits 0-5 control strength (0x00 = max 0x3f = min) 	bit 6 indicates the button is pressed 	bit 7 is not actually read by the game but I use it to simulate the second switch", /* control_details */
  &berabohm_get_ctrl_name
};

const char *berabohm_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Hard Attack";
    case IPT_BUTTON3: return BTN3 "Jump";
    case IPT_BUTTON4: return BTN4 "High Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bermudat_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Button two changes the formation of the picked up small shield airplanes.", /* control_details */
  &bermudat_get_ctrl_name
};

const char *bermudat_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "??";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_DIAL: return "Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo berzerk_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This game was shipped out the door with a 8 way optical joystick. The joystick behaved exactly like a regular 8 way joystick except it was constantly failing. It was so bad that Stern recalled the orignal joystick and offered free leaf replacments to all the owners. So for the history books this game didn't use a regular 8 way, but in actuality it did 99 percent of the time.", /* control_details */
  &berzerk_get_ctrl_name
};

const char *berzerk_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bigevglf_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Button is on either side of the trackball. Button 2 is only used in cocktail mode.", /* control_details */
  &bigevglf_get_ctrl_name
};

const char *bigevglf_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Club Select";
    case IPT_BUTTON2: return BTN2 "Club Select (2P)";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo bigkarnk_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &bigkarnk_get_ctrl_name
};

const char *bigkarnk_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shot";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bigrun_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "Obviously the horn button isn't labeled, but is the horn on the wheel.", /* control_details */
  &bigrun_get_ctrl_name
};

const char *bigrun_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Accelerate";
    case IPT_BUTTON2: return BTN2 "Brake";
    case IPT_BUTTON3: return BTN3 "Low";
    case IPT_BUTTON4: return BTN4 "High";
    case IPT_BUTTON5: return BTN5 "Horn";
    case IPT_PADDLE: return "Left";
    case (IPT_PADDLE + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bigstrik_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "In offense A-Short Pass, B-Long Pass/Shoot, C-Fake Play In defense A-Sliding Tackle, B-Steal", /* control_details */
  &bigstrik_get_ctrl_name
};

const char *bigstrik_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "A";
    case IPT_BUTTON2: return BTN2 "B";
    case IPT_BUTTON3: return BTN3 "C";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bigtwin_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Couldn?t find what the actually button is called on the panel but by pressing it you cause the hand on the screen to grab a ball", /* control_details */
  &bigtwin_get_ctrl_name
};

const char *bigtwin_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Grab";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bbonk_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Driver(lazercmd.c) has the controls as joystick while Klov states directional buttons - couldn't find any CPO pics", /* control_details */
  &bbonk_get_ctrl_name
};

const char *bbonk_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo bijokkog_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &bijokkog_get_ctrl_name
};

const char *bijokkog_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo bijokkoy_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &bijokkoy_get_ctrl_name
};

const char *bijokkoy_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo bioatack_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &bioatack_get_ctrl_name
};

const char *bioatack_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bioship_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Super-Fire is achived by holding down the Fire button until the meter at the lower end of the screen reads full. Holding the Cursor button down causes the Paladin to remain stationary and the cursor can be moved around the screen using the joystick", /* control_details */
  &bioship_get_ctrl_name
};

const char *bioship_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Cursor";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo biofreak_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &biofreak_get_ctrl_name
};

const char *biofreak_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Left Punch";
    case IPT_BUTTON2: return BTN2 "Right Punch";
    case IPT_BUTTON3: return BTN3 "Fire/Shield";
    case IPT_BUTTON4: return BTN4 "Left Kick";
    case IPT_BUTTON5: return BTN5 "Right Kick";
    case IPT_BUTTON6: return BTN6 "Hover";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo biomtoy_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "Game is only 1 player while the driver (gaelco.c) has 2.", /* control_details */
  &biomtoy_get_ctrl_name
};

const char *biomtoy_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bionicc_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &bionicc_get_ctrl_name
};

const char *bionicc_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Bionic Reach";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bking_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &bking_get_ctrl_name
};

const char *bking_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo bking2_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &bking2_get_ctrl_name
};

const char *bking2_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_X: return "Left";
  } /* end of switch */

  return "";
}

const struct ControlInfo bking3_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &bking3_get_ctrl_name
};

const char *bking3_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo birdtry_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "In game controls lists dial input for both players. I think this is taken from hbarrel which is from the same driver (dec0.c). Shouldn?t be in there. Gameplay - press the options button to change club, swing type and ball spin. Press the swing button to start swing. When red bar on right side of screen reaches desired power press swing again.", /* control_details */
  &birdtry_get_ctrl_name
};

const char *birdtry_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Swing";
    case IPT_BUTTON2: return BTN2 "Options";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo psailor1_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &psailor1_get_ctrl_name
};

const char *psailor1_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo psailor2_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &psailor2_get_ctrl_name
};

const char *psailor2_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo blkheart_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &blkheart_get_ctrl_name
};

const char *blkheart_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire A";
    case IPT_BUTTON2: return BTN2 "Fire B";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo blkhole_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &blkhole_get_ctrl_name
};

const char *blkhole_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo blkpnthr_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "No panel pics but that's what the buttons do.", /* control_details */
  &blkpnthr_get_ctrl_name
};

const char *blkpnthr_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo blktiger_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &blktiger_get_ctrl_name
};

const char *blktiger_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Mace";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo bwidow_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &bwidow_get_ctrl_name
};

const char *bwidow_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICKLEFT_UP: return "Up";
    case IPT_JOYSTICKLEFT_DOWN: return "Down";
    case IPT_JOYSTICKLEFT_LEFT: return "Left";
    case IPT_JOYSTICKLEFT_RIGHT: return "Right";
    case IPT_JOYSTICKRIGHT_UP: return "Aim Up";
    case IPT_JOYSTICKRIGHT_DOWN: return "Aim Down";
    case IPT_JOYSTICKRIGHT_LEFT: return "Aim Left";
    case IPT_JOYSTICKRIGHT_RIGHT: return "Aim Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bmaster_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &bmaster_get_ctrl_name
};

const char *bmaster_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bladestl_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The Mame driver has inputs for a 8 way joystick as well, but I've yet to find a machine that uses those inputs. It's unknown if this is a hack.", /* control_details */
  &bladestl_get_ctrl_name
};

const char *bladestl_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_BUTTON2: return BTN2 "Pass / Face-Off";
    case IPT_BUTTON3: return BTN3 "FIGHT!";
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo blandia_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &blandia_get_ctrl_name
};

const char *blandia_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack High";
    case IPT_BUTTON2: return BTN2 "Attack Middle";
    case IPT_BUTTON3: return BTN3 "Attack Low";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo blastoff_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Driver (namcos1.c) has standard 3 button layout although only 2 are required", /* control_details */
  &blastoff_get_ctrl_name
};

const char *blastoff_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Change Weapon";
    case IPT_BUTTON3: return BTN3 "NA";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo blasted_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &blasted_get_ctrl_name
};

const char *blasted_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Aim Up";
    case IPT_JOYSTICK_DOWN: return "Aim Down";
    case IPT_JOYSTICK_LEFT: return "Aim Left";
    case IPT_JOYSTICK_RIGHT: return "Aim Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo blaster_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This game uses a 49-way optical triggerstick with thumb button. The buttons are repeated on the control panel. The game uses aircraft style controls - Pull back on the stick to climb.", /* control_details */
  &blaster_get_ctrl_name
};

const char *blaster_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Blast";
    case IPT_BUTTON2: return BTN2 "Thrust";
    case IPT_BUTTON3: return BTN3 "Unknown";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "Down";
    case IPT_AD_STICK_Y: return "Up";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "Right";
    case IPT_AD_STICK_X: return "Left";
  } /* end of switch */

  return "";
}

const struct ControlInfo blstroid_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &blstroid_get_ctrl_name
};

const char *blstroid_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Thrust";
    case IPT_BUTTON3: return BTN3 "Transform:  Armor, Shots, Speed";
    case IPT_DIAL: return "Rotate Ship Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Rotate Ship Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo blasto_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Cocktail cabinet had directional buttons (up/down/left/right) while upright had joysticks. Clearly seen on the arcadeflyer link", /* control_details */
  &blasto_get_ctrl_name
};

const char *blasto_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo blazeon_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Editor's note:  The control panel on this gmae labels the buttons simply as 'A' and 'B' but I felt it would be ok to simply put the actual functions as described in the flyer. As this game was often sold as a conversion kit, we can assume that the flyer used the labels 'A' and 'B' because that is the 'jamma standard' labeling scheme. A = Normal shot, B = Special Weapon / Attack", /* control_details */
  &blazeon_get_ctrl_name
};

const char *blazeon_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Normal Shot";
    case IPT_BUTTON2: return BTN2 "Special Weapon / Attack";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo blockout_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Note that oddly enough, the drop button, which is on the top-fire is the 4th button, not the first. Button A rotates on the Z axis, B on the Y axis, and C on the Ry. If you can't follow that just try the game an you will cath on.", /* control_details */
  &blockout_get_ctrl_name
};

const char *blockout_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "A Button";
    case IPT_BUTTON2: return BTN2 "B Button";
    case IPT_BUTTON3: return BTN3 "C Button";
    case IPT_BUTTON4: return BTN4 "Drop";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo blockade_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &blockade_get_ctrl_name
};

const char *blockade_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bloodbro_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &bloodbro_get_ctrl_name
};

const char *bloodbro_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Roll";
    case IPT_BUTTON3: return BTN3 "Dynamite";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo bloxeed_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &bloxeed_get_ctrl_name
};

const char *bloxeed_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Rotate";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo blueprnt_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &blueprnt_get_ctrl_name
};

const char *blueprnt_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Run";
    case IPT_JOYSTICK_UP: return "Walk Up";
    case IPT_JOYSTICK_DOWN: return "Walk Down";
    case IPT_JOYSTICK_LEFT: return "Walk Left";
    case IPT_JOYSTICK_RIGHT: return "Walk Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo blueshrk_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "This game actually used a one axis positional gun shaped to look like a spear gun. The spear shoots from the bottom of the screen and travels all the way to the top so just one axis is needed.", /* control_details */
  &blueshrk_get_ctrl_name
};

const char *blueshrk_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_PADDLE: return "Aim Left";
    case (IPT_PADDLE + IPT_EXTENSION): return "Aim Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bodyslam_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Press help when near team mate to tag Press punch + kick and a direction to run Press punch when opponent on ground to pick them up Press kick to pin Press help to get up off the ground", /* control_details */
  &bodyslam_get_ctrl_name
};

const char *bodyslam_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Punch";
    case IPT_BUTTON2: return BTN2 "Kick";
    case IPT_BUTTON3: return BTN3 "Help";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bogeyman_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Button A to swing the rod Button B Trick button (this can be used to jump when the player changes shape)or to trick the ghosts", /* control_details */
  &bogeyman_get_ctrl_name
};

const char *bogeyman_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "A";
    case IPT_BUTTON2: return BTN2 "B";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bombjack_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &bombjack_get_ctrl_name
};

const char *bombjack_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jump";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo boogwing_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Each player starts with a single bomb attached to their plane by a hook. Once dropped the hook can be used to pick up any land-based objects and drop them at will with the bomb button. Once the player's plane is shot down, they can run on land and fire with a pistol until hit.", /* control_details */
  &boogwing_get_ctrl_name
};

const char *boogwing_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo boothill_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This game did NOT have a paddle but something, that for lack of a better description, is a 'paddle gun'. It's similar to the T2 analog guns but with a single axis.", /* control_details */
  &boothill_get_ctrl_name
};

const char *boothill_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_PADDLE: return "Aim Left";
    case (IPT_PADDLE + IPT_EXTENSION): return "Aim Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bosco_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &bosco_get_ctrl_name
};

const char *bosco_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bottom9_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Buttons A and B do various things. According to the manual, A= 'Throw/Swing/Go' and B = 'Select/Bunt/Back'", /* control_details */
  &bottom9_get_ctrl_name
};

const char *bottom9_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "A";
    case IPT_BUTTON2: return BTN2 "B";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bouldash_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &bouldash_get_ctrl_name
};

const char *bouldash_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bowler_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "4 players alternate with the same trackball in the upright cab. Mame doesn't have cocktail mode, but KLOV shows a two trackball cocktail.", /* control_details */
  &bowler_get_ctrl_name
};

const char *bowler_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Straight/Hook";
    case IPT_BUTTON2: return BTN2 "??";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo boxingb_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The dial is actually labeled rotation control. The buttons don't have labels, rather they have pictures of a rocket and a boxing glove respectively.", /* control_details */
  &boxingb_get_ctrl_name
};

const char *boxingb_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Rocket";
    case IPT_BUTTON2: return BTN2 "Punch";
    case IPT_DIAL: return "Rotate Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Rotate Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bradley_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "I've made an executive decision on this one. Since it's a prototype and there aren't any good pics of the control panel, I've decided to list the labels given in mame (which are not correct) and describe how the actual machine worked. First off we have a yoke designed for this military conversion. If not for this game, there wouldn't be a star wars yoke. The range of the shot was controlled by an analog dial on the bezel. Next to that was a digital knob that controlled the magnification. The game originally had a toggle switch that doesn't seem to be included in mame. My guess is that it was never hooked up to anything (this prototype was a mess and was never finished). Please note that all buttons save the first hae hard-coded mappings.", /* control_details */
  &bradley_get_ctrl_name
};

const char *bradley_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=10 */
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON10: return "Magnification Toggle";
    case IPT_BUTTON2: return BTN2 "Armor Piercing (Single Shot)";
    case IPT_BUTTON3: return BTN3 "High Explosive (Single Shot)";
    case IPT_BUTTON4: return BTN4 "Armor Piercing (Low Rate)";
    case IPT_BUTTON5: return BTN5 "High Explosive (Low Rate)";
    case IPT_BUTTON6: return BTN6 "Armor Piercing (High Rate)";
    case IPT_BUTTON7: return BTN7 "High Explosive (High Rate)";
    case IPT_BUTTON8: return BTN7 "Select Tow Missiles";
    case IPT_BUTTON9: return "7.62 mm Machine Gun";
    case (IPT_AD_STICK_Z + IPT_EXTENSION): return "Decrease Range";
    case IPT_AD_STICK_Z: return "Increase Range";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "Aim Right";
    case IPT_AD_STICK_X: return "Aim Left";
    case IPT_AD_STICK_Y: return "Aim Up";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "Aim Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo brkthru_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This game's official overlay didn't have any labels. These are labels.", /* control_details */
  &brkthru_get_ctrl_name
};

const char *brkthru_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bublbobl_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &bublbobl_get_ctrl_name
};

const char *bublbobl_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Bubble";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bubbles_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &bubbles_get_ctrl_name
};

const char *bubbles_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo buckrog_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The trigger stick button is mirrored on the control panel.", /* control_details */
  &buckrog_get_ctrl_name
};

const char *buckrog_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Slow";
    case IPT_BUTTON3: return BTN3 "Fast";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo buggychl_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "As it's mapped in mame, holidng down the shifter button keeps the car in high gear.", /* control_details */
  &buggychl_get_ctrl_name
};

const char *buggychl_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Accelerate";
    case IPT_BUTTON2: return BTN2 "H / L";
    case IPT_DIAL: return "Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo btime_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &btime_get_ctrl_name
};

const char *btime_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Pepper";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo brubber_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Up and Down act essentially as a gear shift, you don\'t have to hold up or down to go fast or slow. Also note that you can only jump when going fast.", /* control_details */
  &brubber_get_ctrl_name
};

const char *brubber_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jump";
    case IPT_JOYSTICK_UP: return "Fast";
    case IPT_JOYSTICK_DOWN: return "Slow";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo cabal_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "There is a bootleg version that used 8-way sticks and 3 buttons instead of the official trackball and 2 buttons. The third button in the bootleg version is the roll button.", /* control_details */
  &cabal_get_ctrl_name
};

const char *cabal_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Grenade";
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo cadash_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &cadash_get_ctrl_name
};

const char *cadash_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo dino_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &dino_get_ctrl_name
};

const char *dino_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo calibr50_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The joysticks were 'Loop 24' joysticks, which look like the yellow mechanical 'LS-30', except are optical instead of mechanical. They also had green handles and clicked 24 times to complete a full rotation, hence the 'Loop 24' name.", /* control_details */
  &calibr50_get_ctrl_name
};

const char *calibr50_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Rapid Fire";
    case IPT_BUTTON2: return BTN2 "Grenade";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_DIAL: return "Rotate Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Rotate Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo cameltry_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This game seems to use a tetris cpo. The button isn't actually labeled, and the labels it were given are explained during gameplay. Pressing the button jumps while holding it down speeds up your decent.", /* control_details */
  &cameltry_get_ctrl_name
};

const char *cameltry_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jump / Speedup";
    case IPT_DIAL: return "Rotate Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Rotate Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo canyon_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The panel had buttons labelled Black Start, Black Fire, White Start, White Fire. Black is the first player and White is the second, so we don't add that part onto the label here. It also had a button for Hi Score Reset (yes, on the panel itself), MAME oddly emulates this as p1 button 7, but the driver overrides the default key to an 'H' (for 'high' score reset). The driver will eventually be fixed to put this button in the service buttons, where it bleongs.", /* control_details */
  &canyon_get_ctrl_name
};

const char *canyon_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
  } /* end of switch */

  return "";
}

const struct ControlInfo capbowl_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &capbowl_get_ctrl_name
};

const char *capbowl_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Hook Left";
    case IPT_BUTTON2: return BTN2 "Hook Right";
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo captaven_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &captaven_get_ctrl_name
};

const char *captaven_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Start / Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo captcomm_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Pressing attack and jump performs a special. This game is basically a capcom ripoff of tmnt and the controls are similar. The only difference is the use of a very rare two-sided, circular, 2-in-1 button (unlabeled btw) instead of two regular buttons. It should also be noted that this game can be changed from 2 player up to 4 player in the dipswitches and just like tmnt when you have it in 4 player mode players can't select their characters.", /* control_details */
  &captcomm_get_ctrl_name
};

const char *captcomm_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo carnevil_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The lightgun is shaped like a small, piston grip, pump action shotgun. You can also reload by shooting off screen.", /* control_details */
  &carnevil_get_ctrl_name
};

const char *carnevil_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Trigger";
    case IPT_BUTTON2: return BTN2 "Reload";
    case IPT_LIGHTGUN_X: return "Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Right";
    case IPT_LIGHTGUN_Y: return "Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo carnival_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &carnival_get_ctrl_name
};

const char *carnival_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo cawing_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &cawing_get_ctrl_name
};

const char *cawing_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Special Weapon";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo cavelon_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &cavelon_get_ctrl_name
};

const char *cavelon_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_BUTTON2: return BTN2 "Magic Sword";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo cninja_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &cninja_get_ctrl_name
};

const char *cninja_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Aim Up";
    case IPT_JOYSTICK_DOWN: return "Duck";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo centiped_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &centiped_get_ctrl_name
};

const char *centiped_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo challeng_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &challeng_get_ctrl_name
};

const char *challeng_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_BUTTON3: return BTN3 "Warp";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo champbas_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "The actual cpo labels simply read A, B, and C respectively. The bezel, however, tells you the functions. Since part of this projects goal is to aid in figuring out how to play, I improvised and combined the two.", /* control_details */
  &champbas_get_ctrl_name
};

const char *champbas_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "A: Change Batter, Pitcher";
    case IPT_BUTTON2: return BTN2 "B: Bat, Extra Bases - Pitch, Throw Ball";
    case IPT_BUTTON3: return BTN3 "C: Steal, Run Back";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo csprint_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &csprint_get_ctrl_name
};

const char *csprint_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_DIAL: return "Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
    case IPT_PEDAL: return "Accelerate ";
  } /* end of switch */

  return "";
}

const struct ControlInfo checkman_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The original Japanese version of Check Man (checkmaj) uses two fire buttons to slide the rows of blocks left and right. The fire buttons were removed for the world release and the player select buttons are used to slide the blocks.", /* control_details */
  &checkman_get_ctrl_name
};

const char *checkman_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Slide left";
    case IPT_BUTTON2: return BTN2 "Slide right";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo checkmat_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &checkmat_get_ctrl_name
};

const char *checkmat_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo cheekyms_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &cheekyms_get_ctrl_name
};

const char *cheekyms_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Hammer";
    case IPT_JOYSTICK_LEFT: return "L";
    case IPT_JOYSTICK_RIGHT: return "R";
  } /* end of switch */

  return "";
}

const struct ControlInfo cheyenne_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Game used a rifle style lightgun on a pedestal mount.", /* control_details */
  &cheyenne_get_ctrl_name
};

const char *cheyenne_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Down";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Right";
    case IPT_LIGHTGUN_Y: return "Up";
    case IPT_LIGHTGUN_X: return "Left";
  } /* end of switch */

  return "";
}

const struct ControlInfo cshift_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &cshift_get_ctrl_name
};

const char *cshift_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Blue Things";
    case IPT_BUTTON2: return BTN2 "Red Things";
  } /* end of switch */

  return "";
}

const struct ControlInfo chiller_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This game is one of only a handful that uses a mounted lightgun instead of a regular analog mounted gun. You would think that mame-wize it would be more autehntic to use an analog gun, but as the game doesn't have any calibration (since it's optical) it is reccomended that you use a standard lightgun for this game.", /* control_details */
  &chiller_get_ctrl_name
};

const char *chiller_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_LIGHTGUN_X: return "Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Right";
    case IPT_LIGHTGUN_Y: return "Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo ccasino_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &ccasino_get_ctrl_name
};

const char *ccasino_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo chopper_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This game's official cpo is unlabeled. If anyone has the manual to this game please feel free to verify these labels.", /* control_details */
  &chopper_get_ctrl_name
};

const char *chopper_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_BUTTON2: return BTN2 "Special Weapon";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo circus_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The original cpo didn't have any labels for the paddle, but rather the instructions:  'Bounce Man From Board. Pop Balloons For Points'  The game also listed the scoring chart on the cpo.", /* control_details */
  &circus_get_ctrl_name
};

const char *circus_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_PADDLE: return "Left";
    case (IPT_PADDLE + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo circusc_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "One neat feature of the game is that Player 1 and Player 2 can select different levels of difficulty.", /* control_details */
  &circusc_get_ctrl_name
};

const char *circusc_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jump";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo cischeat_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The 'Horn' button has a picture of a horn on it rather than actual text.", /* control_details */
  &cischeat_get_ctrl_name
};

const char *cischeat_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Accelerate";
    case IPT_BUTTON2: return BTN2 "Brake";
    case IPT_BUTTON3: return BTN3 "Low";
    case IPT_BUTTON4: return BTN4 "Hi";
    case IPT_BUTTON5: return BTN5 "Horn";
    case (IPT_PADDLE + IPT_EXTENSION): return "Right";
    case IPT_PADDLE: return "Left";
  } /* end of switch */

  return "";
}

const struct ControlInfo citycon_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &citycon_get_ctrl_name
};

const char *citycon_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo citylove_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &citylove_get_ctrl_name
};

const char *citylove_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo cloak_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &cloak_get_ctrl_name
};

const char *cloak_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Light Fuse";
    case IPT_JOYSTICKLEFT_UP: return "Up";
    case IPT_JOYSTICKLEFT_DOWN: return "Down";
    case IPT_JOYSTICKLEFT_LEFT: return "Left";
    case IPT_JOYSTICKLEFT_RIGHT: return "Right";
    case IPT_JOYSTICKRIGHT_UP: return "Fire Up";
    case IPT_JOYSTICKRIGHT_DOWN: return "Fire Down";
    case IPT_JOYSTICKRIGHT_LEFT: return "Fire Left";
    case IPT_JOYSTICKRIGHT_RIGHT: return "Fire Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo clowns_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This game definately has a unique layout. Although players take turns, each player has his own controls, even on the upright version. Even stranger is the fact that the second players controls are on the left and player one is on the right.", /* control_details */
  &clowns_get_ctrl_name
};

const char *clowns_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_PADDLE: return "Move Left";
    case (IPT_PADDLE + IPT_EXTENSION): return "Move Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo cltchitr_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The A, B, and C buttons actually have a series of actions listed for each one on the cpo, but it's far too long to document here.", /* control_details */
  &cltchitr_get_ctrl_name
};

const char *cltchitr_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "A";
    case IPT_BUTTON2: return BTN2 "B";
    case IPT_BUTTON3: return BTN3 "C";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo colony7_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &colony7_get_ctrl_name
};

const char *colony7_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Mega - Blaster";
    case IPT_BUTTON3: return BTN3 "Eradicator";
    case IPT_JOYSTICK_UP: return "Control Up";
    case IPT_JOYSTICK_DOWN: return "Control Down";
    case IPT_JOYSTICK_LEFT: return "Control Left";
    case IPT_JOYSTICK_RIGHT: return "Control Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo columns_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The button is actually unlabed on the cpo and in the manual.", /* control_details */
  &columns_get_ctrl_name
};

const char *columns_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Switch Pieces";
    case IPT_JOYSTICK_UP: return "(Not Used)";
    case IPT_JOYSTICK_DOWN: return "Drop";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo combat_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "This game uses a lightgun, but it's mounted to the control panel like an analog gun.", /* control_details */
  &combat_get_ctrl_name
};

const char *combat_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_LIGHTGUN_X: return "Aim Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Aim Right";
    case IPT_LIGHTGUN_Y: return "Aim Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Aim Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo commsega_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &commsega_get_ctrl_name
};

const char *commsega_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Machine Gun";
    case IPT_BUTTON2: return BTN2 "Grenade";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo commando_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &commando_get_ctrl_name
};

const char *commando_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Machine Gun";
    case IPT_BUTTON2: return BTN2 "Grenade";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo comotion_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &comotion_get_ctrl_name
};

const char *comotion_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo congo_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &congo_get_ctrl_name
};

const char *congo_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jump";
    case IPT_JOYSTICK_UP: return "Up-Right";
    case IPT_JOYSTICK_DOWN: return "Down-Left";
    case IPT_JOYSTICK_LEFT: return "Left-Up";
    case IPT_JOYSTICK_RIGHT: return "Right-Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo contra_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &contra_get_ctrl_name
};

const char *contra_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo cosmica_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This game used odd buttons, that are essentially regular buttons with a translucent core.", /* control_details */
  &cosmica_get_ctrl_name
};

const char *cosmica_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo cavenger_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &cavenger_get_ctrl_name
};

const char *cavenger_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo cchasm_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &cchasm_get_ctrl_name
};

const char *cchasm_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Thrust";
    case IPT_BUTTON3: return BTN3 "Shields";
    case IPT_DIAL: return "Rotate Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Rotate Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo cosmicg_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &cosmicg_get_ctrl_name
};

const char *cosmicg_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo cracksht_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This game used a mounted lightgun as opposed to a free one.", /* control_details */
  &cracksht_get_ctrl_name
};

const char *cracksht_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_LIGHTGUN_X: return "Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Right";
    case IPT_LIGHTGUN_Y: return "Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo crash_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &crash_get_ctrl_name
};

const char *crash_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fast";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo crater_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The shield button is the thumb button on the joystick.", /* control_details */
  &crater_get_ctrl_name
};

const char *crater_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire (Trigger)";
    case IPT_BUTTON2: return BTN2 "Shield";
    case IPT_BUTTON3: return BTN3 "??";
    case IPT_JOYSTICK_DOWN: return "Reverse";
    case IPT_JOYSTICK_UP: return "Forward";
    case IPT_DIAL: return "Turn Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Turn Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo cclimber_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &cclimber_get_ctrl_name
};

const char *cclimber_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICKLEFT_UP: return "Left Up";
    case IPT_JOYSTICKLEFT_DOWN: return "Left Down";
    case IPT_JOYSTICKLEFT_LEFT: return "Left Left";
    case IPT_JOYSTICKLEFT_RIGHT: return "Left Right";
    case IPT_JOYSTICKRIGHT_UP: return "Right Up";
    case IPT_JOYSTICKRIGHT_DOWN: return "Right Down";
    case IPT_JOYSTICKRIGHT_LEFT: return "Right Left";
    case IPT_JOYSTICKRIGHT_RIGHT: return "Right Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo cclimbr2_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &cclimbr2_get_ctrl_name
};

const char *cclimbr2_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICKLEFT_UP: return "Left Up";
    case IPT_JOYSTICKLEFT_DOWN: return "Left Down";
    case IPT_JOYSTICKLEFT_LEFT: return "Left Left";
    case IPT_JOYSTICKLEFT_RIGHT: return "Left Right";
    case IPT_JOYSTICKRIGHT_UP: return "Right Up";
    case IPT_JOYSTICKRIGHT_DOWN: return "Right Down";
    case IPT_JOYSTICKRIGHT_LEFT: return "Right Left";
    case IPT_JOYSTICKRIGHT_RIGHT: return "Right Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo ckong_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &ckong_get_ctrl_name
};

const char *ckong_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo crimec_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &crimec_get_ctrl_name
};

const char *crimec_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo crimfght_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Even though the screen will tell you to press start, you press the punch button to start the game. Oddly enough, this beat-em-up doesn't have a jump button.", /* control_details */
  &crimfght_get_ctrl_name
};

const char *crimfght_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Punch";
    case IPT_BUTTON2: return BTN2 "Kick ";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo crossbow_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "This game uses a mounted optical crossbow instead of a regular lightgun.", /* control_details */
  &crossbow_get_ctrl_name
};

const char *crossbow_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_LIGHTGUN_X: return "Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Right";
    case IPT_LIGHTGUN_Y: return "Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo crgolf_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This game used a slew of small, red, chicklet, looking buttons. Along with a strang lever for the swing. Oddly enough the lever only adjusted the angle, and a button has to be pressed to actually hit the ball.", /* control_details */
  &crgolf_get_ctrl_name
};

const char *crgolf_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Swing";
    case IPT_BUTTON2: return BTN2 "Address Up";
    case IPT_BUTTON3: return BTN3 "Address Down";
    case IPT_BUTTON4: return BTN4 "Address Left";
    case IPT_BUTTON5: return BTN5 "Address Right";
    case IPT_BUTTON6: return BTN6 "Club Select";
    case IPT_AD_STICK_X: return "";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "";
    case IPT_AD_STICK_Y: return "Decrease Swing Angle";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "Increase Swing Angle";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo cbuster_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &cbuster_get_ctrl_name
};

const char *cbuster_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fight";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "Pick Up";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo crush_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &crush_get_ctrl_name
};

const char *crush_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo cryptklr_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Something of note is that this game uses a dedicated reload button that doesn't appear to be optional. The dedicated cabinet uses shotguns, in which the reload button is wired to the pump. Conversion kits often place the button on a control panel.", /* control_details */
  &cryptklr_get_ctrl_name
};

const char *cryptklr_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Reload";
    case IPT_LIGHTGUN_X: return "Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Right";
    case IPT_LIGHTGUN_Y: return "Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo ccastles_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The jump button is also the start button.", /* control_details */
  &ccastles_get_ctrl_name
};

const char *ccastles_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jump";
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo crystalg_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &crystalg_get_ctrl_name
};

const char *crystalg_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo crystal2_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &crystal2_get_ctrl_name
};

const char *crystal2_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo curvebal_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "Note that player 1 and player 2 share a set of controls. During an inning change, player 1 swaps places with player 2 and vice-versa. The batter buttons are globally labeled 'Bat Control and Runners Speed'  and the pitch controls are labeled 'Speed of Pitch and Curve'.", /* control_details */
  &curvebal_get_ctrl_name
};

const char *curvebal_get_ctrl_name(int type)
{
  switch(type)
  {
/* P2NumButtons=2 */
    case (IPT_OSD_DESCRIPTION | IPF_PLAYER2): return "Just Buttons+button";
    case (IPT_BUTTON1 | IPF_PLAYER2): return "Left (Curve)";
    case (IPT_BUTTON2 | IPF_PLAYER2): return "Right (Curve)";
    case IPT_BUTTON1: return BTN1 "Swing";
    case IPT_BUTTON2: return BTN2 "Bunt";
  } /* end of switch */

  return "";
}

const struct ControlInfo cybsled_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "This game used dual analog flight sticks. The Fire and Missile buttons are mirrored on both sticks, while the view point button is a lighted button on the control panel. It should be noted that this game was only sold as a dual cabinet with two boards linked together for head-2-head action, however due to limitations mame only emulates the first board and will probably never emulate the dual mode.", /* control_details */
  &cybsled_get_ctrl_name
};

const char *cybsled_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Missile";
    case IPT_BUTTON3: return BTN3 "View Point";
    case IPT_BUTTON4: return BTN4 "unknown";
    case IPT_AD_STICK_X: return "Left Tread Left";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "Left Tread Right";
    case IPT_AD_STICK_Y: return "Left Tread Forward";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "Left Tread Backward";
  } /* end of switch */

  return "";
}

const struct ControlInfo cyberbal_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "I can't make out the fine print on the cpo image I used as a reference. If you know the real label for the button let me know.", /* control_details */
  &cyberbal_get_ctrl_name
};

const char *cyberbal_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Action";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo cybots_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "", /* control_details */
  &cybots_get_ctrl_name
};

const char *cybots_get_ctrl_name(int type)
{
  switch(type)
  {
/* P2NumButtons=4 */
    case (IPT_OSD_DESCRIPTION | IPF_PLAYER2): return "8-way Joystick+joy8way";
    case (IPT_BUTTON1 | IPF_PLAYER2): return "Attack 1";
    case (IPT_BUTTON2 | IPF_PLAYER2): return "Attack 2";
    case (IPT_BUTTON3 | IPF_PLAYER2): return "Boost";
    case (IPT_BUTTON4 | IPF_PLAYER2): return "Weapons";
    case (IPT_JOYSTICK_RIGHT | IPF_PLAYER2): return "Back / Defense";
    case (IPT_JOYSTICK_LEFT | IPF_PLAYER2): return "Forward";
    case (IPT_JOYSTICK_DOWN | IPF_PLAYER2): return "Duck";
    case (IPT_JOYSTICK_UP | IPF_PLAYER2): return "Jump";
    case IPT_BUTTON1: return BTN1 "Attack 1";
    case IPT_BUTTON2: return BTN2 "Attack 2";
    case IPT_BUTTON3: return BTN3 "Boost";
    case IPT_BUTTON4: return BTN4 "Weapons";
    case IPT_JOYSTICK_LEFT: return "Back / Defense";
    case IPT_JOYSTICK_DOWN: return "Duck";
    case IPT_JOYSTICK_UP: return "Jump";
    case IPT_JOYSTICK_RIGHT: return "Forward";
  } /* end of switch */

  return "";
}

const struct ControlInfo daioh_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &daioh_get_ctrl_name
};

const char *daioh_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Laser Shot";
    case IPT_BUTTON2: return BTN2 "Ion Shot";
    case IPT_BUTTON3: return BTN3 "Missile Shot";
    case IPT_BUTTON4: return BTN4 "Fire Bomb";
    case IPT_BUTTON5: return BTN5 "Mega Beam";
    case IPT_BUTTON6: return BTN6 "Atomic Bomb";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo dangar_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The transform button allows you to split the main ship into several smaller ships.", /* control_details */
  &dangar_get_ctrl_name
};

const char *dangar_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Transform";
    case IPT_BUTTON3: return BTN3 "??";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo dangerz_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "This game does NOT use a trackball in real life. Instead, it uses quite possibly the most unique control ever. Two immovable trigger sticks are mounted on a panel attached to the monitor. When you try to move the sticks, they remain rigid and actually tilt the monitor!  The gameplay screen then scrolls depending upon where you tilt the monitor to. This gives the illusion of the player looking through a window onto the battle field.", /* control_details */
  &dangerz_get_ctrl_name
};

const char *dangerz_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Machine Gun";
    case IPT_BUTTON2: return BTN2 "Heat - Seaking Missile";
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo indyheat_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Player 1 is the Red car, Player 2 is the White car (light grey-ish), Player 3 is the Blue car. Mame by default maps the pedal and the turbo button to the same button input (button 1). If you leave it this way, to use turbo, release the button and press it again. To enter service mode, hold down the blue turbo button and then press the service key (F2).", /* control_details */
  &indyheat_get_ctrl_name
};

const char *indyheat_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Turbo";
    case IPT_DIAL: return "Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
    case IPT_PEDAL: return "Gas";
  } /* end of switch */

  return "";
}

const struct ControlInfo darkplnt_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &darkplnt_get_ctrl_name
};

const char *darkplnt_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Thrust";
    case IPT_BUTTON3: return BTN3 "Laser";
    case IPT_DIAL: return "Rotate Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Rotate Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo darkseal_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &darkseal_get_ctrl_name
};

const char *darkseal_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Magic";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo dstlk_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &dstlk_get_ctrl_name
};

const char *dstlk_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Light Punch";
    case IPT_BUTTON2: return BTN2 "Middle Punch";
    case IPT_BUTTON3: return BTN3 "Heavy Punch";
    case IPT_BUTTON4: return BTN4 "Light Kick";
    case IPT_BUTTON5: return BTN5 "Middle Kick";
    case IPT_BUTTON6: return BTN6 "Heavy Kick";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo deadang_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &deadang_get_ctrl_name
};

const char *deadang_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Grenade";
    case IPT_JOYSTICK_UP: return "Aim Up";
    case IPT_JOYSTICK_DOWN: return "Aim Down";
    case IPT_JOYSTICK_LEFT: return "Aim Left";
    case IPT_JOYSTICK_RIGHT: return "Aim Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo redufo_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &redufo_get_ctrl_name
};

const char *redufo_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo defender_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Joystick is on left side of control panel with reverse button the the right of it so it can be hit with thumb. Fire and thrust are on right side of control panel with smart bomb, and hyperspace to the left in a 45 degree angle. In mame you can turn on cheat mode and the controls are automatically re-mapped so that the game is quite playable on a standard 8way joystick.", /* control_details */
  &defender_get_ctrl_name
};

const char *defender_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "FIRE";
    case IPT_BUTTON2: return BTN2 "THRUST";
    case IPT_BUTTON3: return BTN3 "SMART BOMB";
    case IPT_BUTTON4: return BTN4 "HYPERSPACE";
    case IPT_BUTTON5: return BTN5 "REVERSE";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo demoderb_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "OTHER: This game had a 2-way joystick as the forward/reverse shifter. Unlike Hi/Low shifters that have only two positions, the Demolition Derby shifter has a Forward, a Reverse, and a Neutral (centered, not labeled) like a 2-way (v) joystick. However, Mame emulates the shifter as buttons 1 & 2, and does not use the 2-way joystick. The start button is labeled 'Restart' on the CP. The game comes in 2 player standup and 4 player cocktail, and switches between the two with a dipswitch.", /* control_details */
  &demoderb_get_ctrl_name
};

const char *demoderb_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Forward";
    case IPT_BUTTON2: return BTN2 "Reverse";
    case IPT_DIAL: return "Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo depthch_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "", /* control_details */
  &depthch_get_ctrl_name
};

const char *depthch_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire Left Charge";
    case IPT_BUTTON2: return BTN2 "Fire Right Charge";
    case IPT_JOYSTICK_LEFT: return "Move Ship Left";
    case IPT_JOYSTICK_RIGHT: return "Move Ship Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo desertgu_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "It should be noted that this is the first game to my knowledge that uses an analog mounted gun. That would make it the great grandpa of future analog gun games like Terminator 2.", /* control_details */
  &desertgu_get_ctrl_name
};

const char *desertgu_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_LIGHTGUN_X: return "Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Right";
    case IPT_LIGHTGUN_Y: return "Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo destroyr_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This game uses a throttle control to control the speed of the ship (fast or slow) and a rotary paddle with 'push to release' to control the depth of the charge. The charge will explode at the depth setting that the Release button was pressed at, regardless of the current depth setting.", /* control_details */
  &destroyr_get_ctrl_name
};

const char *destroyr_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Release Charge";
    case IPT_BUTTON2: return BTN2 "Slow";
    case (IPT_PADDLE_V + IPT_EXTENSION): return "Set Depth of Charge Down";
    case IPT_PADDLE_V: return "Set Depth of Charge Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo devstors_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The men in tan uniforms leave guided missiles when shot. These can be picked up and when in range, a red crosshair will appear on a target and they will home on it.", /* control_details */
  &devstors_get_ctrl_name
};

const char *devstors_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_BUTTON2: return BTN2 "Weapon";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Backward";
    case IPT_JOYSTICK_UP: return "Forward";
  } /* end of switch */

  return "";
}

const struct ControlInfo devilfsh_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &devilfsh_get_ctrl_name
};

const char *devilfsh_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Drop bait";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo devzone_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &devzone_get_ctrl_name
};

const char *devzone_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_LEFT: return "Movement Left";
    case IPT_JOYSTICK_RIGHT: return "Movement Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo digdug_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &digdug_get_ctrl_name
};

const char *digdug_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Pump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo digdug2_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &digdug2_get_ctrl_name
};

const char *digdug2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Pump";
    case IPT_BUTTON2: return BTN2 "Drill";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo digger_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &digger_get_ctrl_name
};

const char *digger_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Dig";
    case IPT_BUTTON2: return BTN2 "Fill";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo dimahoo_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Although in mame the game has three buttons, and all 3 work, button 3 is redundant and mirrors button 1. On the actual game (sold in kit form only) only two buttons are used and this is confirmed on the instruction card for the game.", /* control_details */
  &dimahoo_get_ctrl_name
};

const char *dimahoo_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo otatidai_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &otatidai_get_ctrl_name
};

const char *otatidai_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo dotron_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &dotron_get_ctrl_name
};

const char *dotron_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Throw";
    case IPT_BUTTON2: return BTN2 "Deflect";
    case IPT_BUTTON3: return BTN3 "Aim Up";
    case IPT_BUTTON4: return BTN4 "Aim Down";
    case IPT_JOYSTICK_UP: return "Move Tron";
    case IPT_JOYSTICK_DOWN: return "Move Tron";
    case IPT_JOYSTICK_LEFT: return "Move Tron";
    case IPT_JOYSTICK_RIGHT: return "Move Tron";
    case IPT_DIAL: return "Aim";
    case (IPT_DIAL + IPT_EXTENSION): return "Aim";
  } /* end of switch */

  return "";
}

const struct ControlInfo dorunrun_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Something of note is that this game actually has a second button and this button is emulated in mame. The reason it isn't included here is because it was a dead button left-over from development of the game and isn't found on the control panel. The manual explains installing the controls, but neglects to mention this button, however it does show up in the service menu as 'p1 jump'.", /* control_details */
  &dorunrun_get_ctrl_name
};

const char *dorunrun_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo domino_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &domino_get_ctrl_name
};

const char *domino_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Swat";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo dominos_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &dominos_get_ctrl_name
};

const char *dominos_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo dondenmj_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &dondenmj_get_ctrl_name
};

const char *dondenmj_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo dkong_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &dkong_get_ctrl_name
};

const char *dkong_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jump";
    case IPT_JOYSTICK_LEFT: return "Run Left";
    case IPT_JOYSTICK_DOWN: return "Climb Down Ladder";
    case IPT_JOYSTICK_UP: return "Climb Up Ladder";
    case IPT_JOYSTICK_RIGHT: return "Run Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo dkong3_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &dkong3_get_ctrl_name
};

const char *dkong3_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "SPRAY";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo dkongjr_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &dkongjr_get_ctrl_name
};

const char *dkongjr_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "JUMP";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo ddragon_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "From manual: JUMP KICK:  Joystick in the direction. Push jump then kick. ELBOW: Joystick in the direction. Push jump and punch buttons together. BACK KICK: Joystick in the direction. Push jump and kick buttons together. HEAD BUTT: Joystick in the direction. (TWICE) BODY THROW: Joystick in the direction. Push jump button after catching enemy. BREAK ENEMY'S HOLD: Push jump button only.", /* control_details */
  &ddragon_get_ctrl_name
};

const char *ddragon_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Kick";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "Punch";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo ddragon3_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &ddragon3_get_ctrl_name
};

const char *ddragon3_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Punch";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "Kick";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo ddragon2_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &ddragon2_get_ctrl_name
};

const char *ddragon2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack Left";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "Attack Right";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo ddribble_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "In order to move with the ball, you must hold down the dribble button.", /* control_details */
  &ddribble_get_ctrl_name
};

const char *ddribble_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Dribble";
    case IPT_BUTTON2: return BTN2 "Shoot";
    case IPT_BUTTON3: return BTN3 "Pass";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo downtown_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This game uses SNK LS-30 rotary joysticks. In standard MAME, rotation is controlled using the dial inputs.", /* control_details */
  &downtown_get_ctrl_name
};

const char *downtown_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Punch";
    case IPT_BUTTON2: return BTN2 "Kick";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_DIAL: return "Rotate Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Rotate Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo dragrace_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The game actually uses a 360 degree steering wheel, but for obvious reasons, mame has mapped it to the vertical spinner. The numbers denote the gear position.", /* control_details */
  &dragrace_get_ctrl_name
};

const char *dragrace_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Accelerate";
    case IPT_BUTTON2: return BTN2 "1";
    case IPT_BUTTON3: return BTN3 "2";
    case IPT_BUTTON4: return BTN4 "3";
    case IPT_BUTTON5: return BTN5 "4";
    case (IPT_DIAL_V + IPT_EXTENSION): return "Down";
    case IPT_DIAL_V: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo dragngun_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This game is probably the only game that features talking guns. You heard me right, the 'drag-guns' in this game had speakers that spouted out advice during gameplay.", /* control_details */
  &dragngun_get_ctrl_name
};

const char *dragngun_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Dragon Bomb";
    case IPT_LIGHTGUN_Y: return "Up";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Right";
    case IPT_LIGHTGUN_X: return "Left";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo dspirit_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Shoot down flashing enemies and collect their eggs for mystery power (from the CP overlay).", /* control_details */
  &dspirit_get_ctrl_name
};

const char *dspirit_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_BUTTON3: return BTN3 "Unknown";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo drgnunit_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &drgnunit_get_ctrl_name
};

const char *drgnunit_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "Shield";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo ddsom_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &ddsom_get_ctrl_name
};

const char *ddsom_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "Select";
    case IPT_BUTTON4: return BTN4 "Magic";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo ddtod_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &ddtod_get_ctrl_name
};

const char *ddtod_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "Magic";
    case IPT_BUTTON4: return BTN4 "Select";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo dynamcop_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Instruction panel has moves list", /* control_details */
  &dynamcop_get_ctrl_name
};

const char *dynamcop_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Punch";
    case IPT_BUTTON2: return BTN2 "Kick";
    case IPT_BUTTON3: return BTN3 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo eswat_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &eswat_get_ctrl_name
};

const char *eswat_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "Special Weapons";
    case IPT_JOYSTICK_UP: return "Shoot Upward";
    case IPT_JOYSTICK_DOWN: return "Kneel";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo ecofghtr_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Button 1 and 3 rotate the gun around the craft so you can fire in any direction", /* control_details */
  &ecofghtr_get_ctrl_name
};

const char *ecofghtr_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Rotate CCW";
    case IPT_BUTTON2: return BTN2 "Shot";
    case IPT_BUTTON3: return BTN3 "Rotate CW";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo eggventr_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &eggventr_get_ctrl_name
};

const char *eggventr_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_LIGHTGUN_X: return "Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Right";
    case IPT_LIGHTGUN_Y: return "Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo elevator_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &elevator_get_ctrl_name
};

const char *elevator_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Jump/Kick";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Kneel";
    case IPT_JOYSTICK_UP: return "";
  } /* end of switch */

  return "";
}

const struct ControlInfo elim2_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &elim2_get_ctrl_name
};

const char *elim2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Thrust";
    case IPT_JOYSTICK_LEFT: return "Rotate Left";
    case IPT_JOYSTICK_RIGHT: return "Rotate Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo enigma2_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &enigma2_get_ctrl_name
};

const char *enigma2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Thrust";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo eprom_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The buttons are arranged in a triangle, with fire on the bottom left corner, duck on the bottom right, and jump/start on the middle top corner. The original analog stick used Hall Effect sensors instead of POTs. Due to the price (and now out of production) of the sensors, many arcade operators replaced the hall effect sensors with their equivalent POT. This game is very hard to control in mame with 8-ways or keyboards. An analog joystick, OTOH, gives the player control like the original joystick.", /* control_details */
  &eprom_get_ctrl_name
};

const char *eprom_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Jump / Start";
    case IPT_BUTTON3: return BTN3 "Duck";
    case IPT_AD_STICK_X: return "Left";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "Right";
    case IPT_AD_STICK_Y: return "Up";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo exerion_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This game has two types of Cannon. Fast Fire shoots a limited number of rapid-fire shots from the ship's center. Fire shoots double forward shots for the ship's sides. The game uses standard controls, i.e., moving the stick up causes the ship to climb.", /* control_details */
  &exerion_get_ctrl_name
};

const char *exerion_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fast Fire";
    case IPT_BUTTON2: return BTN2 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo exterm_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "OTHER: The 8-way trigger stick also can be rotated left or right. (Label 'Rotate Left', and 'Rotate Right')  The rotation is analog, while the rest of the stick is a digital 8-way trigger stick. Mame uses the DIAL type for this input. Mame by default maps the rotate left & right to the same inputs as move left and move right, and the game plays fairly well with this setup. To fire, you are supposed to move all the way to your side, press the fire button, and control the direction you shoot by rotating the trigger stick and moving it up and down. As long as you hold the fire button, you can't move away from the edge. NOTE: This entry has been modified to use a rotary optical joystick with a top fire button. This is the closest to the controls the game originally had, unfortunately a top fire rotary does not exist. You could, however, take a top fire handle and mount it into a rotary base, in theory at least. There is a cheat that lets you shoot all the time (making the 'fire/grab' button just a fire button).", /* control_details */
  &exterm_get_ctrl_name
};

const char *exterm_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire / Grap";
    case IPT_BUTTON2: return BTN2 "Pound";
    case IPT_JOYSTICK_RIGHT: return "Move Right";
    case IPT_JOYSTICK_LEFT: return "Move Left";
    case IPT_JOYSTICK_DOWN: return "Move Down";
    case IPT_JOYSTICK_UP: return "Move Up";
    case IPT_DIAL: return "Rotate Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Rotate Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo eyes_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &eyes_get_ctrl_name
};

const char *eyes_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo f1dream_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The joystick is used to guide the car around the track. Holding both Gear buttons down activates Turbo mode. Note: Directions for turn are not included because which direction the stick makes you turn depends upon which way your car is facing. It is actually quite confusing to control your car.", /* control_details */
  &f1dream_get_ctrl_name
};

const char *f1dream_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "1st Gear";
    case IPT_BUTTON2: return BTN2 "2nd Gear";
    case IPT_JOYSTICK_RIGHT: return "Turn";
    case IPT_JOYSTICK_LEFT: return "Turn";
    case IPT_JOYSTICK_DOWN: return "Turn";
    case IPT_JOYSTICK_UP: return "Turn";
  } /* end of switch */

  return "";
}

const struct ControlInfo f1en_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "This game uses formula one style shifter buttons, which are mounted behind the steering wheel.", /* control_details */
  &f1en_get_ctrl_name
};

const char *f1en_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Gear Down";
    case IPT_BUTTON2: return BTN2 "Gear Up";
    case IPT_PADDLE: return "Left";
    case (IPT_PADDLE + IPT_EXTENSION): return "Right";
    case IPT_PEDAL: return "Accelerate";
    case IPT_PEDAL2: return "Brake";
  } /* end of switch */

  return "";
}

const struct ControlInfo fantasy_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &fantasy_get_ctrl_name
};

const char *fantasy_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo sqbert_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Used a 4-way Joystick rotated 45 degrees.", /* control_details */
  &sqbert_get_ctrl_name
};

const char *sqbert_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICK_RIGHT: return "Down+Right";
    case IPT_JOYSTICK_LEFT: return "Up+Left";
    case IPT_JOYSTICK_DOWN: return "Down+Left";
    case IPT_JOYSTICK_UP: return "Up+Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo fax_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "In the mame driver, this game seems to have two sets of coin 1 and coin 2 buttons. It's unclear if this is a bug or intentional.", /* control_details */
  &fax_get_ctrl_name
};

const char *fax_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "A";
    case IPT_BUTTON2: return BTN2 "B";
    case IPT_BUTTON3: return BTN3 "C";
    case IPT_BUTTON4: return BTN4 "D";
  } /* end of switch */

  return "";
}

const struct ControlInfo fgoal_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &fgoal_get_ctrl_name
};

const char *fgoal_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_PADDLE: return "Left";
    case (IPT_PADDLE + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo fghtatck_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "It should be noted that mame includes a third button and rightly so, however, the button is an extra one not used in this game but in other games of the system. It does show up in the service menu, however.", /* control_details */
  &fghtatck_get_ctrl_name
};

const char *fghtatck_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo fvipers_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "In mame you will notice a 4th button. This is because the game runs on the model-2b boardset, which is setup generically in mame with 4 inputs.", /* control_details */
  &fvipers_get_ctrl_name
};

const char *fvipers_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Punch";
    case IPT_BUTTON2: return BTN2 "Kick";
    case IPT_BUTTON3: return BTN3 "Guard";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo finalb_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Press the weak and medium buttons at the same time for a strong punch.", /* control_details */
  &finalb_get_ctrl_name
};

const char *finalb_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Weak";
    case IPT_BUTTON2: return BTN2 "Medium Strength";
    case IPT_BUTTON3: return BTN3 "Duck";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo ffight_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "If you press both buttons at the same time, your character does a special move or breaks out of a hold. Mame and some machines had a third cheat button /* control_details */ it basically presses both buttons for you. It is included since the timing of pressing both buttons at the same time can be tight, but is disabled in mame by default.", /* control_details */
  &ffight_get_ctrl_name
};

const char *ffight_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo finalap2_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "", /* control_details */
  &finalap2_get_ctrl_name
};

const char *finalap2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "High / Low";
    case IPT_DIAL: return "Turn Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Turn Right";
    case IPT_PEDAL: return "Accelerate";
    case IPT_PEDAL2: return "Brake";
  } /* end of switch */

  return "";
}

const struct ControlInfo firetrap_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This game works exactly like crazy climber except you can shoot by pressing right on the left joystick and left on the right joystick at the same time. Some conversion kits used top-fire joysticks as this is a rather un-natural movement for firing rapidly. Because of this an auxillary input for 'fire' is included. So you can play this game with two joysticks, a joystick and a top-fire, two top-fires or whatever floats your boat.", /* control_details */
  &firetrap_get_ctrl_name
};

const char *firetrap_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICKLEFT_UP: return "Left Up";
    case IPT_JOYSTICKLEFT_DOWN: return "Left Down";
    case IPT_JOYSTICKLEFT_LEFT: return "Left Left";
    case IPT_JOYSTICKLEFT_RIGHT: return "Left Right";
    case IPT_JOYSTICKRIGHT_UP: return "Right Up";
    case IPT_JOYSTICKRIGHT_DOWN: return "Right Down";
    case IPT_JOYSTICKRIGHT_LEFT: return "Right Left";
    case IPT_JOYSTICKRIGHT_RIGHT: return "Right Right";
  } /* end of switch */

  return "";
}

#if 0
const struct ControlInfo firetrk_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "In this game the player 2 control panel is behind player 1. Yes I said behind. On a real fire truck there are two steering wheels. One is in the back of the truck and turns the read wheels independantly of the front, thus allowing for tight turns with such a long vehicle. This game is played exactly the same with player 2 controlling the rear wheel when two player mode is selected. When 1 player mode is selected, those rear controls are ignored and thus the game is much harder to play.", /* control_details */
  &firetrk_get_ctrl_name
};

const char *firetrk_get_ctrl_name(int type)
{
  switch(type)
  {
/* P2NumButtons=1 */
    case (IPT_OSD_DESCRIPTION | IPF_PLAYER2): return "360 Steering Wheel+dial+P2_BUTTON1";
    case (IPT_BUTTON1 | IPF_PLAYER2): return "Bell";
    case IPT_DIAL: return "Left (Rear Wheels)";
    case (IPT_DIAL + IPT_EXTENSION): return "Right (Rear Wheels)";
    case IPT_BUTTON1: return BTN1 "Accelerate";
    case IPT_BUTTON2: return BTN2 "Horn";
    case IPT_BUTTON3: return BTN3 "Track Select";
    case IPT_DIAL: return "Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}
#endif

const struct ControlInfo fshark_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &fshark_get_ctrl_name
};

const char *fshark_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo foodf_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Uses a Gimbal stick.", /* control_details */
  &foodf_get_ctrl_name
};

const char *foodf_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Throw";
    case IPT_AD_STICK_Y: return "Up";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "Right";
    case IPT_AD_STICK_X: return "Left";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo forgottn_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The spinners also was the fire button. The spinner rotates the direction the character shoots. The players can buy power-ups /* control_details */ when they get a shooting power-up the character gets a floating shooting platform that rotates with the player. When the spinner is not pressed and is rotated, the platform rotates around the charcter, staying relative to the direction the character is facing. When the spinner is pressed and rotated, the platform and character rotate at their own centers.", /* control_details */
  &forgottn_get_ctrl_name
};

const char *forgottn_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Push to Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_DIAL: return "Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo formatz_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "In the kit, it was optional to have the buttons mirrored on both sides of the joystick. Used 8-way leaf joysticks  Holding the laser button down gives the player one stronger shot. Holding the jump button down transforms the player between a robot and an airplane. Unlike most side-scroll shooters with only shoot straight sideways, you shoot diagonally when the joystick is pushed up or down.", /* control_details */
  &formatz_get_ctrl_name
};

const char *formatz_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Laser / Hold for Energy";
    case IPT_BUTTON2: return BTN2 "Jump Button / Hold to Transform";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo frenzy_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Sequel to Berzerk. An interesting feature of the game is that the fire button only works when the player is moving. Also, this game allows you and enemies to shoot out wall segments and move/shoot through them.", /* control_details */
  &frenzy_get_ctrl_name
};

const char *frenzy_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo frogger_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &frogger_get_ctrl_name
};

const char *frogger_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo frogs_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "It really was a three way joystick, basically a 4-way stick without a down. The button flicked out your frog's tongue. *update*    I looked into this. This game was generally hacked into an old frogger cab. The jump button was hacked into the 4way up and a tongue button was added. However mame uses a two way joystick and two buttons to emulate the hardware (which is correct input wise) so we reflect these constants in the database. As it's sorta a bootleg there isn't much point in worrying about control accuracy.", /* control_details */
  &frogs_get_ctrl_name
};

const char *frogs_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Tongue";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
  } /* end of switch */

  return "";
}

const struct ControlInfo frontlin_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This game, along with Wild Western and Tin Star, used a unique controller. The Actual game uses a '8 way push to fire' spinner. The 'spinner' actually used a cam to engage one or two of the 4 microswitches below the control panel. So if you have a real spinner then don't expect to use it with this game. MAME emulates this like a dual 8-way joystick game. This set-up works well for the original controls, but poorly for anything else. Note: Spinners and rotary joysticks can not be used in MAME for this game. In the tank stages, use grenades to enter the blue tank. Exit the tank when it is hit. Use the spinner to rotate and fire the tank turret.", /* control_details */
  &frontlin_get_ctrl_name
};

const char *frontlin_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Tank/Grenade";
    case IPT_JOYSTICKLEFT_DOWN: return "Aim Down";
    case IPT_JOYSTICKLEFT_UP: return "Aim Up";
    case IPT_JOYSTICKLEFT_LEFT: return "Aim Left";
    case IPT_JOYSTICKLEFT_RIGHT: return "Aim Right";
    case IPT_JOYSTICKRIGHT_UP: return "Up";
    case IPT_JOYSTICKRIGHT_DOWN: return "Down";
    case IPT_JOYSTICKRIGHT_LEFT: return "Left";
    case IPT_JOYSTICKRIGHT_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo futspy_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The control panel on this game improperly labeled the bomb button as fire since the top button is the primary weapon.", /* control_details */
  &futspy_get_ctrl_name
};

const char *futspy_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Fire (Bomb)";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo gloc_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "", /* control_details */
  &gloc_get_ctrl_name
};

const char *gloc_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Vulcan - Gun";
    case IPT_BUTTON2: return BTN2 "Missile";
    case IPT_BUTTON3: return BTN3 "Afterburner";
    case IPT_AD_STICK_X: return "Left";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "Right";
    case IPT_AD_STICK_Y: return "Up";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "Down";
    case IPT_AD_STICK_Z: return "Speed Up";
    case (IPT_AD_STICK_Z + IPT_EXTENSION): return "Slow Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo gijoe_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &gijoe_get_ctrl_name
};

const char *gijoe_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_BUTTON2: return BTN2 "Super Weapon";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo gground_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "It should be noted that the joystick had the simple label of 'Select Warrior / Move Player'", /* control_details */
  &gground_get_ctrl_name
};

const char *gground_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Magic Weapon";
    case IPT_BUTTON2: return BTN2 "special Weapon";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo galaga88_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This game was marketed as a conversion for Dragon Spirit, so it used an 8-way joystick, but the vertical inputs were ignored. The game has one actual action button 'Fire' located on the left and right side of the joystick. However the PCB does have three button inputs.", /* control_details */
  &galaga88_get_ctrl_name
};

const char *galaga88_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Fire";
    case IPT_BUTTON3: return BTN3 "N/A";
    case IPT_JOYSTICK_UP: return "N/A";
    case IPT_JOYSTICK_DOWN: return "N/A";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo galaga_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &galaga_get_ctrl_name
};

const char *galaga_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo galaxian_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &galaxian_get_ctrl_name
};

const char *galaxian_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_LEFT: return "Control Left";
    case IPT_JOYSTICK_RIGHT: return "Control Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo gforce2_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "Please note that none of the controls in this game have any labels. They are labeled by what they do.", /* control_details */
  &gforce2_get_ctrl_name
};

const char *gforce2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Missile";
    case IPT_AD_STICK_X: return "Left";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "Right";
    case IPT_AD_STICK_Y: return "Up";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "Down";
    case IPT_AD_STICK_Z: return "Fast";
    case (IPT_AD_STICK_Z + IPT_EXTENSION): return "Slow";
  } /* end of switch */

  return "";
}

const struct ControlInfo galxwars_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &galxwars_get_ctrl_name
};

const char *galxwars_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_LEFT: return "L";
    case IPT_JOYSTICK_RIGHT: return "R";
  } /* end of switch */

  return "";
}

const struct ControlInfo galpanic_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &galpanic_get_ctrl_name
};

const char *galpanic_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Cut";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo galpani2_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This game didn't actually label the button and in all the docs it's referred to as button 1, however it is clear what this button does. I labeled it 'cut' to avoid confusion as 'button 1' may seem like a parsing error to the average viewer. Also take note that the pcb has inputs for three physical buttons and they are emulated in mame, but only the first is used.", /* control_details */
  &galpani2_get_ctrl_name
};

const char *galpani2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Cut";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo gaplus_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &gaplus_get_ctrl_name
};

const char *gaplus_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo gauntlet_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &gauntlet_get_ctrl_name
};

const char *gauntlet_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Magic / Start";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo gaunt2_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &gaunt2_get_ctrl_name
};

const char *gaunt2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Magic / Start";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo geebee_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This is a blockout type game that is controlled by a paddle (limited turn with POT), instead of a spinner as in Arkanoid.", /* control_details */
  &geebee_get_ctrl_name
};

const char *geebee_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Serve";
    case IPT_PADDLE: return "Left";
    case (IPT_PADDLE + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo gng_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Buttons are mirrored on both sides of the joystick.", /* control_details */
  &gng_get_ctrl_name
};

const char *gng_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo ghouls_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &ghouls_get_ctrl_name
};

const char *ghouls_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo gigawing_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Normal shots are made by tapping on the 'Shot' button. If you hold it down (and you are recharged), you get a temporary 'Reflect Barrier' that reflect all the ememies' shots back at them. You don't have a max number of times to use the reflect barrier, except there is a fairly short recharge time before you can use it again. The 'Force Bomb' button is like most shooter's bomb buttons (you have limited number bombs & one bomb is stronger than a normal shot).", /* control_details */
  &gigawing_get_ctrl_name
};

const char *gigawing_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shot / Hold for Reflect Barrier";
    case IPT_BUTTON2: return BTN2 "Force Bomb";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo goldmedl_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The buttons on this game aren't labeled, which is a shame as it's quite difficult to figure out what they do. With over 20 events and each event using the buttons for a different thing, it may be impossible to play this game without an instruction card. During the attract mode, however, it shows which buttons you are supposed to press when going through an event.", /* control_details */
  &goldmedl_get_ctrl_name
};

const char *goldmedl_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Button A";
    case IPT_BUTTON2: return BTN2 "Button B";
    case IPT_BUTTON3: return BTN3 "Button C";
  } /* end of switch */

  return "";
}

const struct ControlInfo goldnaxe_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &goldnaxe_get_ctrl_name
};

const char *goldnaxe_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "Magic";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo ga2_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &ga2_get_ctrl_name
};

const char *ga2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "Magic";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo gt97_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "1 = Up Left, 2 = Up, 3 = Up Right. A = Down Left, B = Down, C = Down Right. On the control panel overlay is instruction on how to swing using those numbers and letters.", /* control_details */
  &gt97_get_ctrl_name
};

const char *gt97_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Face Left";
    case IPT_BUTTON2: return BTN2 "Face Right";
    case IPT_TRACKBALL_Y: return "Forward Swing";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Choose Club";
    case IPT_TRACKBALL_X: return "Choose Club";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Back Swing";
  } /* end of switch */

  return "";
}

const struct ControlInfo gt98_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "1 = Up Left, 2 = Up, 3 = Up Right. A = Down Left, B = Down, C = Down Right. On the control panel overlay is instruction on how to swing using those numbers and letters.", /* control_details */
  &gt98_get_ctrl_name
};

const char *gt98_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Face Left";
    case IPT_BUTTON2: return BTN2 "Face Right";
    case IPT_TRACKBALL_X: return "Choose Club";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Choose Club";
    case IPT_TRACKBALL_Y: return "Forward Swing";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Back Swing";
  } /* end of switch */

  return "";
}

const struct ControlInfo gt99_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "1 = Up Left, 2 = Up, 3 = Up Right. A = Down Left, B = Down, C = Down Right. On the control panel overlay is instruction on how to swing using those numbers and letters.", /* control_details */
  &gt99_get_ctrl_name
};

const char *gt99_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Face Left";
    case IPT_BUTTON2: return BTN2 "Face Right";
    case IPT_TRACKBALL_X: return "Choose Club";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Choose Club";
    case IPT_TRACKBALL_Y: return "Forward Swing";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Back Swing";
  } /* end of switch */

  return "";
}

const struct ControlInfo gt2k_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "1 = Up Left, 2 = Up, 3 = Up Right. A = Down Left, B = Down, C = Down Right. On the control panel overlay is instruction on how to swing using those numbers and letters.", /* control_details */
  &gt2k_get_ctrl_name
};

const char *gt2k_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Face Left";
    case IPT_BUTTON2: return BTN2 "Face Right";
    case IPT_TRACKBALL_X: return "Choose Club";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Choose Club";
    case IPT_TRACKBALL_Y: return "Forward Swing";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Back Swing";
  } /* end of switch */

  return "";
}

const struct ControlInfo gt3d_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "1 = Up Left, 2 = Up, 3 = Up Right. A = Down Left, B = Down, C = Down Right. On the control panel overlay is instruction on how to swing using those numbers and letters.", /* control_details */
  &gt3d_get_ctrl_name
};

const char *gt3d_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Face Left";
    case IPT_BUTTON2: return BTN2 "Face Right";
    case IPT_TRACKBALL_Y: return "Forward Swing";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Choose Club";
    case IPT_TRACKBALL_X: return "Choose Club";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Back Swing";
  } /* end of switch */

  return "";
}

const struct ControlInfo gtg2_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "1 = Up Left, 2 = Up, 3 = Up Right. A = Down Left, B = Down, C = Down Right. On the control panel overlay is instruction on how to swing using those numbers and letters.", /* control_details */
  &gtg2_get_ctrl_name
};

const char *gtg2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Face Left";
    case IPT_BUTTON2: return BTN2 "Face Right";
    case IPT_TRACKBALL_X: return "Choose Club";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Choose Club";
    case IPT_TRACKBALL_Y: return "Forward Swing";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Back Swing";
  } /* end of switch */

  return "";
}

const struct ControlInfo glfgreat_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "MAME lists inputs for buttons 3 and 4 but they don't do anything. Use the Shot button to enter initials.", /* control_details */
  &glfgreat_get_ctrl_name
};

const char *glfgreat_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Stance";
    case IPT_BUTTON2: return BTN2 "Shot";
    case IPT_BUTTON3: return BTN3 "N/A";
    case IPT_BUTTON4: return BTN4 "N/A";
    case IPT_JOYSTICK_UP: return "Select longer distance club";
    case IPT_JOYSTICK_DOWN: return "Select shorter distance club";
    case IPT_JOYSTICK_LEFT: return "Rotate Left";
    case IPT_JOYSTICK_RIGHT: return "Rotate Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo golgo13_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "The select and enter buttons may very well be useless in the game itself. Everything is in Japanese it's generally hard to tell with what little is know with this game. On the original game there was a scope you looked through that contained a small lcd with a closer view. In mame a 'zoom button' was hacked in. There is no telling if that was an original option or not.", /* control_details */
  &golgo13_get_ctrl_name
};

const char *golgo13_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Trigger";
    case IPT_BUTTON2: return BTN2 "Zoom In / Zoom Out";
    case IPT_BUTTON3: return BTN3 "Enter";
    case IPT_JOYSTICK_UP: return "Select Up";
    case IPT_JOYSTICK_DOWN: return "Select Down";
    case IPT_LIGHTGUN_X: return "Aim Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Aim Right";
    case IPT_LIGHTGUN_Y: return "Aim Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Aim Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo gollygho_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &gollygho_get_ctrl_name
};

const char *gollygho_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "1";
    case IPT_LIGHTGUN_X: return "Aim Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Aim Right";
    case IPT_LIGHTGUN_Y: return "Aim Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Aim Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo gondo_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Used the yellow snk LS-30 mechcanical rotatry. Rotating the joystick changes the direction the Character Weapon shoots. The Airbike Weapon always shoots straight forward. This was usually released as a kit /* control_details */ the instructions suggested mirroring the buttons on both sides of each joystick, but not all arcade operaters did this. Player1 is the blue air bike, player2 is the grey air bike.", /* control_details */
  &gondo_get_ctrl_name
};

const char *gondo_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Character Weapon";
    case IPT_BUTTON2: return BTN2 "Airbike Weapon";
    case IPT_DIAL: return "Rotate Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case (IPT_DIAL + IPT_EXTENSION): return "Rotate Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo gorf_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The alternating play is not normal. Players alternate when a player passes a level or game over, not when a life is lost like most alternating games. If you press the button before the last shot gets off the screen or hits something, that shot will disappear and you shoot a new one.", /* control_details */
  &gorf_get_ctrl_name
};

const char *gorf_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo grchamp_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "", /* control_details */
  &grchamp_get_ctrl_name
};

const char *grchamp_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_DIAL: return "Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
    case IPT_PEDAL: return "Accelerate";
  } /* end of switch */

  return "";
}

const struct ControlInfo f1gpstar_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &f1gpstar_get_ctrl_name
};

const char *f1gpstar_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Accelerate";
    case IPT_BUTTON2: return BTN2 "Brake";
    case IPT_BUTTON3: return BTN3 "Lo";
    case IPT_BUTTON4: return BTN4 "Hi";
    case (IPT_PADDLE + IPT_EXTENSION): return "Right";
    case IPT_PADDLE: return "Left";
  } /* end of switch */

  return "";
}

const struct ControlInfo gravitar_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &gravitar_get_ctrl_name
};

const char *gravitar_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Thurst";
    case IPT_BUTTON3: return BTN3 "Tractor/Shield";
    case IPT_JOYSTICK_LEFT: return "Rotate Left";
    case IPT_JOYSTICK_RIGHT: return "Rotate Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo greatgun_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The guns on this game are indeed lightguns, but they were mounted to the cabinet as they were very heavy shotguns.", /* control_details */
  &greatgun_get_ctrl_name
};

const char *greatgun_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_LIGHTGUN_X: return "Aim Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Aim Right";
    case IPT_LIGHTGUN_Y: return "Aim Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Aim Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo gberet_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &gberet_get_ctrl_name
};

const char *gberet_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Weapon";
    case IPT_BUTTON2: return BTN2 "Shoot";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo gridiron_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The trackball itself is actually labeled 'Pass & Movement Control.'  The original game had a led counter on the control panel that displayed the currently select play number. In mame this is simulated by a tiny, tiny little orange character on the bottom left of the screen. This really needs to be replaced by some artwork files to make it a little bigger and easier to understand.", /* control_details */
  &gridiron_get_ctrl_name
};

const char *gridiron_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Pass & Formation Set";
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo gridlee_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &gridlee_get_ctrl_name
};

const char *gridlee_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo guardian_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Press both kicks or punches together to perform a power punch or kick respectively.", /* control_details */
  &guardian_get_ctrl_name
};

const char *guardian_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fast Punch";
    case IPT_BUTTON2: return BTN2 "Fast Kick";
    case IPT_BUTTON3: return BTN3 "Defense";
    case IPT_BUTTON4: return BTN4 "Strong Punch";
    case IPT_BUTTON5: return BTN5 "Strong Kick";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo gwar_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Grenade button also gets you into and out of the tank. Used the SNK LS-30, 12 direction rotary, but only faces 8 directions in the game. Usually the buttons were mirrored on both sides of the joystick for a total of four physical buttons per player, but both fire buttons and both grenade buttons are wired to the same PCB input. The recommended button colors are yellow for the fire button, and black for the grenade button. To enter test mode hold down the service key (F2) during boot or reboot until grid screen /* control_details */ press service button to go to next test screen; reboot to exit. Mame's driver has an extra 13th 'direction' between 5 & 6 because it 'avoids the 'joystick error' protection in Guerilla War which happens when direction changes directly from 0x50&lt;-&gt;0x60 8 times.'", /* control_details */
  &gwar_get_ctrl_name
};

const char *gwar_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Grenade";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_DIAL: return "Rotate Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Rotate Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo gunsmoke_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Six shot directions are possible by pressing the buttons in combination - Besides the obvious primary directions, pressing Fire Right and Fire Straight would aim between Straight and Right, same for Straight and Left, and pressing Left and Right together would shoot in both directions.", /* control_details */
  &gunsmoke_get_ctrl_name
};

const char *gunsmoke_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire - Left";
    case IPT_BUTTON2: return BTN2 "Fire - Center";
    case IPT_BUTTON3: return BTN3 "Fire - Right";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo gunbird_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &gunbird_get_ctrl_name
};

const char *gunbird_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo gunbustr_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The game's descriptions are in japanese when you start the game and since the game's cpo doesn't have any labels, I did the best I could with the in-game input test.", /* control_details */
  &gunbustr_get_ctrl_name
};

const char *gunbustr_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Trigger";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_JOYSTICK_UP: return "Move Forward";
    case IPT_JOYSTICK_DOWN: return "move Backward";
    case IPT_JOYSTICK_LEFT: return "Move Left";
    case IPT_JOYSTICK_RIGHT: return "Move Right";
    case IPT_LIGHTGUN_X: return "Aim Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Aim Right";
    case IPT_LIGHTGUN_Y: return "Aim Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Aim Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo gyruss_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The joystick caused you to rotate around the exterior of the playfield.", /* control_details */
  &gyruss_get_ctrl_name
};

const char *gyruss_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo halleys_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Note that the mame driver labels button 2 as 'hyperspace' but according to the mame cpo pack and a few others sources it is the 'warp' button. If evidence is found to the contrary please feel free to correct.", /* control_details */
  &halleys_get_ctrl_name
};

const char *halleys_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Warp";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo hardyard_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "If dive is not the correct caption, please correct.", /* control_details */
  &hardyard_get_ctrl_name
};

const char *hardyard_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Pass / Jump";
    case IPT_BUTTON2: return BTN2 "Dive";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo hattrick_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &hattrick_get_ctrl_name
};

const char *hattrick_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo hcastle_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &hcastle_get_ctrl_name
};

const char *hcastle_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo hbarrel_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This cpo actually didn't have any labels. The labels were obtained by the serivce manual.", /* control_details */
  &hbarrel_get_ctrl_name
};

const char *hbarrel_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_BUTTON2: return BTN2 "Grenade";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_DIAL: return "Rotate Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Rotate Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo hiimpact_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "1 & 2 are the red team, players 3 & 4 are the blue team. If one person plays per team, he calls all the plays. If two people team up and play on the same team: On the offense, players 2 & 3 call the play and control that team's quarterback. On the defense, players 1 & 4 call the play. The action button does everything: pass, handoff, kick, punt, jump, select play. To kick or punt farther, you have to hit the action button quickly. References: CPO http://www.klov.com/game_detail.php?letter=H&game_id=8111", /* control_details */
  &hiimpact_get_ctrl_name
};

const char *hiimpact_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Action";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo hippodrm_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Like all Dataeast games of the day, this game's cpo didn't have any labels. Instead it had a gameplay insert for the bezel.", /* control_details */
  &hippodrm_get_ctrl_name
};

const char *hippodrm_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo hitme_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This game uses rather odd, non-arcade buttons.", /* control_details */
  &hitme_get_ctrl_name
};

const char *hitme_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Stand";
    case IPT_BUTTON2: return BTN2 "Hit";
    case IPT_BUTTON3: return BTN3 "Ante";
  } /* end of switch */

  return "";
}

const struct ControlInfo hitice_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This game can be converted to 2 player via a dip swtich. This game has an unused button emulated in mame. The inputs actually exists, it just doesn't do anything.", /* control_details */
  &hitice_get_ctrl_name
};

const char *hitice_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot / Check";
    case IPT_BUTTON2: return BTN2 "Pass / Save";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo holo_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "It should be noted that this game doesn\'t have labels, as it is a conversion kit for the hologram (time traveler) cabinet.", /* control_details */
  &holo_get_ctrl_name
};

const char *holo_get_ctrl_name(int type)
{
  switch(type)
  {
/* P2NumButtons=2 */
    case (IPT_OSD_DESCRIPTION | IPF_PLAYER2): return "8-way Joystick+joy8way";
    case (IPT_BUTTON1 | IPF_PLAYER2): return "Quick Tricks";
    case (IPT_BUTTON2 | IPF_PLAYER2): return "Fierce Tricks";
    case (IPT_JOYSTICK_UP | IPF_PLAYER2): return "Jump";
    case (IPT_JOYSTICK_DOWN | IPF_PLAYER2): return "Crouch";
    case (IPT_JOYSTICK_LEFT | IPF_PLAYER2): return "Forward";
    case (IPT_JOYSTICK_RIGHT | IPF_PLAYER2): return "Backward / Defense";
    case IPT_BUTTON1: return BTN1 "Quick Tricks";
    case IPT_BUTTON2: return BTN2 "Fierce Tricks";
    case IPT_JOYSTICK_UP: return "Jump";
    case IPT_JOYSTICK_DOWN: return "Crouch";
    case IPT_JOYSTICK_LEFT: return "Backward / Defend";
    case IPT_JOYSTICK_RIGHT: return "Forward";
  } /* end of switch */

  return "";
}

const struct ControlInfo hotrod_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &hotrod_get_ctrl_name
};

const char *hotrod_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_DIAL: return "Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
    case IPT_PEDAL: return "Accelerate";
  } /* end of switch */

  return "";
}

const struct ControlInfo hstennis_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Press both buttons to lob.", /* control_details */
  &hstennis_get_ctrl_name
};

const char *hstennis_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Hard";
    case IPT_BUTTON2: return BTN2 "Soft";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo housemnq_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &housemnq_get_ctrl_name
};

const char *housemnq_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo housemn2_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &housemn2_get_ctrl_name
};

const char *housemn2_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo hustle_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &hustle_get_ctrl_name
};

const char *hustle_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo hng64_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The Hyper Neo Geo 64 system was the next generation of the classic Neo Geo mvs system. This new system wasn't as popular and only had a few games released on it. They all used the same control layout and relied upon inserts to explain to the consumer what button was what. Also 99% of the games started with a 'How to Play' screen upon starting the game. Although these games don't work yet in MAME 0.141, the inputs are already hooked up, just like the original Neo Geo. It would be silly to think that these would be altered after the driver is in working order.", /* control_details */
  &hng64_get_ctrl_name
};

const char *hng64_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "A";
    case IPT_BUTTON2: return BTN2 "B";
    case IPT_BUTTON3: return BTN3 "C";
    case IPT_BUTTON4: return BTN4 "D";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo hyperspt_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This game is actually 4 players, but you alternate in teams of two.", /* control_details */
  &hyperspt_get_ctrl_name
};

const char *hyperspt_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Go (Left)";
    case IPT_BUTTON2: return BTN2 "Up";
    case IPT_BUTTON3: return BTN3 "Go (Right)";
  } /* end of switch */

  return "";
}

const struct ControlInfo irobot_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This had a funny looking CP. The joystick sat on a small panel, sticking out toward the player at about 45 degrees toward the player. The two fire buttons were mirrored, one on each side of the small panel, one panels of there own, angled sideways at about 30 degrees from vertical. The two start buttons were the Atari cones on their own panel above the small panel of the joystick. Mame has two seperate buttons emulated, but the second does not do anything. The test screen only lists one fire button, so it looks like the two physical fire buttons were wired together in the original game, connected to the PCBs as one. The original joystick was a Hall Effect joystick: an analog joystick that used magnetics to vary the resistance instead of the usual POT.", /* control_details */
  &irobot_get_ctrl_name
};

const char *irobot_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Not used";
    case IPT_AD_STICK_X: return "Left";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "Right";
    case IPT_AD_STICK_Y: return "Up";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo a47pie2_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &a47pie2_get_ctrl_name
};

const char *a47pie2_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo idhimitu_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &idhimitu_get_ctrl_name
};

const char *idhimitu_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo fromance_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &fromance_get_ctrl_name
};

const char *fromance_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo idolmj_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &idolmj_get_ctrl_name
};

const char *idolmj_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo iemoto_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &iemoto_get_ctrl_name
};

const char *iemoto_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo ikari3_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Uses an LS-30 joystick.", /* control_details */
  &ikari3_get_ctrl_name
};

const char *ikari3_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Kick";
    case IPT_BUTTON2: return BTN2 "Punch";
    case IPT_BUTTON3: return BTN3 "Jump";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_DIAL: return "Rotate Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Rotate Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo ikari_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Uses an LS-30 joystick.", /* control_details */
  &ikari_get_ctrl_name
};

const char *ikari_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Gun";
    case IPT_BUTTON2: return BTN2 "Grenade";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_DIAL: return "Rotate Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Rotate Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo imekura_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &imekura_get_ctrl_name
};

const char *imekura_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo indytemp_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Like some other Atari games, such as Road Runner & Peter Packrat, the player start buttons double as the action buttons. The original game has the Whip button mirrored on both sides of the joystick. The left side Whip button is also 1 player start button /* control_details */ mame emulates this as two buttons, button1 and start1. The right side Whip button is also the 2 players start button; mame emulates this as only the 'start2' button, even though pressing mame's start2 button also whips the whip. Also, the buttons are used to select the number of lives the player has: the right selects the normal 3 lives (1 credit), the left selects 7 lives (for 2 credits).", /* control_details */
  &indytemp_get_ctrl_name
};

const char *indytemp_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Whip";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo inferno_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The game actually uses a 4 way ball-top and a 4-way trigger stick. Both are rotated on a 45 degree angle al-la qbert. The 'fire' stick doesn't actually shoot, rather it aims your gun. The fire button must be used to actually fire.", /* control_details */
  &inferno_get_ctrl_name
};

const char *inferno_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICKLEFT_UP: return "Move Up+Right";
    case IPT_JOYSTICKLEFT_DOWN: return "Move Down+Left";
    case IPT_JOYSTICKLEFT_LEFT: return "Move Left+Up";
    case IPT_JOYSTICKLEFT_RIGHT: return "Move Right+Down";
    case IPT_JOYSTICKRIGHT_UP: return "Fire Up+Right";
    case IPT_JOYSTICKRIGHT_DOWN: return "Fire Down+Left";
    case IPT_JOYSTICKRIGHT_LEFT: return "Fire Left+Up";
    case IPT_JOYSTICKRIGHT_RIGHT: return "Fire Right+Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo invrvnge_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &invrvnge_get_ctrl_name
};

const char *invrvnge_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_LEFT: return "Move Left";
    case IPT_JOYSTICK_RIGHT: return "Move Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo invho2_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This is a two in one cabinet with two games in it. The control panel is split in half.... on the left is two directional buttons (Left,Right) and a button (Fire). These inputs are actually wired to the controls on the right side of the panel. These controls are a 4 way jostick and a button (gas). This seems like a huge waste of control space, but I suppose at the time, generic panels seemed silly.", /* control_details */
  &invho2_get_ctrl_name
};

const char *invho2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire / Gas";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo offroad_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "There are no Start buttons /* control_details */ the Nitro buttons double as the Start buttons. You also use the the Nitro buttons to select improvements on your car. 'Player 1' is the Red car, 'Player 2' is the Yellow car, 'Player 3' is the Blue car. The game refers the players as 'Red Player', 'Yellow Player', 'Blue Player', not 'Player 1', etc. There are also two player cabs of this game, but all they did was remove the Yellow car's inputs, including the coin inputs. There are no dipswitches to change. So on these cabs, the 'second player' is the blue car, but all the inputs are connected to what is still 'Player 3' in mame. To eneter service mode, hold down Blue Nitro button and press service button. The menus are scrolled down by pressing the Red Nitro button, and selected by pressing the Blue Nitro button.", /* control_details */
  &offroad_get_ctrl_name
};

const char *offroad_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Nitro / Start";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
    case IPT_DIAL: return "Left";
    case IPT_PEDAL: return "Accelerate";
  } /* end of switch */

  return "";
}

const struct ControlInfo offroadt_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "There are no Start buttons /* control_details */ the Nitro buttons double as the Start buttons. You also use the the Nitro buttons to select improvements on your car. There are two Nitro buttons for each player, mirrored on each side of the steering wheel, but they are wired together as one button in the harness. 'Player 1' is the Red car or 'Red Player', 'Player 2' is the Yellow car or 'Yellow Player', and 'Player 3' is the Blue car or 'Blue Player'. The game and manual refer to the players with their color, not a number. Might be because of next point. There are also two player cabs of this game, but all they did was remove the Yellow car's inputs, including the coin inputs. There are no dipswitches to change. So on these cabs, the 'second player' is the blue car, but all the inputs are connected to what is still 'Player 3' in mame. This was usually done not because of blue being a more popular color, but the arcade operators need the blue nitro button to change game settings. To eneter service mode, hold down Blue Nitro button and press service button. The menus are scrolled down by pressing the Red Nitro button, and selected by pressing the Blue Nitro button. This is basically the same as the original Ironman Ivan Stewart's Super Off Road. However, it has new tracks, and the players can choose between driving a dune buggy or the original truck. The control is exactly the same.", /* control_details */
  &offroadt_get_ctrl_name
};

const char *offroadt_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Nitro / Start";
    case IPT_DIAL: return "Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
    case IPT_PEDAL: return "On";
  } /* end of switch */

  return "";
}

const struct ControlInfo jackal_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &jackal_get_ctrl_name
};

const char *jackal_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Machine Gun";
    case IPT_BUTTON2: return BTN2 "Hand Grenade";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo jailbrek_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &jailbrek_get_ctrl_name
};

const char *jailbrek_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_BUTTON2: return BTN2 "Select";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

#if 0
const struct ControlInfo teamqb_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "The start button is labeled 'Join'. Player 1 is 'left QB', player 2 is 'left HB', and are on the same team. Player 3 is 'right QB', player 4 is 'right HB', and are on the same team. The CP has the players from left to right: LHB, LQB, RQB, RHB, or if you go by numbers, 2, 1, 3, 4. Only the quarterbacks have springsticks (to control throwing & kicking), but all players have a normal 8-way stick to control the player's movements. The action button does different things, depending on what the 8 way stick is doing. Since the 2 & 4 players don't have a spring stick, they often have the action button mirrored on both sides of the joystick. The analog joystick 'springsticks' were held all the way up by the spring, with free movement sideways. The farther back you pulled the springstick, the farther/faster you would throw or kick the ball when you released the stick. The label 'short' is positioned just below the springstick, below which is 'long'. Along with the words, part of the label is a fat pointed line or arrow, pointing down away from the springstick.", /* control_details */
  &teamqb_get_ctrl_name
};

const char *teamqb_get_ctrl_name(int type)
{
  switch(type)
  {
/* P4NumButtons=1 */
    case (IPT_OSD_DESCRIPTION | IPF_PLAYER4): return "8-way Joystick+joy8way";
    case (IPT_BUTTON1 | IPF_PLAYER4): return "Action";
/* P3NumButtons=1 */
    case (IPT_OSD_DESCRIPTION | IPF_PLAYER3): return "8-way Joystick+joy8way|Baseball Pitcher+stick";
    case (IPT_BUTTON1 | IPF_PLAYER3): return "Action";
    case (IPT_JOYSTICK_UP | IPF_PLAYER3): return "Up";
    case (IPT_JOYSTICK_DOWN | IPF_PLAYER3): return "Down";
    case (IPT_JOYSTICK_LEFT | IPF_PLAYER3): return "Left";
    case (IPT_JOYSTICK_RIGHT | IPF_PLAYER3): return "Right";
    case (IPT_AD_STICK_X | IPF_PLAYER3): return "Aim Left";
    case ((IPT_AD_STICK_X + IPT_EXTENSION) | IPF_PLAYER3): return "Aim Right"
    case (IPT_AD_STICK_Y | IPF_PLAYER3): return "Throw / Kick"
    case ((IPT_AD_STICK_Y + IPT_EXTENSION) | IPF_PLAYER3): return "Short / Long";
/* P2NumButtons=1 */
    case (IPT_OSD_DESCRIPTION | IPF_PLAYER2): return "8-way Joystick+joy8way";
    case (IPT_BUTTON1 | IPF_PLAYER2): return "Action";
    case (IPT_JOYSTICK_UP | IPF_PLAYER2): return "Up";
    case (IPT_JOYSTICK_DOWN | IPF_PLAYER2): return "Down";
    case (IPT_JOYSTICK_LEFT | IPF_PLAYER2): return "Left";
    case (IPT_JOYSTICK_RIGHT | IPF_PLAYER2): return "Right";
    case IPT_BUTTON1: return BTN1 "Action";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_AD_STICK_X: return "Aim Left";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "Aim Right";
    case IPT_AD_STICK_Y: return "Throw / Kick";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "Short / Long";
/*  case (IPT_JOYSTICK_UP | IPF_PLAYER0): return "Up";
    case (IPT_JOYSTICK_DOWN | IPF_PLAYER0): return "Down";
    case (IPT_JOYSTICK_LEFT | IPF_PLAYER0): return "Left";
    case (IPT_JOYSTICK_RIGHT | IPF_PLAYER0): return "Right";*/
  } /* end of switch */

  return "";
}
#endif

const struct ControlInfo jantouki_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &jantouki_get_ctrl_name
};

const char *jantouki_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo journey_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This is five games in one, plus a bonus level. The five games all center around a musician (from the band Journey) getting to his instrument, and then getting back to the spaceship. The blast button is not used until the player retrieves his musical instrument. The blast button is mirrored on both sides of the centered joystick.", /* control_details */
  &journey_get_ctrl_name
};

const char *journey_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Blast";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo joust_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &joust_get_ctrl_name
};

const char *joust_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Flap";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo joust2_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "", /* control_details */
  &joust2_get_ctrl_name
};

const char *joust2_get_ctrl_name(int type)
{
  switch(type)
  {
/* P2NumButtons=2 */
    case (IPT_OSD_DESCRIPTION | IPF_PLAYER2): return "2-way Joystick (Horizontal)+joy2way";
    case (IPT_BUTTON1 | IPF_PLAYER2): return "Flap";
    case (IPT_BUTTON2 | IPF_PLAYER2): return "Start Player 2 / Transform";
    case (IPT_JOYSTICK_LEFT | IPF_PLAYER2): return "Left";
    case (IPT_JOYSTICK_RIGHT | IPF_PLAYER2): return "Right";
    case IPT_BUTTON1: return BTN1 "Flap";
    case IPT_BUTTON2: return BTN2 "Start Player 1 / Transform";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo joyfulr_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The original cpo simply had the two joysticks labeled 'car control' and 'hand control' respectively. It may not be apparent from playing, but the goal of this game is to navigate the car with the left stick, while grabbing things with the right.", /* control_details */
  &joyfulr_get_ctrl_name
};

const char *joyfulr_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICKLEFT_UP: return "Car Up";
    case IPT_JOYSTICKLEFT_DOWN: return "Car Down";
    case IPT_JOYSTICKLEFT_LEFT: return "Car Left";
    case IPT_JOYSTICKLEFT_RIGHT: return "Car Right";
    case IPT_JOYSTICKRIGHT_UP: return "Hand Up";
    case IPT_JOYSTICKRIGHT_DOWN: return "Hand Down";
    case IPT_JOYSTICKRIGHT_LEFT: return "Hand Left";
    case IPT_JOYSTICKRIGHT_RIGHT: return "Hand Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo jrpacman_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &jrpacman_get_ctrl_name
};

const char *jrpacman_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo jumpbug_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &jumpbug_get_ctrl_name
};

const char *jumpbug_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo junglek_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &junglek_get_ctrl_name
};

const char *junglek_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jump / Knife";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo jungler_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &jungler_get_ctrl_name
};

const char *jungler_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo jpark_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Although the control is definately a gun, the physical control looks nothing like a gun. It looks like a pistol-grip analog stick.", /* control_details */
  &jpark_get_ctrl_name
};

const char *jpark_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_LIGHTGUN_X: return "Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Right";
    case IPT_LIGHTGUN_Y: return "Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo kageki_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &kageki_get_ctrl_name
};

const char *kageki_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jab";
    case IPT_BUTTON2: return BTN2 "Punch";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo kanatuen_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &kanatuen_get_ctrl_name
};

const char *kanatuen_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo kangaroo_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Diagonals were labelled 'Super Leap'.", /* control_details */
  &kangaroo_get_ctrl_name
};

const char *kangaroo_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Punch";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo kaos_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Panel had symmetric layout with a jump button either side of the joy, but wired back to the same input.", /* control_details */
  &kaos_get_ctrl_name
};

const char *kaos_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jump";
    case IPT_BUTTON2: return BTN2 "??";
    case IPT_BUTTON3: return BTN3 "??";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo kchamp_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This game is the very first \'street fighter\' style game. The controls on it are a tad odd. Instead of a joystick and an array of buttons, you have two joysticks. These joysticks don\'t have any labels and merely have arrow directions printed on the overlay. The left joystick controls movement while the right determines the type of attack. Different attack directions while in different positions perform different moves. Luckily, the game tutors you on moves during the first round. It should be noted that this game comes in one and two player versions.", /* control_details */
  &kchamp_get_ctrl_name
};

const char *kchamp_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICKLEFT_UP: return "Up";
    case IPT_JOYSTICKLEFT_DOWN: return "Down";
    case IPT_JOYSTICKLEFT_LEFT: return "Left";
    case IPT_JOYSTICKLEFT_RIGHT: return "Right";
    case IPT_JOYSTICKRIGHT_UP: return "Attack Up";
    case IPT_JOYSTICKRIGHT_DOWN: return "Attack Down";
    case IPT_JOYSTICKRIGHT_LEFT: return "Attack Left";
    case IPT_JOYSTICKRIGHT_RIGHT: return "Attack Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo karnov_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The option button actives whatever items you have collected.", /* control_details */
  &karnov_get_ctrl_name
};

const char *karnov_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "Option";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo kick_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Teh roller on this game is made from a trackball ball, but this is not uncommon.", /* control_details */
  &kick_get_ctrl_name
};

const char *kick_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Press to Kick";
    case IPT_DIAL: return "Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo kicker_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Game used dipswitch for single or dual control layout, still alternating play. Mame uses single control layout.", /* control_details */
  &kicker_get_ctrl_name
};

const char *kicker_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Kick";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo mayumi_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mayumi_get_ctrl_name
};

const char *mayumi_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo killcom_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The buttons actually have a global label 'laser fire' and each individual button has a sub label of 'up,' 'down,' and 'left.'", /* control_details */
  &killcom_get_ctrl_name
};

const char *killcom_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire Left";
    case IPT_BUTTON2: return BTN2 "Fire Up";
    case IPT_BUTTON3: return BTN3 "Fire Right";
    case IPT_BUTTON4: return BTN4 "Hyperspace";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo kinst_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &kinst_get_ctrl_name
};

const char *kinst_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Quick (High Attack)";
    case IPT_BUTTON2: return BTN2 "Medium (High Attack)";
    case IPT_BUTTON3: return BTN3 "Fierce (High Attack)";
    case IPT_BUTTON4: return BTN4 "Quick (Low Attack)";
    case IPT_BUTTON5: return BTN5 "Medium (Low Attack)";
    case IPT_BUTTON6: return BTN6 "Fierce (Low Attack)";
    case IPT_JOYSTICK_UP: return "Jump";
    case IPT_JOYSTICK_DOWN: return "Duck";
    case IPT_JOYSTICK_LEFT: return "Move Left";
    case IPT_JOYSTICK_RIGHT: return "Move Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo kinst2_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &kinst2_get_ctrl_name
};

const char *kinst2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Quick (High Attack)";
    case IPT_BUTTON2: return BTN2 "Medium (High Attack)";
    case IPT_BUTTON3: return BTN3 "Fierce (High Attack)";
    case IPT_BUTTON4: return BTN4 "Quick (Low Attack)";
    case IPT_BUTTON5: return BTN5 "Medium (Low Attack)";
    case IPT_BUTTON6: return BTN6 "Fierce (Low Attack)";
    case IPT_JOYSTICK_UP: return "Jump";
    case IPT_JOYSTICK_DOWN: return "Duck";
    case IPT_JOYSTICK_LEFT: return "Move Left";
    case IPT_JOYSTICK_RIGHT: return "Move Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo kingball_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Galaga-like game, except you can be hit without lose a life!  Instead, you lose a life when the king you\'re protecting is lifted all the way to the top.", /* control_details */
  &kingball_get_ctrl_name
};

const char *kingball_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo kingofb_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This game lacks any labels, even in the manual. The labels reflect the function.", /* control_details */
  &kingofb_get_ctrl_name
};

const char *kingofb_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Punch";
    case IPT_BUTTON2: return BTN2 "Uppercut";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo klax_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &klax_get_ctrl_name
};

const char *klax_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Start / Flip";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo knights_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &knights_get_ctrl_name
};

const char *knights_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo konamigt_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "", /* control_details */
  &konamigt_get_ctrl_name
};

const char *konamigt_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Accelerate";
    case IPT_BUTTON2: return BTN2 "Brake";
    case IPT_BUTTON3: return BTN3 "High / Low";
    case IPT_DIAL: return "Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo kroozr_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "OTHER: Mame's driver (incorrectly) emulates this as an 8way trigger stick (so I included that). However, the real game used an analog trigger joystick (so I put other). The A/D circuit in part of the joystick assembly, instead of on the main PCB or daughter board like most analog joysticks /* control_details */ and the connection had 8 pins per axis. The joystick handle looked a lot like (if not exactly the same as) a tron handle. The spinner was also a push down button, much like a Forgotten Worlds spinner.", /* control_details */
  &kroozr_get_ctrl_name
};

const char *kroozr_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Zap!";
    case IPT_BUTTON2: return BTN2 "Shield";
    case IPT_JOYSTICK_UP: return "Krooz Up";
    case IPT_JOYSTICK_DOWN: return "Krooz Down";
    case IPT_JOYSTICK_LEFT: return "Krooz Left";
    case IPT_JOYSTICK_RIGHT: return "Krooz Right";
    case IPT_DIAL: return "Aim Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Aim Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo kram_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The joystick is labeled 'Kram Kontrol'", /* control_details */
  &kram_get_ctrl_name
};

const char *kram_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Wall";
    case IPT_BUTTON2: return BTN2 "Breakout";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo krull_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The game actually uses icons and doesn't have any labels.", /* control_details */
  &krull_get_ctrl_name
};

const char *krull_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICKLEFT_UP: return "Up";
    case IPT_JOYSTICKLEFT_DOWN: return "Down";
    case IPT_JOYSTICKLEFT_LEFT: return "Left";
    case IPT_JOYSTICKLEFT_RIGHT: return "Right";
    case IPT_JOYSTICKRIGHT_UP: return "Fire Up";
    case IPT_JOYSTICKRIGHT_DOWN: return "Fire Down";
    case IPT_JOYSTICKRIGHT_LEFT: return "Fire Left";
    case IPT_JOYSTICKRIGHT_RIGHT: return "Fire Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo kungfum_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &kungfum_get_ctrl_name
};

const char *kungfum_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Kick";
    case IPT_BUTTON2: return BTN2 "Punch";
    case IPT_JOYSTICK_UP: return "Jump";
    case IPT_JOYSTICK_DOWN: return "Stoop Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo kurikint_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Note that the original cpo doesn't have labels for the joystick, this is simply what it does. Also not there are two jumps. Pressing up is NOT the same as pressing the dedicated jump button.", /* control_details */
  &kurikint_get_ctrl_name
};

const char *kurikint_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Punch / Kick";
    case IPT_BUTTON2: return BTN2 "Jump (higher)";
    case IPT_JOYSTICK_UP: return "Jump";
    case IPT_JOYSTICK_DOWN: return "Duck";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo ladybug_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Although mame has 2 buttons mapped, it's merely a glitch caused by using the input template of a similar game. The actual game only has a joystick.", /* control_details */
  &ladybug_get_ctrl_name
};

const char *ladybug_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo lagunar_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "Note that the shifter button is mapped to button 1 in Mame, which could cause conflicts with the pedal.", /* control_details */
  &lagunar_get_ctrl_name
};

const char *lagunar_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "High / Low";
    case IPT_PADDLE: return "Left";
    case (IPT_PADDLE + IPT_EXTENSION): return "Right";
    case IPT_PEDAL: return "Accelerate";
  } /* end of switch */

  return "";
}

const struct ControlInfo lghost_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Player 3 seems to have an extra input in mame. It won't hurt anything though.", /* control_details */
  &lghost_get_ctrl_name
};

const char *lghost_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Laser Gun";
    case IPT_BUTTON2: return BTN2 "Special Weapon";
    case IPT_LIGHTGUN_X: return "Aim Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Aim Right";
    case IPT_LIGHTGUN_Y: return "Aim Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Aim Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo lastduel_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Button 1: Attack  Button 2: Rolling Attack (Stages 1, 3, and 6 when airplane), Jump (Stages 2, 4, and 5 when car), Surface Attack (Stages 2, 4, and 5 when 2 player mode and both players in airplanes). 2nd player can join during single player game.", /* control_details */
  &lastduel_get_ctrl_name
};

const char *lastduel_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Button 1";
    case IPT_BUTTON2: return BTN2 "Button 2";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
  } /* end of switch */

  return "";
}

const struct ControlInfo lethalen_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &lethalen_get_ctrl_name
};

const char *lethalen_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_LIGHTGUN_X: return "Aim Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Aim Right";
    case IPT_LIGHTGUN_Y: return "Aim Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Aim Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo lethalj_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &lethalj_get_ctrl_name
};

const char *lethalj_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_LIGHTGUN_X: return "Aim Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Aim Right";
    case IPT_LIGHTGUN_Y: return "Aim Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Aim Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo liberatr_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &liberatr_get_ctrl_name
};

const char *liberatr_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Shield";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_X: return "Left";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo lnc_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &lnc_get_ctrl_name
};

const char *lnc_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Lock";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo lockon_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The two machine gun triggers are universally labeled and have the same function, despite the fact that they have seperate inputs. The other two buttons are the left and right thumb buttons respectively.", /* control_details */
  &lockon_get_ctrl_name
};

const char *lockon_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Machine Gun Fire (1)";
    case IPT_BUTTON2: return BTN2 "Machine Gun Fire (2)";
    case IPT_BUTTON3: return BTN3 "Hover Aircraft";
    case IPT_BUTTON4: return BTN4 "Lock-On Missiles";
    case IPT_AD_STICK_X: return "Left";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "Right";
    case IPT_AD_STICK_Y: return "Up";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo locomotn_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &locomotn_get_ctrl_name
};

const char *locomotn_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Speed";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo ldrun_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &ldrun_get_ctrl_name
};

const char *ldrun_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Dig Left";
    case IPT_BUTTON2: return BTN2 "Dig Right";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo looping_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &looping_get_ctrl_name
};

const char *looping_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Accelerator";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo losttomb_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &losttomb_get_ctrl_name
};

const char *losttomb_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Whip";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo janjans1_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &janjans1_get_ctrl_name
};

const char *janjans1_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo llander_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The original used a large handle connected to a potentiometer for Thrust control. The select game button is actually player 2 start. so to toggle through games press p2 start and then p1 start when you are ready to play.", /* control_details */
  &llander_get_ctrl_name
};

const char *llander_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Abort";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_PADDLE_V: return "Increase Thrust";
    case (IPT_PADDLE_V + IPT_EXTENSION): return "Decrease Thrust";
  } /* end of switch */

  return "";
}

const struct ControlInfo lrescue_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &lrescue_get_ctrl_name
};

const char *lrescue_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo lupin3_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "That isn't a typo, the button is actually called 'Magic Button.'", /* control_details */
  &lupin3_get_ctrl_name
};

const char *lupin3_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Magic Button";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo m4_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This game actually uses a two-way, top-fire lever, which is quite rare.", /* control_details */
  &m4_get_ctrl_name
};

const char *m4_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Reload";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo mplanets_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &mplanets_get_ctrl_name
};

const char *mplanets_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_DIAL: return "Rotate Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Rotate Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo msword_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &msword_get_ctrl_name
};

const char *msword_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo magspot_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The 'L' and 'R' labels are indeed accurate. The original cpo used those to abbreviate 'left' and 'right'.", /* control_details */
  &magspot_get_ctrl_name
};

const char *magspot_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_LEFT: return "L";
    case IPT_JOYSTICK_RIGHT: return "R";
  } /* end of switch */

  return "";
}

const struct ControlInfo akiss_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &akiss_get_ctrl_name
};

const char *akiss_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mjangels_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mjangels_get_ctrl_name
};

const char *mjangels_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo bananadr_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &bananadr_get_ctrl_name
};

const char *bananadr_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mjcamera_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mjcamera_get_ctrl_name
};

const char *mjcamera_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mcnpshnt_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mcnpshnt_get_ctrl_name
};

const char *mcnpshnt_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo chinmoku_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &chinmoku_get_ctrl_name
};

const char *chinmoku_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo cmehyou_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &cmehyou_get_ctrl_name
};

const char *cmehyou_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mjclinic_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mjclinic_get_ctrl_name
};

const char *mjclinic_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo club90s_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &club90s_get_ctrl_name
};

const char *club90s_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo daiyogen_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &daiyogen_get_ctrl_name
};

const char *daiyogen_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mjderngr_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mjderngr_get_ctrl_name
};

const char *mjderngr_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mjdialq2_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mjdialq2_get_ctrl_name
};

const char *mjdialq2_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mjdiplob_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mjdiplob_get_ctrl_name
};

const char *mjdiplob_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo dokyusei_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &dokyusei_get_ctrl_name
};

const char *dokyusei_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo dokyusp_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &dokyusp_get_ctrl_name
};

const char *dokyusp_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mjelctrn_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mjelctrn_get_ctrl_name
};

const char *mjelctrn_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mjegolf_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mjegolf_get_ctrl_name
};

const char *mjegolf_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mjfocus_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mjfocus_get_ctrl_name
};

const char *mjfocus_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mjfriday_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mjfriday_get_ctrl_name
};

const char *mjfriday_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mfunclub_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mfunclub_get_ctrl_name
};

const char *mfunclub_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mgmen89_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mgmen89_get_ctrl_name
};

const char *mgmen89_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mgakuen_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mgakuen_get_ctrl_name
};

const char *mgakuen_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mgakuen2_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mgakuen2_get_ctrl_name
};

const char *mgakuen2_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo gakusai_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &gakusai_get_ctrl_name
};

const char *gakusai_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo gakusai2_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &gakusai2_get_ctrl_name
};

const char *gakusai2_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo gal10ren_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &gal10ren_get_ctrl_name
};

const char *gal10ren_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo galkaika_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &galkaika_get_ctrl_name
};

const char *galkaika_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo galkoku_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &galkoku_get_ctrl_name
};

const char *galkoku_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mjgottsu_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mjgottsu_get_ctrl_name
};

const char *mjgottsu_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo hanamomo_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &hanamomo_get_ctrl_name
};

const char *hanamomo_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mhgaiden_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mhgaiden_get_ctrl_name
};

const char *mhgaiden_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mjhokite_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mjhokite_get_ctrl_name
};

const char *mjhokite_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo hourouki_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &hourouki_get_ctrl_name
};

const char *hourouki_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo hypreact_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &hypreact_get_ctrl_name
};

const char *hypreact_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo hypreac2_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &hypreac2_get_ctrl_name
};

const char *hypreac2_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mjikaga_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mjikaga_get_ctrl_name
};

const char *mjikaga_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo janbari_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &janbari_get_ctrl_name
};

const char *janbari_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mjlstory_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mjlstory_get_ctrl_name
};

const char *mjlstory_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo jogakuen_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &jogakuen_get_ctrl_name
};

const char *jogakuen_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo kaguya_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &kaguya_get_ctrl_name
};

const char *kaguya_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mkeibaou_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mkeibaou_get_ctrl_name
};

const char *mkeibaou_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mjkinjas_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mjkinjas_get_ctrl_name
};

const char *mjkinjas_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo koinomp_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &koinomp_get_ctrl_name
};

const char *koinomp_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mjkoiura_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mjkoiura_get_ctrl_name
};

const char *mjkoiura_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mjkojink_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mjkojink_get_ctrl_name
};

const char *mjkojink_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mjkjidai_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mjkjidai_get_ctrl_name
};

const char *mjkjidai_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mjlaman_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mjlaman_get_ctrl_name
};

const char *mjlaman_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo lemnangl_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &lemnangl_get_ctrl_name
};

const char *lemnangl_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mjnanpas_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mjnanpas_get_ctrl_name
};

const char *mjnanpas_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mjnatsu_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mjnatsu_get_ctrl_name
};

const char *mjnatsu_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo ntopstar_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &ntopstar_get_ctrl_name
};

const char *ntopstar_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo neruton_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &neruton_get_ctrl_name
};

const char *neruton_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo patimono_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &patimono_get_ctrl_name
};

const char *patimono_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo pstadium_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &pstadium_get_ctrl_name
};

const char *pstadium_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo ponchin_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &ponchin_get_ctrl_name
};

const char *ponchin_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mjnquest_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mjnquest_get_ctrl_name
};

const char *mjnquest_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo renaiclb_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &renaiclb_get_ctrl_name
};

const char *renaiclb_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mrokumei_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mrokumei_get_ctrl_name
};

const char *mrokumei_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo sailorws_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &sailorws_get_ctrl_name
};

const char *sailorws_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo msjiken_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &msjiken_get_ctrl_name
};

const char *msjiken_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mscoutm_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mscoutm_get_ctrl_name
};

const char *mscoutm_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mjsikaku_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mjsikaku_get_ctrl_name
};

const char *mjsikaku_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mjsister_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mjsister_get_ctrl_name
};

const char *mjsister_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo majs101b_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &majs101b_get_ctrl_name
};

const char *majs101b_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mladyhtr_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mladyhtr_get_ctrl_name
};

const char *mladyhtr_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo triplew1_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &triplew1_get_ctrl_name
};

const char *triplew1_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo triplew2_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &triplew2_get_ctrl_name
};

const char *triplew2_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo uchuuai_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &uchuuai_get_ctrl_name
};

const char *uchuuai_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mjuraden_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mjuraden_get_ctrl_name
};

const char *mjuraden_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo vanilla_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &vanilla_get_ctrl_name
};

const char *vanilla_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo vitaminc_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &vitaminc_get_ctrl_name
};

const char *vitaminc_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo yarunara_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &yarunara_get_ctrl_name
};

const char *yarunara_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mjyuugi_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mjyuugi_get_ctrl_name
};

const char *mjyuugi_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mjyougo_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mjyougo_get_ctrl_name
};

const char *mjyougo_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo korinai_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &korinai_get_ctrl_name
};

const char *korinai_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mhavoc_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &mhavoc_get_ctrl_name
};

const char *mhavoc_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire/Jump";
    case IPT_BUTTON2: return BTN2 "Shield";
    case (IPT_DIAL + IPT_EXTENSION): return "Move Right";
    case IPT_DIAL: return "Move Left";
  } /* end of switch */

  return "";
}

const struct ControlInfo maniach_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &maniach_get_ctrl_name
};

const char *maniach_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Punch";
    case IPT_BUTTON2: return BTN2 "Kick";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo mappy_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &mappy_get_ctrl_name
};

const char *mappy_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Door Open / Close";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo marble_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &marble_get_ctrl_name
};

const char *marble_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo mario_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &mario_get_ctrl_name
};

const char *mario_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jump";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo mars_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &mars_get_ctrl_name
};

const char *mars_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICKLEFT_UP: return "Up";
    case IPT_JOYSTICKLEFT_DOWN: return "Down";
    case IPT_JOYSTICKLEFT_LEFT: return "Left";
    case IPT_JOYSTICKLEFT_RIGHT: return "Right";
    case IPT_JOYSTICKRIGHT_UP: return "Fire Up";
    case IPT_JOYSTICKRIGHT_DOWN: return "Fire Down";
    case IPT_JOYSTICKRIGHT_LEFT: return "Fire Left";
    case IPT_JOYSTICKRIGHT_RIGHT: return "Fire Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo mmatrix_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &mmatrix_get_ctrl_name
};

const char *mmatrix_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo msh_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "As with all fighters, the actions for the joystick are reversed when you flip over your opponent to the opposite side of the screen. As with all capcom titles the top row of buttons is actually the first three instead of the last.", /* control_details */
  &msh_get_ctrl_name
};

const char *msh_get_ctrl_name(int type)
{
  switch(type)
  {
/* P2NumButtons=6 */
    case (IPT_OSD_DESCRIPTION | IPF_PLAYER2): return "8-way Joystick+joy8way";
    case (IPT_BUTTON1 | IPF_PLAYER2): return "Jab Punch";
    case (IPT_BUTTON2 | IPF_PLAYER2): return "Strong Punch";
    case (IPT_BUTTON3 | IPF_PLAYER2): return "Fierce Punch";
    case (IPT_BUTTON4 | IPF_PLAYER2): return "Short Kick";
    case (IPT_BUTTON5 | IPF_PLAYER2): return "Forward Kick";
    case (IPT_BUTTON6 | IPF_PLAYER2): return "Roundhouse Kick";
    case (IPT_JOYSTICK_UP | IPF_PLAYER2): return "Jump";
    case (IPT_JOYSTICK_DOWN | IPF_PLAYER2): return "Duck";
    case (IPT_JOYSTICK_LEFT | IPF_PLAYER2): return "Forward";
    case (IPT_JOYSTICK_RIGHT | IPF_PLAYER2): return "Back / Defense";
    case IPT_BUTTON1: return BTN1 "Jab Punch";
    case IPT_BUTTON2: return BTN2 "Strong Punch";
    case IPT_BUTTON3: return BTN3 "Fierce Punch";
    case IPT_BUTTON4: return BTN4 "Short Kick";
    case IPT_BUTTON5: return BTN5 "Forward Kick";
    case IPT_BUTTON6: return BTN6 "Roundhouse Kick";
    case IPT_JOYSTICK_UP: return "Jump";
    case IPT_JOYSTICK_DOWN: return "Duck";
    case IPT_JOYSTICK_LEFT: return "Back  / Defense";
    case IPT_JOYSTICK_RIGHT: return "Forward";
  } /* end of switch */

  return "";
}

const struct ControlInfo mshvsf_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &mshvsf_get_ctrl_name
};

const char *mshvsf_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Punch - Jab ";
    case IPT_BUTTON2: return BTN2 "Punch - Strong";
    case IPT_BUTTON3: return BTN3 "Punch - Fierce";
    case IPT_BUTTON4: return BTN4 "Kick - Short";
    case IPT_BUTTON5: return BTN5 "Kick - Forward";
    case IPT_BUTTON6: return BTN6 "Kick - Roundhouse";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo mvsc_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The original control panels had the punch buttons on the top row of thee and the kick buttons on the bottom row. ame maps the punch buttons 1 - 3 and the kick buttons 4 - 6. This can be backwards for people. Mame devs have stood by this because of the jamma locations of each button.", /* control_details */
  &mvsc_get_ctrl_name
};

const char *mvsc_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Punch - Jab";
    case IPT_BUTTON2: return BTN2 "Punch - Strong";
    case IPT_BUTTON3: return BTN3 "Punch - Fierce";
    case IPT_BUTTON4: return BTN4 "Kick - Short";
    case IPT_BUTTON5: return BTN5 "Kick - Forward";
    case IPT_BUTTON6: return BTN6 "Kick - Round-House";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo matmania_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Press both buttons to pin. Rapidly press both buttons to kick out.", /* control_details */
  &matmania_get_ctrl_name
};

const char *matmania_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Action Punch";
    case IPT_BUTTON2: return BTN2 "Action Kick";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo maxrpm_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Please note that mame has fudged the shifter input up. Also note that since the shifter buttons are mapped to button 1 and 2 they will conflict with the gas pedal with mame's default mappings.", /* control_details */
  &maxrpm_get_ctrl_name
};

const char *maxrpm_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shift Up";
    case IPT_BUTTON2: return BTN2 "Shift Down";
    case IPT_PADDLE: return "Left";
    case (IPT_PADDLE + IPT_EXTENSION): return "Right";
    case IPT_PEDAL: return "Accelerate";
  } /* end of switch */

  return "";
}

const struct ControlInfo maxforce_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &maxforce_get_ctrl_name
};

const char *maxforce_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_LIGHTGUN_X: return "Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Right";
    case IPT_LIGHTGUN_Y: return "Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo mayday_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Right directions on the joystick are the only ones used as you can't turn back. Also note that the buttons are in different order on the control panel. (Mayday, Back, Fire Front)", /* control_details */
  &mayday_get_ctrl_name
};

const char *mayday_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire Front";
    case IPT_BUTTON2: return BTN2 "Mayday";
    case IPT_BUTTON3: return BTN3 "Back";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo mechatt_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &mechatt_get_ctrl_name
};

const char *mechatt_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Grenade";
    case IPT_LIGHTGUN_X: return "Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Right";
    case IPT_LIGHTGUN_Y: return "Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo mmehyou_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mmehyou_get_ctrl_name
};

const char *mmehyou_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo pachiten_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &pachiten_get_ctrl_name
};

const char *pachiten_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo megaman2_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &megaman2_get_ctrl_name
};

const char *megaman2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "Weapon Change";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo megazone_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &megazone_get_ctrl_name
};

const char *megazone_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo mercs_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &mercs_get_ctrl_name
};

const char *mercs_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo metamrph_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This game can be turned into a 2 player setup via a dip setting. Also something unique in 4 player games, this one allows you to have a shared coin slot via the settings. (This means the 2 player-style select screen even when you have the cabinet set to 4 players)", /* control_details */
  &metamrph_get_ctrl_name
};

const char *metamrph_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo metrocrs_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Teh control panel didn't have a button label.", /* control_details */
  &metrocrs_get_ctrl_name
};

const char *metrocrs_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo mwalk_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &mwalk_get_ctrl_name
};

const char *mwalk_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_BUTTON2: return BTN2 "Dance";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo midres_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &midres_get_ctrl_name
};

const char *midres_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_DIAL: return "Rotate Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Rotate Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo gtmr2_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This game does NOT use all of these controls. It has dipswitch settings which allow the games to be controlled with a 360 degree wheel, a 270 degree wheel, a 270 degree digital wheel (using a d2a conveter) and a plain old 8-way joystick with buttons. Uses with steering wheels please note that the game defaults to joystick input. Also note that the pedals optionally can be set to analog mode, but mame disables this feature due to input limitations.", /* control_details */
  &gtmr2_get_ctrl_name
};

const char *gtmr2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Accelerate";
    case IPT_BUTTON2: return BTN2 "Brake";
    case IPT_PADDLE: return "Left";
    case (IPT_PADDLE + IPT_EXTENSION): return "Right";
    case IPT_DIAL: return "Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo milliped_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &milliped_get_ctrl_name
};

const char *milliped_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo minefld_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &minefld_get_ctrl_name
};

const char *minefld_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Cannon";
    case IPT_JOYSTICKLEFT_RIGHT: return "Tank Direction Right";
    case IPT_JOYSTICKLEFT_LEFT: return "Tank Direction Left";
    case IPT_JOYSTICKLEFT_DOWN: return "Tank Direction Down";
    case IPT_JOYSTICKLEFT_UP: return "Tank Direction Up";
    case IPT_JOYSTICKRIGHT_UP: return "Machine Gun Up";
    case IPT_JOYSTICKRIGHT_DOWN: return "Machine Gun Down";
    case IPT_JOYSTICKRIGHT_LEFT: return "Machine Gun Left";
    case IPT_JOYSTICKRIGHT_RIGHT: return "Machine Gun Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo mineswpr_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Player 1 is actually position on the bottom right of the screen while Player 2 is at the top right", /* control_details */
  &mineswpr_get_ctrl_name
};

const char *mineswpr_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo minigolf_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &minigolf_get_ctrl_name
};

const char *minigolf_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Tee Selection";
  } /* end of switch */

  return "";
}

const struct ControlInfo mcontest_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mcontest_get_ctrl_name
};

const char *mcontest_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo missile_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &missile_get_ctrl_name
};

const char *missile_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire - Alpha Base";
    case IPT_BUTTON2: return BTN2 "Fire - Delta Base";
    case IPT_BUTTON3: return BTN3 "Fire - Omega Base";
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo gmissile_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This game actually uses a 2-way top-fire joystick, which is extremely rare. So rare we don't recognize it in the database.", /* control_details */
  &gmissile_get_ctrl_name
};

const char *gmissile_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo moguchan_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Unknown as to what the button does but is listed in mame", /* control_details */
  &moguchan_get_ctrl_name
};

const char *moguchan_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Unkown";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo mole_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The button is layed out on a 3x3 grid and relates directly to the position on the screen  Top Row:    7 8 9 Middle Row: 4 5 6 Bottom Row: 1 2 3", /* control_details */
  &mole_get_ctrl_name
};

const char *mole_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=9 */
    case IPT_BUTTON1: return BTN1 "Attack 1";
    case IPT_BUTTON2: return BTN2 "Attack 2";
    case IPT_BUTTON3: return BTN3 "Attack 3";
    case IPT_BUTTON4: return BTN4 "Attack 4";
    case IPT_BUTTON5: return BTN5 "Attack 5";
    case IPT_BUTTON6: return BTN6 "Attack 6";
    case IPT_BUTTON7: return BTN7 "Attack 7";
    case IPT_BUTTON8: return BTN7 "Attack 8";
    case IPT_BUTTON9: return "Attack 9";
  } /* end of switch */

  return "";
}

const struct ControlInfo monymony_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The joystick was generically labeled 'control'. Also of note is that you can only jump when you are standing on a white circle and you can't control the direction of the jump like in most games.", /* control_details */
  &monymony_get_ctrl_name
};

const char *monymony_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo monsterb_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &monsterb_get_ctrl_name
};

const char *monsterb_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Zap";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo montecar_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "Please note that this game's driver hard-code's all of the buttons. The gears are remapped to z,x,c and v while track select is remapped to space.", /* control_details */
  &montecar_get_ctrl_name
};

const char *montecar_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Accelerate";
    case IPT_BUTTON2: return BTN2 "Gear 1";
    case IPT_BUTTON3: return BTN3 "Gear 2";
    case IPT_BUTTON4: return BTN4 "Gear 3";
    case IPT_BUTTON5: return BTN5 "Gear 4";
    case IPT_BUTTON6: return BTN6 "Track Select";
    case IPT_DIAL: return "Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo mooncrst_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &mooncrst_get_ctrl_name
};

const char *mooncrst_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo mpatrol_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &mpatrol_get_ctrl_name
};

const char *mpatrol_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_LEFT: return "Slower";
    case IPT_JOYSTICK_RIGHT: return "Faster";
  } /* end of switch */

  return "";
}

const struct ControlInfo moonwar_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The game's original control panel also has a button called 'Hyper Flip' that for whatever reason isn't emulated in mame. Also the roller for this game looks more like some sort of futuristic valve and is dubbed the 'Vector Director' by the label underneath it.", /* control_details */
  &moonwar_get_ctrl_name
};

const char *moonwar_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire Missile";
    case IPT_BUTTON2: return BTN2 "Warp Drive";
    case IPT_BUTTON3: return BTN3 "Shields";
    case IPT_DIAL: return "Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo mk_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Mame uses the jamma standard for button numbering and thus all of the mk games are completely off. The games buttons were arranged in a cross pattern with block the center of the 'X' high and low punch on the left and high and low kick on the right respectively. It is highly reccomended that you wrie ctrlr files for these gmaes if you intend to play them. Also there is actually a second block button used for sf2 conversions but it alternates between broken and half working in the mame source.", /* control_details */
  &mk_get_ctrl_name
};

const char *mk_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "High Punch";
    case IPT_BUTTON2: return BTN2 "Block";
    case IPT_BUTTON3: return BTN3 "High Kick";
    case IPT_BUTTON4: return BTN4 "Low Punch";
    case IPT_BUTTON5: return BTN5 "Low Kick";
    case IPT_JOYSTICK_UP: return "Jump";
    case IPT_JOYSTICK_DOWN: return "Duck";
    case IPT_JOYSTICK_LEFT: return "Move Left";
    case IPT_JOYSTICK_RIGHT: return "Move Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo mk3_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Mame uses the jamma standard for button numbering and thus all of the mk games are completely off. The games buttons were arranged in a cross pattern with block the center of the 'X' high and low punch on the left and high and low kick on the right respectively. The Run button is placed inthe lower left hand corner, similar to a mamers 'modified Neo Geo' layout. It is highly reccomended that you write ctrlr files for these games if you intend to play them.", /* control_details */
  &mk3_get_ctrl_name
};

const char *mk3_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "High Punch";
    case IPT_BUTTON2: return BTN2 "Block";
    case IPT_BUTTON3: return BTN3 "High Kick";
    case IPT_BUTTON4: return BTN4 "Low Punch";
    case IPT_BUTTON5: return BTN5 "Low Kick";
    case IPT_BUTTON6: return BTN6 "Run";
    case IPT_JOYSTICK_UP: return "Jump";
    case IPT_JOYSTICK_DOWN: return "Duck";
    case IPT_JOYSTICK_LEFT: return "Move Left";
    case IPT_JOYSTICK_RIGHT: return "Move Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo mk4_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The final mortal kombat game to be released in the arcades.", /* control_details */
  &mk4_get_ctrl_name
};

const char *mk4_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "High Punch";
    case IPT_BUTTON2: return BTN2 "Block";
    case IPT_BUTTON3: return BTN3 "High Kick";
    case IPT_BUTTON4: return BTN4 "Low Punch";
    case IPT_BUTTON5: return BTN5 "Low Kick";
    case IPT_BUTTON6: return BTN6 "Run";
    case IPT_JOYSTICK_UP: return "Jump";
    case IPT_JOYSTICK_DOWN: return "Duck";
    case IPT_JOYSTICK_LEFT: return "Move Left";
    case IPT_JOYSTICK_RIGHT: return "Move Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo mk2_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Mame uses the jamma standard for button numbering and thus all of the mk games are completely off. The games buttons were arranged in a cross pattern with block the center of the 'X' high and low punch on the left and high and low kick on the right respectively. It is highly reccomended that you write ctrlr files for these games if you intend to play them. Also there is actually a second block button used for sf2 conversions but it alternates between broken and half working in the mame source.", /* control_details */
  &mk2_get_ctrl_name
};

const char *mk2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "High Punch";
    case IPT_BUTTON2: return BTN2 "Block";
    case IPT_BUTTON3: return BTN3 "High Kick";
    case IPT_BUTTON4: return BTN4 "Low Punch";
    case IPT_BUTTON5: return BTN5 "Low Kick";
    case IPT_JOYSTICK_UP: return "Jump";
    case IPT_JOYSTICK_DOWN: return "Duck";
    case IPT_JOYSTICK_LEFT: return "Move Left";
    case IPT_JOYSTICK_RIGHT: return "Move Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo mtrap_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "On the original control panel, the order was (from left to right) red, yellow, blue... Not the order that mame has (yellow, red, blue).", /* control_details */
  &mtrap_get_ctrl_name
};

const char *mtrap_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Dog";
    case IPT_BUTTON2: return BTN2 "Doors - Yellow";
    case IPT_BUTTON3: return BTN3 "Doors - Red";
    case IPT_BUTTON4: return BTN4 "Doors - Blue";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo mrdo_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &mrdo_get_ctrl_name
};

const char *mrdo_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Throw";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo docastle_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The button is actually unlabeled.", /* control_details */
  &docastle_get_ctrl_name
};

const char *docastle_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo dowild_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &dowild_get_ctrl_name
};

const char *dowild_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Run";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo mrdrillr_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The drill button is actually unlabeled as the game was only sold in a conversion kit with a very generic namco overlay.", /* control_details */
  &mrdrillr_get_ctrl_name
};

const char *mrdrillr_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Drill";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo mspacman_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &mspacman_get_ctrl_name
};

const char *mspacman_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo mvp_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The buttons aren't labeled red, yellow and blue rather that is their color. The instruction card uses these colors to explain the various functions of the buttons.", /* control_details */
  &mvp_get_ctrl_name
};

const char *mvp_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Red";
    case IPT_BUTTON2: return BTN2 "Yellow";
    case IPT_BUTTON3: return BTN3 "Blue";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo mx5000_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Air-to-air and air-to-ground refer to missiles.", /* control_details */
  &mx5000_get_ctrl_name
};

const char *mx5000_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Air - to - Air";
    case IPT_BUTTON2: return BTN2 "Air - to - Ground";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo mysticm_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &mysticm_get_ctrl_name
};

const char *mysticm_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo mystwarr_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Mame has three buttons, but only uses the first two. There is a dipswitch to change between 2 and 4 players.", /* control_details */
  &mystwarr_get_ctrl_name
};

const char *mystwarr_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "NA";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo nametune_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The game used special lighted buttons for the tune buttons.", /* control_details */
  &nametune_get_ctrl_name
};

const char *nametune_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "1";
    case IPT_BUTTON2: return BTN2 "2";
    case IPT_BUTTON3: return BTN3 "3";
    case IPT_BUTTON4: return BTN4 "4";
  } /* end of switch */

  return "";
}

const struct ControlInfo narc_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &narc_get_ctrl_name
};

const char *narc_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "Crouch";
    case IPT_BUTTON4: return BTN4 "Rocket Bomb";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo nastar_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The orignal cpo lacks labels.", /* control_details */
  &nastar_get_ctrl_name
};

const char *nastar_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo natodef_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The cpo actually had pictures of the tank going in various directions for the joystick labels.", /* control_details */
  &natodef_get_ctrl_name
};

const char *natodef_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "1";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo naughtyb_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &naughtyb_get_ctrl_name
};

const char *naughtyb_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Throw";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo nbahangt_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Default setting is for 2-player cabinet but this can be changed to 4-player as a dip switch setting", /* control_details */
  &nbahangt_get_ctrl_name
};

const char *nbahangt_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Turbo";
    case IPT_BUTTON2: return BTN2 "Shoot / Block";
    case IPT_BUTTON3: return BTN3 "Pass / Steal";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo nbajam_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &nbajam_get_ctrl_name
};

const char *nbajam_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Turbo";
    case IPT_BUTTON2: return BTN2 "Shoot / Block";
    case IPT_BUTTON3: return BTN3 "Pass / Steal";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo neckneck_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Even though this game allows 6 players, it is wired to a single player layout in mame, due to the odd layout. Each numbered button represents a horse a player can control. it also doubles as a start button for that player. All the button does is jump. There is also a global start button that starts the race without giving others time to join. This is mapped to player 1 start in mame.", /* control_details */
  &neckneck_get_ctrl_name
};

const char *neckneck_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "1";
    case IPT_BUTTON2: return BTN2 "2";
    case IPT_BUTTON3: return BTN3 "3";
    case IPT_BUTTON4: return BTN4 "4";
    case IPT_BUTTON5: return BTN5 "5";
    case IPT_BUTTON6: return BTN6 "6";
  } /* end of switch */

  return "";
}

const struct ControlInfo ngpgal_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &ngpgal_get_ctrl_name
};

const char *ngpgal_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo nmsengen_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &nmsengen_get_ctrl_name
};

const char *nmsengen_get_ctrl_name(int type)
{
  switch(type)
  {

  } /* end of switch */

  return "";
}

const struct ControlInfo neogeo_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The Neo Geo MVS system is a generic cabinet that can have games swapped out very easily, similar to console games. A single game cabinet, a 2 game, 4 game, and 6 game variation were manufactured. The multi-cart versions had buttons to switch to a new game prior to inserting your quarter. This feature is unemulated as of MAME 0.141. Neo Geo cabinets all used the same control layout and relied upon inserts to explain to the consumer what button had what function. Most Neo Geo games begin with a 'How to Play' screen with gameplay information.", /* control_details */
  &neogeo_get_ctrl_name
};

const char *neogeo_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Neo Geo A";
    case IPT_BUTTON2: return BTN2 "Neo Geo B";
    case IPT_BUTTON3: return BTN3 "Neo Geo C";
    case IPT_BUTTON4: return BTN4 "Neo Geo D";
  } /* end of switch */

  return joy4way_labels(type);
}


const struct ControlInfo nyny_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The cpo also has a general caption for the joystick, but it's unreadable.", /* control_details */
  &nyny_get_ctrl_name
};

const char *nyny_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo blitz_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "OTHER:  There is a dipswitch to use either two 49-way or two 8-way joysticks for direction control. AFAIK, all blitz dedicated cabs came with 49-way stick /* control_details */ some upgrade kits came with 49-way sticks, others without any sticks (I guess assumed operator would use already installed 8-ways). Mame currently (0.82u3) only emulates the 8-way. In-game instructions sometimes refer to the buttons by their color instead of the label. Turbo = White, Jump = Blue, Pass = Red. When choosing the offensive play: the Turbo (White) button switches between the two pages of plays, Jump (Blue) flips the play directions left to right, and Pass (Red) chooses the highlighted play. When choosing the defensive play: any button chooses the highlighted play (only one page, and plays can't be flipped). When choosing either offense and defense you can turn off showing which play is highlighted by pressing up on the joystick three times (useful when playing against another player). Turbo + Pass when running with the ball gives a stiff arm. Tapping Turbo twice when running with the ball gives a spin.", /* control_details */
  &blitz_get_ctrl_name
};

const char *blitz_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Turbo";
    case IPT_BUTTON2: return BTN2 "Jump/Tackle";
    case IPT_BUTTON3: return BTN3 "Pass/Change Player";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo nibbler_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &nibbler_get_ctrl_name
};

const char *nibbler_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo nss_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Super System is the super nintendo version of the playchoice system and it runs on basically the same concept. The control panel has 2 (or 4) industrial versions of the snes control pad mounted to it. Please note that as of this posting, the mame driver doesn't emulate the nss fully. Game select buttons aren't implemented yet. Also note that the gamepad's select buttons are mapped to service buttons 1-4 respectively.", /* control_details */
  &nss_get_ctrl_name
};

const char *nss_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "Y";
    case IPT_BUTTON3: return BTN3 "A";
    case IPT_BUTTON4: return BTN4 "X";
    case IPT_BUTTON5: return BTN5 "L";
    case IPT_BUTTON6: return BTN6 "R";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_SERVICE1: return "Select (Player 1)";
    case IPT_SERVICE2: return "Select (Player 2)";
    case IPT_SERVICE3: return "Select (Player 3)";
    case IPT_SERVICE4: return "Select (Player 4)";
  } /* end of switch */

  return "";
}

const struct ControlInfo nomnlnd_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &nomnlnd_get_ctrl_name
};

const char *nomnlnd_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire!";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo nova2001_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This game had a pause button (unlabeled on the cpo) but apparently the feature isn't working in mame.", /* control_details */
  &nova2001_get_ctrl_name
};

const char *nova2001_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Pause";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo ojankoc_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &ojankoc_get_ctrl_name
};

const char *ojankoc_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo ojankohs_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &ojankohs_get_ctrl_name
};

const char *ojankohs_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo ojankoy_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &ojankoy_get_ctrl_name
};

const char *ojankoy_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo ojanko2_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &ojanko2_get_ctrl_name
};

const char *ojanko2_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo ojousan_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &ojousan_get_ctrl_name
};

const char *ojousan_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo olibochu_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &olibochu_get_ctrl_name
};

const char *olibochu_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo omegrace_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This game acutally uses one of the very rare optical dials. No it doesn't really spin, you turn it like a paddle. Ironically, I believe that this was one of mame's first optical games and thus the 2 way optical was named 'dial' instead of 'spinner,' which is what most optical mame games have.", /* control_details */
  &omegrace_get_ctrl_name
};

const char *omegrace_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Thrust";
    case IPT_DIAL: return "Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo oneshot_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &oneshot_get_ctrl_name
};

const char *oneshot_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_LIGHTGUN_X: return "Aim Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Aim Right";
    case IPT_LIGHTGUN_Y: return "Aim Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Aim Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo othunder_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &othunder_get_ctrl_name
};

const char *othunder_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Grenade";
    case IPT_LIGHTGUN_X: return "Aim Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Aim Right";
    case IPT_LIGHTGUN_Y: return "Aim Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Aim Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo opwolf_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "", /* control_details */
  &opwolf_get_ctrl_name
};

const char *opwolf_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Rocket Gun";
    case IPT_LIGHTGUN_X: return "Aim Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Aim Right";
    case IPT_LIGHTGUN_Y: return "Aim Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Aim Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo opwolf3_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The bomb button is actually the reload cock on the gun. Yes this doesn't make any sense, just go with it.", /* control_details */
  &opwolf3_get_ctrl_name
};

const char *opwolf3_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_LIGHTGUN_X: return "Aim Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Aim Right";
    case IPT_LIGHTGUN_Y: return "Aim Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Aim Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo orangec_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &orangec_get_ctrl_name
};

const char *orangec_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo otonano_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &otonano_get_ctrl_name
};

const char *otonano_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo outrun_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "The shifter is hard-coded to the space-bar to avoid conflicts.", /* control_details */
  &outrun_get_ctrl_name
};

const char *outrun_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "High / Low";
    case IPT_PADDLE: return "Left";
    case (IPT_PADDLE + IPT_EXTENSION): return "Right";
    case IPT_PEDAL: return "Accelerate";
    case IPT_PEDAL2: return "Brake";
  } /* end of switch */

  return "";
}

const struct ControlInfo overdriv_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "", /* control_details */
  &overdriv_get_ctrl_name
};

const char *overdriv_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Accelerate";
    case IPT_BUTTON2: return BTN2 "Brake";
    case IPT_BUTTON3: return BTN3 "High / Low";
    case IPT_DIAL: return "Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo pow_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "On the original cpo, the buttons are in 'Double Dragon' configuration (jump on the top row, punch and kick on the bottom). You may wish to remap for comfort", /* control_details */
  &pow_get_ctrl_name
};

const char *pow_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Kick";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "Punch";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo pacland_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &pacland_get_ctrl_name
};

const char *pacland_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jump";
    case IPT_JOYSTICK_LEFT: return "Run Left";
    case IPT_JOYSTICK_RIGHT: return "Run Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo pacplus_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &pacplus_get_ctrl_name
};

const char *pacplus_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo pacmania_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The original CP had one button on either side of the CP for Bounce. Note By HowarC:  This seems to be a glitch in mame caused by a sloppy macro. For now three buttons is ok, but I will submit a new driver which ditches the other two.", /* control_details */
  &pacmania_get_ctrl_name
};

const char *pacmania_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Bounce";
    case IPT_BUTTON2: return BTN2 "Bounce";
    case IPT_BUTTON3: return BTN3 "Bounce";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo paddlema_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This game is 4 player but only one start button is used. Upon inserting a coin and presing start, you are presented with a menu to choose the number of players and play mode.", /* control_details */
  &paddlema_get_ctrl_name
};

const char *paddlema_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Bounce";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo pandoras_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &pandoras_get_ctrl_name
};

const char *pandoras_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo paperboy_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Game used a handlebar controller, Pushing forward on the handles made the bike speed up, pulling back slowed it down.", /* control_details */
  &paperboy_get_ctrl_name
};

const char *paperboy_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Throw";
    case IPT_BUTTON2: return BTN2 "Throw";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "Right";
    case IPT_AD_STICK_X: return "Left";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "Break";
    case IPT_AD_STICK_Y: return "Accelerate";
  } /* end of switch */

  return "";
}

const struct ControlInfo pastelg_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &pastelg_get_ctrl_name
};

const char *pastelg_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo pengo_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &pengo_get_ctrl_name
};

const char *pengo_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Push";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo pepper2_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &pepper2_get_ctrl_name
};

const char *pepper2_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo peterpak_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This game uses a unique type of trigger stick that is rarely used. Although it looks different, the diagrams show similar mounting and throw of a more standard tron stick.", /* control_details */
  &peterpak_get_ctrl_name
};

const char *peterpak_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Throw";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo phoenix_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &phoenix_get_ctrl_name
};

const char *phoenix_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Force Field";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo pigout_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &pigout_get_ctrl_name
};

const char *pigout_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jump";
    case IPT_BUTTON2: return BTN2 "Throw";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo pigskin_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "OTHER: This game used a 49-way joystick. This game was recently updated to accomidate true analog inputs to better emulate the 49-way joystick. Unfortunately, they turned an othewise tidy driver into an ungodly mess. The stick is there and oddly enough three joystick directions (up, down, and only left) and now the normal 'button 1' labels are overwritten with the game selection labels, which are secondary functions and should NOT be the custom labels for the buttons. For the love of all things good, someone PLEASE fix this driver. The joystick controls one player, but when you punch, the rest of the team also punches. If another teammate has the ball and you press the pass button, he passes the ball to you. If you have the ball and press and hold the pass button, the choices rolls between long, short, back passes, and a drop kick, which happens when you let go of the button.", /* control_details */
  &pigskin_get_ctrl_name
};

const char *pigskin_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Punch";
    case IPT_BUTTON2: return BTN2 "Pass";
    case IPT_BUTTON3: return BTN3 "Team Attitude";
    case IPT_AD_STICK_X: return "Left";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "Right";
    case IPT_AD_STICK_Y: return "Up";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo pbaction_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The cpo lables are a little misleading. By 'Start' it actually refers to launching the pinball, not the start button, which the game actually has two of. Also, although there are two buttons on each side Labeled 'Start And Shake' apparently, only the left button starts and only the right button shakes. This may be a mame issue though. My best guess is on the original cpo, each button was cross-wired to both switches as a last-minute layout decision.", /* control_details */
  &pbaction_get_ctrl_name
};

const char *pbaction_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Left Flipper Button";
    case IPT_BUTTON2: return BTN2 "Right Flipper Button";
    case IPT_BUTTON3: return BTN3 "Shake and Start Button (Left)";
    case IPT_BUTTON4: return BTN4 "Shake and Start Button (Right)";
  } /* end of switch */

  return "";
}

const struct ControlInfo piratetr_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The games cpo didn't have any directional arrows, nor did it have any labels, probably due to the simplistic layout.", /* control_details */
  &piratetr_get_ctrl_name
};

const char *piratetr_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo pitfight_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Although in the arcades the start buton was also the jump button, this is not the case in mame. My guess is in the arcades two inputs were wired to the same button to save space much like in other 3 and 4 player games. This game only had a 2 player verison in japan, but often the 3 player us version was also used in a 2 player cabinet because of the way the menu is setup. Unlike most multiplayer games, the coin slots are shared and you can select each character regardless of which stick you press start at.", /* control_details */
  &pitfight_get_ctrl_name
};

const char *pitfight_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Punch";
    case IPT_BUTTON2: return BTN2 "Kick";
    case IPT_BUTTON3: return BTN3 "Start / Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo pitfall2_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The actual cpo for this game didn't have a label for the button, nor a visual hint of what it's for. Also the manual doesn't explicitly say that the button is the 'jump' button. This is probably due to the fact that the pitfall series is one of the most popular in early gaming history and you'd have to live in a cave not to know that the button is for jumping.", /* control_details */
  &pitfall2_get_ctrl_name
};

const char *pitfall2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo playch10_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "The playchoice 10 system is a pay-per-play system based on the original nes console and plays the same titles. Instead of purchasing lives, you purchase time on the machine. The machine can hold 10 games at once and you switch using the game menu on the secondary monitor.", /* control_details */
  &playch10_get_ctrl_name
};

const char *playch10_get_ctrl_name(int type)
{
  switch(type)
  {
/* P2NumButtons=2 */
    case (IPT_OSD_DESCRIPTION | IPF_PLAYER2): return "8-way Joystick+joy8way";
    case (IPT_BUTTON1 | IPF_PLAYER2): return "A";
    case (IPT_BUTTON2 | IPF_PLAYER2): return "B";
    case (IPT_JOYSTICK_UP | IPF_PLAYER2): return "Up";
    case (IPT_JOYSTICK_DOWN | IPF_PLAYER2): return "Down";
    case (IPT_JOYSTICK_LEFT | IPF_PLAYER2): return "Left";
    case (IPT_JOYSTICK_RIGHT | IPF_PLAYER2): return "Right";
    case IPT_BUTTON1: return BTN1 "A";
    case IPT_BUTTON2: return BTN2 "B";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Right";
    case IPT_LIGHTGUN_X: return "Left";
    case IPT_LIGHTGUN_Y: return "Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Down";
    case IPT_SERVICE1: return "Service Coin";
    case IPT_SERVICE2: return "Channel Select";
    case IPT_SERVICE3: return "Enter";
    case IPT_SERVICE4: return "Reset";
  } /* end of switch */

  return "";
}

const struct ControlInfo pleiads_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &pleiads_get_ctrl_name
};

const char *pleiads_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Warp";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo plotting_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &plotting_get_ctrl_name
};

const char *plotting_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo ptblank_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "To reload fire offscreen.", /* control_details */
  &ptblank_get_ctrl_name
};

const char *ptblank_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_LIGHTGUN_X: return "Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Right";
    case IPT_LIGHTGUN_Y: return "Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo polaris_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The original cpo simply labeled the joystick 'control'", /* control_details */
  &polaris_get_ctrl_name
};

const char *polaris_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo polepos_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "Button 1 is actually the spacebar by default to avoid conflicts with the pedals. The high/low shifter is emulated by a single toggle input in mame.", /* control_details */
  &polepos_get_ctrl_name
};

const char *polepos_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "High / Low";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
    case IPT_DIAL: return "Left";
    case IPT_PEDAL: return "Accelerate";
    case IPT_PEDAL2: return "Brake";
  } /* end of switch */

  return "";
}

const struct ControlInfo polepos2_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "Button1 is actually spacbar by default in this game to avoid conflicts with the pedals. The high / low shifter is emulated in mame by a single button toggle. The upright cab only uses the gas pedal while the cockpit uses both. This is a dipswitch setting that you can alter if you wish to better suit your layout.", /* control_details */
  &polepos2_get_ctrl_name
};

const char *polepos2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "High / Low";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
    case IPT_DIAL: return "Left";
    case IPT_PEDAL: return "Accelerate";
    case IPT_PEDAL2: return "Brake";
  } /* end of switch */

  return "";
}

const struct ControlInfo policetr_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Fire offscreen to reload.", /* control_details */
  &policetr_get_ctrl_name
};

const char *policetr_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_LIGHTGUN_X: return "Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Right";
    case IPT_LIGHTGUN_Y: return "Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo polyplay_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "Note that this game didn't have any labels. The poly play system was the second East-German arcade machine. Quite, frankly it was a slapped-together piece of crap. It used inferior russian computer hardware, an old television converted to rgb and a cabient made out of chip-board laminated to look like fake wood. We use the terms 'arcade contols' in a generic sense on this one. The joystick and button were salvaged from industrial machines and are nothing like real arcade controls.", /* control_details */
  &polyplay_get_ctrl_name
};

const char *polyplay_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "A";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo ponpoko_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &ponpoko_get_ctrl_name
};

const char *ponpoko_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo pooyan_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &pooyan_get_ctrl_name
};

const char *pooyan_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo popeye_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &popeye_get_ctrl_name
};

const char *popeye_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Punch";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo popper_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "For you Q-Bert fans that don't have a diagonal joystick mounted this is the game for you. It is essentailly the same game only an 8-way joystick is used.", /* control_details */
  &popper_get_ctrl_name
};

const char *popper_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Throw";
    case IPT_JOYSTICK_UP: return "Move Up";
    case IPT_JOYSTICK_DOWN: return "Move Down";
    case IPT_JOYSTICK_LEFT: return "Move Left";
    case IPT_JOYSTICK_RIGHT: return "Move Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo pdrift_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "", /* control_details */
  &pdrift_get_ctrl_name
};

const char *pdrift_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "High / Low";
    case IPT_PADDLE: return "Left";
    case (IPT_PADDLE + IPT_EXTENSION): return "Right";
    case IPT_PEDAL: return "Accelerate";
    case IPT_PEDAL2: return "Brake";
  } /* end of switch */

  return "";
}

const struct ControlInfo powerdrv_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Tap the front and back tires rapidly to acelerate and use the shifter to change gearing for obstacles. Pop a wheelie with the wheelie button.", /* control_details */
  &powerdrv_get_ctrl_name
};

const char *powerdrv_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Back Tire";
    case IPT_BUTTON2: return BTN2 "Front Tire";
    case IPT_BUTTON3: return BTN3 "Wheelie";
    case IPT_BUTTON4: return BTN4 "2wd/4wd";
  } /* end of switch */

  return "";
}

const struct ControlInfo pclubj_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "Even though the label indicates that this is a 4 way joystick it is really a two way. The joystick is desginated as a 4 way because the cpo actually had arrows in all 4 directions. This isn't even a game, it is a photo booth in which users select a overlay and have theri pciture printed with it in front. Considering mame's 'arcade machine only' policy, it is suprising that it is included in mame.", /* control_details */
  &pclubj_get_ctrl_name
};

const char *pclubj_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Ok / Print";
    case IPT_BUTTON2: return BTN2 "Cancel";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo kiwame_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &kiwame_get_ctrl_name
};

const char *kiwame_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo profpac_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Something of note is that on this layout the first player is on the right side instead of the left. Note:  As of mame 0.83 this game isn't working yet... I am just preparing for when it does.", /* control_details */
  &profpac_get_ctrl_name
};

const char *profpac_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "A";
    case IPT_BUTTON2: return BTN2 "B";
    case IPT_BUTTON3: return BTN3 "C";
  } /* end of switch */

  return "";
}

const struct ControlInfo psychos_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The player starts as a flying-saucer which the player can fly anywhere in the screen. After a few seconds, the flying-saucer drops the main character that runs/jumps/drops between the platforms. After a life is lost, the player returns to the saucer.", /* control_details */
  &psychos_get_ctrl_name
};

const char *psychos_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Primary Fire";
    case IPT_BUTTON2: return BTN2 "Secondary Fire ";
    case IPT_JOYSTICK_RIGHT: return "Move Right";
    case IPT_JOYSTICK_LEFT: return "Move Left";
    case IPT_JOYSTICK_DOWN: return "Move Down";
    case IPT_JOYSTICK_UP: return "Move Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo puckman_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &puckman_get_ctrl_name
};

const char *puckman_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo pulsar_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The original game had the fire button on the left and the joystick on the right.", /* control_details */
  &pulsar_get_ctrl_name
};

const char *pulsar_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo punchout_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "The Hook Uppercut is also referred to as the 'knockout blow' on the control panel and can only be used when your ko meter flashes. The button is a large gameshow type of button.", /* control_details */
  &punchout_get_ctrl_name
};

const char *punchout_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Left Blow To Head/Body";
    case IPT_BUTTON2: return BTN2 "Right Blow to Head/Body";
    case IPT_BUTTON3: return BTN3 "Hook Uppercut";
    case IPT_JOYSTICK_UP: return "Guard Up";
    case IPT_JOYSTICK_DOWN: return "Guard Down";
    case IPT_JOYSTICK_LEFT: return "Dodge Left";
    case IPT_JOYSTICK_RIGHT: return "Dodge Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo punkshot_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &punkshot_get_ctrl_name
};

const char *punkshot_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Pass / Hit";
    case IPT_BUTTON2: return BTN2 "Shoot / Block";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo pbobble_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &pbobble_get_ctrl_name
};

const char *pbobble_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo pbobble2_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Puzzle Bobble 2 is listed as using an 8-way joystick and 4 buttons, though only left, right and 1 button are used for gameplay. Up, down and buttons 2 and 3 are only used during Test Mode. I can find no references to button 4.", /* control_details */
  &pbobble2_get_ctrl_name
};

const char *pbobble2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "NA";
    case IPT_BUTTON3: return BTN3 "NA";
    case IPT_BUTTON4: return BTN4 "NA";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo pbobble3_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Mame lists Puzzle Bobble 3 as having 4 buttons and an 8-way joystick (because it is a Taito F3 System game) /* control_details */ only one button is used during gameplay, Test Mode lists 3 buttons. Only left and right are used during gameplay, up and down are used during Test Mode. I can find no references to button 4.", /* control_details */
  &pbobble3_get_ctrl_name
};

const char *pbobble3_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_BUTTON2: return BTN2 "NA";
    case IPT_BUTTON3: return BTN3 "NA";
    case IPT_BUTTON4: return BTN4 "NA";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo qbert_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Used a 4-way joystick rotated 45 degrees.", /* control_details */
  &qbert_get_ctrl_name
};

const char *qbert_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICK_LEFT: return "Left+Up";
    case IPT_JOYSTICK_DOWN: return "Down+Left";
    case IPT_JOYSTICK_UP: return "Up+Right";
    case IPT_JOYSTICK_RIGHT: return "Down+Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo qbertqub_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Used a 4-way joystick rotated 45 degrees", /* control_details */
  &qbertqub_get_ctrl_name
};

const char *qbertqub_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICK_LEFT: return "Left+Up";
    case IPT_JOYSTICK_DOWN: return "Down+Left";
    case IPT_JOYSTICK_UP: return "Up+Right";
    case IPT_JOYSTICK_RIGHT: return "Right+Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo qix_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &qix_get_ctrl_name
};

const char *qix_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fast Draw";
    case IPT_BUTTON2: return BTN2 "Slow Draw";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo quantum_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This game did not use buttons, the only input is a trackball.", /* control_details */
  &quantum_get_ctrl_name
};

const char *quantum_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

#if 0
const struct ControlInfo quarterb_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "Note that the buttons do various things based on the gameplay scenario. Also both buttons were labeled 'Action' so 'A' and 'B' were added to avoid confusion. Also the kicker only labeled the three actions it is used for, not how to aim, ect. This was added for your benefit.", /* control_details */
  &quarterb_get_ctrl_name
};

const char *quarterb_get_ctrl_name(int type)
{
  switch(type)
  {
/* P2NumButtons=2 */
    case (IPT_OSD_DESCRIPTION | IPF_PLAYER2): return "8-way Joystick+joy8way";
    case (IPT_BUTTON1 | IPF_PLAYER2): return "Action A";
    case (IPT_BUTTON2 | IPF_PLAYER2): return "Action B";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_BUTTON1: return BTN1 "Action A";
    case IPT_BUTTON2: return BTN2 "Action B";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_AD_STICK_X: return "Aim Left";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "Aim Right";
    case IPT_AD_STICK_Y: return "Pass / Punt / Kick";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "Set Power";
  } /* end of switch */

  return "";
}
#endif

const struct ControlInfo quartet_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Ironically this game is also available in a 2 player variety. Wouldn't that make it a duo?", /* control_details */
  &quartet_get_ctrl_name
};

const char *quartet_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jump / Start";
    case IPT_BUTTON2: return BTN2 "Shoot";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo quasar_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The 'forward' button appears to be broken in mame.", /* control_details */
  &quasar_get_ctrl_name
};

const char *quasar_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Forward";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo qad_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "You may wonder why the control type is listed as 'Just Buttons' instead of 'Trivia Buttons'. This is one of the few arcade trivia games that doesn't use trivia-style buttons. It uses standard pushbuttons.", /* control_details */
  &qad_get_ctrl_name
};

const char *qad_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "1";
    case IPT_BUTTON2: return BTN2 "2";
    case IPT_BUTTON3: return BTN3 "3";
    case IPT_BUTTON4: return BTN4 "4";
  } /* end of switch */

  return "";
}

const struct ControlInfo qndream_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Like all capcom quiz games, this game's cp uses regular push buttons instead of trivia-style buttons.", /* control_details */
  &qndream_get_ctrl_name
};

const char *qndream_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "1";
    case IPT_BUTTON2: return BTN2 "2";
    case IPT_BUTTON3: return BTN3 "3";
    case IPT_BUTTON4: return BTN4 "4";
  } /* end of switch */

  return "";
}

const struct ControlInfo qmhayaku_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &qmhayaku_get_ctrl_name
};

const char *qmhayaku_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo rtype_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The longer you hold down the fire button, the stronger the shot. The force button 'shoots' or recalls a power-up piece from and to your ship. Mame has four buttons for this game for some reason, but only uses the first two. The game has the fire and force buttons on both sides of the joystick, but not 'mirrored': the force is to the left of the fire button on both sides of the joystick. NOTE  In Mame this game actually has four buttons. This is due to some sloppy code and nothing more. The dipswitches between this game and a similar game running on the same system were identical, so the input function was simply re-routed to that game. This needs to be removed asap.", /* control_details */
  &rtype_get_ctrl_name
};

const char *rtype_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Force";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo radarscp_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Note by HowardC:  As of mame version .77 this game should us a 2-way stick. If it doesn't contact me.", /* control_details */
  &radarscp_get_ctrl_name
};

const char *radarscp_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
  } /* end of switch */

  return "";
}

const struct ControlInfo radrad_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &radrad_get_ctrl_name
};

const char *radrad_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo rchase_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The game didn't have a gun, rather a joystick with a crosshair on the screen. The machine also had a bench the players sat on with two solenoids mounted underneath to give the illusion of them sitting in the mine cart.", /* control_details */
  &rchase_get_ctrl_name
};

const char *rchase_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_LIGHTGUN_X: return "Aim Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Aim Right";
    case IPT_LIGHTGUN_Y: return "Aim Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Aim Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo rainbow_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &rainbow_get_ctrl_name
};

const char *rainbow_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Rainbow";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo rallyx_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &rallyx_get_ctrl_name
};

const char *rallyx_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Smoke Screen";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
  } /* end of switch */

  return "";
}

const struct ControlInfo rampage_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &rampage_get_ctrl_name
};

const char *rampage_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Punch";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Climb";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo rmpgwt_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The tilt in mame does not work.", /* control_details */
  &rmpgwt_get_ctrl_name
};

const char *rmpgwt_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jump";
    case IPT_BUTTON2: return BTN2 "Punch";
    case IPT_BUTTON3: return BTN3 "Kick";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo rampart_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The player's Place Piece/Fire button is also the start button. There are three basic different CP layouts for this game: 3 player trackball, 2 player trackball (dipswitch with same ROM as 3 player TB), and 2 player 8-way joystick (with ramprt2p and rampartj). The 3 player dedicated TB CP had two buttons per player on the left side of the TB. The kit highly recomends mirroring the buttons on both sides the joystick, with two buttons wired to each button input, but this was not always followed. Button2 (Rotate Peice/Fire) is labeled as the 3 player TB CP /* control_details */ for the joystick CP, this button was 'Rotate Piece/Speed Up' instead to give the joystick two movement speeds in the shooting part of the game.", /* control_details */
  &rampart_get_ctrl_name
};

const char *rampart_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Place Piece/Fire/Start";
    case IPT_BUTTON2: return BTN2 "Rotate Piece/Fire";
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo rastan_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Joystick in center of Panel, with attack and jump buttons on both sides, for both left and right handed players. Player start buttons were on RIGHT side of CP, with P1 at top, and P2 at bottom", /* control_details */
  &rastan_get_ctrl_name
};

const char *rastan_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo reactor_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The action buttons are 'mirrored' on both sides of the trackball like normal, and double as start buttons. However, the start half of the buttons are not mirrored: the start buttons go 1 2 1 2 from left to right, and the left side start buttons give you 3 ships for one credit, while the right side buttons give you 7 ships for two credits. So the layout, from left to right, is (energy / 1 player with 3 ships), (decoy / 2 players with 3 ships each), trackball, (decoy / 1 player with 7 ships), (energy / 2 players with 7 ships each). Mame's emulated buttons go start1, start2, trackball, p1 button2, p1 button1, following the above layout. So the start buttons are also action buttons, and the action buttons are start buttons, but they are 4 different buttons, even though there are two different actions.", /* control_details */
  &reactor_get_ctrl_name
};

const char *reactor_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Energy";
    case IPT_BUTTON2: return BTN2 "Decoy";
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo rmhaihai_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &rmhaihai_get_ctrl_name
};

const char *rmhaihai_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo rmhaijin_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &rmhaijin_get_ctrl_name
};

const char *rmhaijin_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo rmhaisei_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &rmhaisei_get_ctrl_name
};

const char *rmhaisei_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo redlin2p_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &redlin2p_get_ctrl_name
};

const char *redlin2p_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_DIAL: return "Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
    case IPT_PEDAL: return "Accelerate";
  } /* end of switch */

  return "";
}

const struct ControlInfo regulus_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This game doesn't have any labels, probably because the controls are so self-explainatory.", /* control_details */
  &regulus_get_ctrl_name
};

const char *regulus_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo renegade_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &renegade_get_ctrl_name
};

const char *renegade_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack Left";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "Attack Right";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo rescue_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &rescue_get_ctrl_name
};

const char *rescue_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Bomb";
    case IPT_JOYSTICKLEFT_UP: return "Up";
    case IPT_JOYSTICKLEFT_DOWN: return "Down";
    case IPT_JOYSTICKLEFT_LEFT: return "Left";
    case IPT_JOYSTICKLEFT_RIGHT: return "Right";
    case IPT_JOYSTICKRIGHT_UP: return "Fire Up";
    case IPT_JOYSTICKRIGHT_DOWN: return "Fire Down";
    case IPT_JOYSTICKRIGHT_LEFT: return "Fire Left";
    case IPT_JOYSTICKRIGHT_RIGHT: return "Fire Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo rescraid_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The CP has the steering stick on the left side, shooting stick on the right. Mame has it emulated the opposite, so the labels are not mixed up.", /* control_details */
  &rescraid_get_ctrl_name
};

const char *rescraid_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Select Weapons";
    case IPT_JOYSTICKLEFT_UP: return "Shooting Up";
    case IPT_JOYSTICKLEFT_DOWN: return "Shooting Down";
    case IPT_JOYSTICKLEFT_LEFT: return "Shooting Left";
    case IPT_JOYSTICKLEFT_RIGHT: return "Shooting Right";
    case IPT_JOYSTICKRIGHT_UP: return "Steering Up";
    case IPT_JOYSTICKRIGHT_DOWN: return "Steering Down";
    case IPT_JOYSTICKRIGHT_LEFT: return "Steering Left";
    case IPT_JOYSTICKRIGHT_RIGHT: return "Steering Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo nekkyoku_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &nekkyoku_get_ctrl_name
};

const char *nekkyoku_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo jedi_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Triggers fire cannon on all levels. Thumb buttons usually also fire cannon, except on the AT-Walker stages, where they rotate the turret.", /* control_details */
  &jedi_get_ctrl_name
};

const char *jedi_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire / Rotate Left";
    case IPT_BUTTON2: return BTN2 "Fire";
    case IPT_BUTTON3: return BTN3 "Fire / Rotate Right";
    case IPT_AD_STICK_Y: return "Up";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "Right";
    case IPT_AD_STICK_X: return "Left";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo revx_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The 'bomb' button actually shoots a compact disc. But that's what it is labeled in the game.", /* control_details */
  &revx_get_ctrl_name
};

const char *revx_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_LIGHTGUN_X: return "Aim Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Aim Right";
    case IPT_LIGHTGUN_Y: return "Aim Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Aim Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo ripoff_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This is a two player cooperative game. You cannot shoot the other player, but if you crash into him, you both blow up. Prevent the small tanks from stealing the triangular fuel pods by shooting them. The game ends when all the pods are gone.", /* control_details */
  &ripoff_get_ctrl_name
};

const char *ripoff_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Forward";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo roadblst_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "Steering wheel is unique in that it uses optics but is restricted to ~270 degrees, and it returns to the center position using springs. Also, it has 2 triggers (Fire Lasers), and 2 thumb buttons (Activate Special Weapon). Each trigger / thumb button does the same action.", /* control_details */
  &roadblst_get_ctrl_name
};

const char *roadblst_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire Lasers";
    case IPT_BUTTON2: return BTN2 "Activate Special Weapon";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
    case IPT_DIAL: return "Left";
    case IPT_PEDAL: return "Accelerate";
  } /* end of switch */

  return "";
}

const struct ControlInfo roadf_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Game used a joystick and two pushbuttons for Low Gear and High Gear. No Shifter. High Gear cannot be pressed until the car has started and built up some RPM's.", /* control_details */
  &roadf_get_ctrl_name
};

const char *roadf_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Low Gear";
    case IPT_BUTTON2: return BTN2 "High Gear";
    case IPT_JOYSTICK_UP: return "Speed Up";
    case IPT_JOYSTICK_DOWN: return "Slow Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo roadrunn_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mame includes buttons 2 & 3, but they are not used. The original game has the hop button mirrored on both sides of the joystick. The left side jump button is also 1 player start button /* control_details */ mame emulates this as two buttons, button1 and start1. The right side hop button is also 2 players start button; mame emulates this as only the 'start2' button, even though pressing mame's start2 button also makes RoadRunner hop. The original joystick was a Hall Effect joystick: an analog joystick that used magnetics to vary the resistance instead of the usual POT.", /* control_details */
  &roadrunn_get_ctrl_name
};

const char *roadrunn_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Hop";
    case IPT_BUTTON2: return BTN2 "??not used";
    case IPT_BUTTON3: return BTN3 "??not used";
    case IPT_AD_STICK_X: return "Left";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "Right";
    case IPT_AD_STICK_Y: return "Up";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo robby_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &robby_get_ctrl_name
};

const char *robby_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Magic";
    case IPT_JOYSTICK_UP: return "Move Up";
    case IPT_JOYSTICK_DOWN: return "Move Down";
    case IPT_JOYSTICK_LEFT: return "Move Left";
    case IPT_JOYSTICK_RIGHT: return "Move Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo robocop_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &robocop_get_ctrl_name
};

const char *robocop_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot/Punch";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo robocop2_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &robocop2_get_ctrl_name
};

const char *robocop2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot Left";
    case IPT_BUTTON2: return BTN2 "Shoot Right";
    case IPT_BUTTON3: return BTN3 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo robotron_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The drivers in mame don't have a cocktail mode, but klov shows a cocktail cab, and the robotron drawing set shows two (cocktail) sets of dual joysticks.", /* control_details */
  &robotron_get_ctrl_name
};

const char *robotron_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICKLEFT_UP: return "Move Up";
    case IPT_JOYSTICKLEFT_DOWN: return "Move Down";
    case IPT_JOYSTICKLEFT_LEFT: return "Move Left";
    case IPT_JOYSTICKLEFT_RIGHT: return "Move Right";
    case IPT_JOYSTICKRIGHT_UP: return "Fire Up";
    case IPT_JOYSTICKRIGHT_DOWN: return "Fire Down";
    case IPT_JOYSTICKRIGHT_LEFT: return "Fire Left";
    case IPT_JOYSTICKRIGHT_RIGHT: return "Fire Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo rocnrope_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &rocnrope_get_ctrl_name
};

const char *rocnrope_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Rope";
    case IPT_BUTTON2: return BTN2 "Flash";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo rollerg_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The two buttons have other uses besides those labeled, but you will be prompted on how to use them during gameplay.", /* control_details */
  &rollerg_get_ctrl_name
};

const char *rollerg_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo rthunder_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The buttons are mirrored on both sides of the joystick. There are three settings for the type of control panel: 'Type A Upright' (1 joystick, alternating), 'Type B Cocktail--no flip' (2 joysticks, alternating), and 'Type C Cocktail--flip' (2 joysticks, alternating). Those with normal 2 joystick upright cabs will be happy with the Type B setting.", /* control_details */
  &rthunder_get_ctrl_name
};

const char *rthunder_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo rranger_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The original cpo used icons, but they are very cryptic. 'Shoot' sported a rather understandable gun icon, but 'Jump' had an icon of overlapping up and down arrows.", /* control_details */
  &rranger_get_ctrl_name
};

const char *rranger_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jump";
    case IPT_BUTTON2: return BTN2 "Shoot";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo roundup_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The original panel has the same button either side of the joystick so can be played with either hand", /* control_details */
  &roundup_get_ctrl_name
};

const char *roundup_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Cube Color Select";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo royalmah_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &royalmah_get_ctrl_name
};

const char *royalmah_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo rungun_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Please note that although all 4 player inputs are in mame you can NOT play a 2 on 2 game. The original 4-player cab was actually two cabinets linked together. Since mame doesn't emulate the link or the second monitor, this game is 2 player only.", /* control_details */
  &rungun_get_ctrl_name
};

const char *rungun_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "A";
    case IPT_BUTTON2: return BTN2 "B";
    case IPT_BUTTON3: return BTN3 "C";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo runaway_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The hi / low shifter was actually a plastic switch, but it operates just like a high / low shifter in mame so it's mapped it to that. The jump button was unlabeled on the original cpo.", /* control_details */
  &runaway_get_ctrl_name
};

const char *runaway_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Switcher";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "Forward / Reverse";
  } /* end of switch */

  return "";
}

const struct ControlInfo kirarast_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &kirarast_get_ctrl_name
};

const char *kirarast_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo stunrun_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "Even though the yoke's buttons have seperate inputs, they seem to both perform the same function.", /* control_details */
  &stunrun_get_ctrl_name
};

const char *stunrun_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire (left)";
    case IPT_BUTTON2: return BTN2 "Fire (right)";
    case IPT_AD_STICK_X: return "Left";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "Right";
    case IPT_AD_STICK_Y: return "Up";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo salamand_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &salamand_get_ctrl_name
};

const char *salamand_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Missile";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo searchar_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &searchar_get_ctrl_name
};

const char *searchar_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_DIAL: return "Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo sarge_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The buttons are mirrored across both sticks. They are labeled generically because you can control various vehicles in the game and they have different functions for each. This game driver has hacked in inputs that allow you to play the game with a regular joystick. To disable these hacked inputs you need to either disable cheats or remap the hacked inputs to 'none' in the input menu.", /* control_details */
  &sarge_get_ctrl_name
};

const char *sarge_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Trigger Switch";
    case IPT_BUTTON2: return BTN2 "Thumb Button";
    case IPT_JOYSTICKLEFT_UP: return "Left Tread Forward";
    case IPT_JOYSTICKLEFT_DOWN: return "Left Tread Backward";
    case IPT_JOYSTICKRIGHT_UP: return "Right Tread Forward";
    case IPT_JOYSTICKRIGHT_DOWN: return "Right Tread Backward";
  } /* end of switch */

  return "";
}

const struct ControlInfo satansat_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The joystick had the typical generic 'control' caption below it.", /* control_details */
  &satansat_get_ctrl_name
};

const char *satansat_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Firing Button";
    case IPT_BUTTON2: return BTN2 "Laser Beam";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo shollow_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This game actually uses a gorf-style trigger stick, but a restrictor is used to make it 2-way.", /* control_details */
  &shollow_get_ctrl_name
};

const char *shollow_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Shield";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo scandal_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &scandal_get_ctrl_name
};

const char *scandal_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo scramble_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &scramble_get_ctrl_name
};

const char *scramble_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Laser";
    case IPT_BUTTON2: return BTN2 "Bombs";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Slow";
    case IPT_JOYSTICK_RIGHT: return "Fast";
  } /* end of switch */

  return "";
}

const struct ControlInfo sdi_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "For those of you who have 'fraken-panels' this is the game for you. This game uses the extremely odd combination of a top-fire 8-way joystick and a trackball. All controls are required too so forget about playing this game unless you have those controls.", /* control_details */
  &sdi_get_ctrl_name
};

const char *sdi_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Move Up";
    case IPT_JOYSTICK_DOWN: return "Move Down";
    case IPT_JOYSTICK_LEFT: return "Move Left";
    case IPT_JOYSTICK_RIGHT: return "Move Right";
    case IPT_TRACKBALL_X: return "Aim Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Aim Right";
    case IPT_TRACKBALL_Y: return "Aim Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Aim Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo seawolf_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "The 'paddle' is actually a periscope you look through and turn. The field of view you have when looking through the scope helps you aim. Mame displays a cross hair to help you aim, you can turn it off with the F1 key.", /* control_details */
  &seawolf_get_ctrl_name
};

const char *seawolf_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire Torpedo";
    case IPT_PADDLE: return "Left";
    case (IPT_PADDLE + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo seawolf2_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The 'paddle' is actually a periscope you look through and turn. The field of view you have when looking through the scope helps you aim. Mame displays a cross hair to help you aim, you can turn it off with the F1 key.", /* control_details */
  &seawolf2_get_ctrl_name
};

const char *seawolf2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire Torpedo";
    case IPT_PADDLE: return "Left";
    case (IPT_PADDLE + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo secolove_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &secolove_get_ctrl_name
};

const char *secolove_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo seiha_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &seiha_get_ctrl_name
};

const char *seiha_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo sengokmj_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &sengokmj_get_ctrl_name
};

const char *sengokmj_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo shdancer_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Pull joystick down and push ATTACK button to send your dog to attack your opponents. To wipe out everything on the screen use NINJA MAGIC button.", /* control_details */
  &shdancer_get_ctrl_name
};

const char *shdancer_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "Ninja Magic";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo shadoww_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Yes, although it is rare to see the game with it's original layout, it was designed to be played with a top-fire joystick.", /* control_details */
  &shadoww_get_ctrl_name
};

const char *shadoww_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "Grab";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo sharkatt_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The cpo labels the joystick as 'shark control.'  Above both buttons are the words 'press to'  (as in press to thrust or press to munch).", /* control_details */
  &sharkatt_get_ctrl_name
};

const char *sharkatt_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Munch";
    case IPT_BUTTON2: return BTN2 "Thrust";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo sshooter_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &sshooter_get_ctrl_name
};

const char *sshooter_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_LIGHTGUN_X: return "Aim Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Aim Right";
    case IPT_LIGHTGUN_Y: return "Aim Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Aim Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo sheriff_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "NOTE  The input emulation is correct in mame, but this games real life controls are NOT dual 8-ways. The game used a 8 way joystick and a special rotary dial with a trigger, which used absolute positon. Basically it acted like an 8way joystick that stays in the direction you point it.", /* control_details */
  &sheriff_get_ctrl_name
};

const char *sheriff_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICKLEFT_UP: return "Up";
    case IPT_JOYSTICKLEFT_DOWN: return "Down";
    case IPT_JOYSTICKLEFT_LEFT: return "Left";
    case IPT_JOYSTICKLEFT_RIGHT: return "Right";
    case IPT_JOYSTICKRIGHT_UP: return "Aim Up";
    case IPT_JOYSTICKRIGHT_DOWN: return "Aim Down";
    case IPT_JOYSTICKRIGHT_LEFT: return "Aim Left";
    case IPT_JOYSTICKRIGHT_RIGHT: return "Aim Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo shinobi_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "CP is a generic SEGA CP, with buttons arranged in a triangle.", /* control_details */
  &shinobi_get_ctrl_name
};

const char *shinobi_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "Ninja Magic";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo shootout_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The 'jump' label is misleading. While moving left or right you press it to roll out of the way. The button is only effective while moving.", /* control_details */
  &shootout_get_ctrl_name
};

const char *shootout_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo shootbul_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &shootbul_get_ctrl_name
};

const char *shootbul_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo shuffle_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Please note that the actual cpo shows the generic arrows shooting out from the trackball with the caption 'control puck'  this has been left out for length reasons. Also the button caption may not exactly be 'game select' but this cpo was screened directly over the metal, and thus it's very difficult to find a completely readable one.", /* control_details */
  &shuffle_get_ctrl_name
};

const char *shuffle_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Game Select";
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo shufshot_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &shufshot_get_ctrl_name
};

const char *shufshot_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Zoom";
    case IPT_BUTTON2: return BTN2 "Wax";
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo sidearms_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &sidearms_get_ctrl_name
};

const char *sidearms_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire Left";
    case IPT_BUTTON2: return BTN2 "Fire Right";
    case IPT_BUTTON3: return BTN3 "Power";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo sidetrac_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Note that the original game used a generic exidy panel and thus the button was unlabeled.", /* control_details */
  &sidetrac_get_ctrl_name
};

const char *sidetrac_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Speed Up";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo sinistar_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &sinistar_get_ctrl_name
};

const char *sinistar_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Sinibomb";
    case IPT_AD_STICK_X: return "Left";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "Right";
    case IPT_AD_STICK_Y: return "Up";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo skullxbo_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "CP has 2 sword buttons either side of joystick, and 1 turn button directly below joystick. This just allows for left/right handed players - both sword buttons are wired to same input.", /* control_details */
  &skullxbo_get_ctrl_name
};

const char *skullxbo_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Sword";
    case IPT_BUTTON2: return BTN2 "Turn";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo skydiver_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This game actually used a parachute ripcord mounted as a 2-way joystick. You adjust for the wind by moving the cord left or right and pull up on it to release the chute.", /* control_details */
  &skydiver_get_ctrl_name
};

const char *skydiver_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jump";
    case IPT_BUTTON2: return BTN2 "Open Chute";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo skysoldr_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &skysoldr_get_ctrl_name
};

const char *skysoldr_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Cannon";
    case IPT_BUTTON2: return BTN2 "Missle";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo slapfigh_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The game is 2 player alternating, with a cocktail mode. As with all alternating cocktail games, a separate input is for the second player when the video flips for the second player.", /* control_details */
  &slapfigh_get_ctrl_name
};

const char *slapfigh_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Weapon Select";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo slikshot_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The 'trackball' is actually an entire section of a pool table, with a cue ball, cue stick, and various sensors to track their movement. The buttons are lighted when they are required and you are prompted on screen as to which to press.", /* control_details */
  &slikshot_get_ctrl_name
};

const char *slikshot_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Yellow";
    case IPT_BUTTON2: return BTN2 "Green";
    case IPT_BUTTON3: return BTN3 "Red";
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo slither_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &slither_get_ctrl_name
};

const char *slither_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire Down";
    case IPT_BUTTON2: return BTN2 "Fire Up";
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo slyspy_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &slyspy_get_ctrl_name
};

const char *slyspy_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo smashtv_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The joysticks were just globally labeled 'move' and 'fire'", /* control_details */
  &smashtv_get_ctrl_name
};

const char *smashtv_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICKLEFT_UP: return "Move Up";
    case IPT_JOYSTICKLEFT_DOWN: return "Move Down";
    case IPT_JOYSTICKLEFT_LEFT: return "Move Left";
    case IPT_JOYSTICKLEFT_RIGHT: return "Move Right";
    case IPT_JOYSTICKRIGHT_UP: return "Fire Up";
    case IPT_JOYSTICKRIGHT_DOWN: return "Fire Down";
    case IPT_JOYSTICKRIGHT_LEFT: return "Fire Left";
    case IPT_JOYSTICKRIGHT_RIGHT: return "Fire Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo snakjack_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &snakjack_get_ctrl_name
};

const char *snakjack_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Sneeze Button";
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo snapjack_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The cpo generically labeled the entire joystick 'control'.", /* control_details */
  &snapjack_get_ctrl_name
};

const char *snapjack_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo snowbros_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Snow Bros is listed as using an 8-way joystick, though only left and right are used during gameplay.", /* control_details */
  &snowbros_get_ctrl_name
};

const char *snowbros_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot and Kick Snowball";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "N/A";
    case IPT_JOYSTICK_UP: return "N/A";
  } /* end of switch */

  return "";
}

const struct ControlInfo solarfox_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "it should be noted that the triger button was also mirrored on the control panel itself.", /* control_details */
  &solarfox_get_ctrl_name
};

const char *solarfox_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Speed Control";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo solarq_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "", /* control_details */
  &solarq_get_ctrl_name
};

const char *solarq_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Thrust";
    case IPT_BUTTON3: return BTN3 "Hyper Space";
    case IPT_BUTTON4: return BTN4 "Nova";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo amazon_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &amazon_get_ctrl_name
};

const char *amazon_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo sbm_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This game is unplayable on anyone's layout. It used a series of photo sensors and a punching pad, along with boxing gloves to make a 'punching sim'. Mame maps the impact position on the pad to the directional arrows and the speed is calculated by the photo sensors. Player 2 joystick may also do something. It doesn't really matter as the game is unplayable. Interesting side note.... The original machine was responsible for several lawsuits as the pad wasn't padded enough and people injured themselves hitting it.", /* control_details */
  &sbm_get_ctrl_name
};

const char *sbm_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Sensor 1";
    case IPT_BUTTON2: return BTN2 "Sensor 2";
    case IPT_BUTTON3: return BTN3 "Sensor 3";
    case IPT_BUTTON4: return BTN4 "Sensor 4";
    case IPT_JOYSTICK_UP: return "Aim Up";
    case IPT_JOYSTICK_DOWN: return "Aim Down";
    case IPT_JOYSTICK_LEFT: return "Aim Left";
    case IPT_JOYSTICK_RIGHT: return "Aim Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo souledge_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The original control panel actually has attack with arrows going left and right for 'Attack A' and attack with arrows going up and down for 'Attack B'  On some panels you will see this game with the labels A,B,K,G", /* control_details */
  &souledge_get_ctrl_name
};

const char *souledge_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack A";
    case IPT_BUTTON2: return BTN2 "Attack B";
    case IPT_BUTTON3: return BTN3 "Kick";
    case IPT_BUTTON4: return BTN4 "Guard";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo sspaceat_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Space Invader type game.", /* control_details */
  &sspaceat_get_ctrl_name
};

const char *sspaceat_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_LEFT: return "Control Left";
    case IPT_JOYSTICK_RIGHT: return "Control Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo spacduel_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Note that the 2 player start button does NOT function as a start button, rather a game select button. The good news is you can play a 2 player game on a single quarter!", /* control_details */
  &spacduel_get_ctrl_name
};

const char *spacduel_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Thrust";
    case IPT_BUTTON3: return BTN3 "Shield";
    case IPT_JOYSTICK_LEFT: return "Rotate Left";
    case IPT_JOYSTICK_RIGHT: return "Rotate Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo spacefb_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The game's cpo used nautical labels above the directional buttons and arrows below them. Since we aren't all sailors, the arrow directions are included.", /* control_details */
  &spacefb_get_ctrl_name
};

const char *spacefb_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Warp";
    case IPT_JOYSTICK_LEFT: return "Port (Left)";
    case IPT_JOYSTICK_RIGHT: return "Starboard (Right)";
  } /* end of switch */

  return "";
}

const struct ControlInfo spacfury_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &spacfury_get_ctrl_name
};

const char *spacfury_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Thrust";
    case IPT_JOYSTICK_LEFT: return "Rotate Left";
    case IPT_JOYSTICK_RIGHT: return "Rotate Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo spacegun_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &spacegun_get_ctrl_name
};

const char *spacegun_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Trigger";
    case IPT_BUTTON2: return BTN2 "Bomb Select";
    case IPT_BUTTON3: return BTN3 "Back Up";
    case IPT_LIGHTGUN_X: return "Aim Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Aim Right";
    case IPT_LIGHTGUN_Y: return "Aim Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Aim Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo sharrier_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "If you are wondering why there are three 'shot' buttons, you are not alone. The trigger on the flight stick shoots and there are two buttons on the control panel that also shoot. They all have the same function, but for documentation's sake all three will be included.", /* control_details */
  &sharrier_get_ctrl_name
};

const char *sharrier_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shot";
    case IPT_BUTTON2: return BTN2 "Shot";
    case IPT_BUTTON3: return BTN3 "Shot";
    case IPT_AD_STICK_X: return "Left";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "Right";
    case IPT_AD_STICK_Y: return "Up";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo invaders_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The game cpo image uses 'control' as the label for the joystick. I modified it slightly to avoid confusion. The midway version of the game (invaders) actually used directional buttons instead of the joystick. The Taito version (Sitv) used the two-way joystick.", /* control_details */
  &invaders_get_ctrl_name
};

const char *invaders_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_RIGHT: return "Control Right";
    case IPT_JOYSTICK_LEFT: return "Control Left";
  } /* end of switch */

  return "";
}

const struct ControlInfo spacedx_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &spacedx_get_ctrl_name
};

const char *spacedx_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo invadpt2_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Taito version of this game (invadpt2) used a directional joystick. The Midway version (invaddlx) replaced the joystick with directional buttons. The buttons were labelled 'Laser Base Control' with arrows.", /* control_details */
  &invadpt2_get_ctrl_name
};

const char *invadpt2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire Laser";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
  } /* end of switch */

  return "";
}

const struct ControlInfo spacelnc_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &spacelnc_get_ctrl_name
};

const char *spacelnc_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Launch";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo spaceod_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The cpo has very subtle icons integrated into the artwork. A death-ray like beam eminates from the 'laser' button while bombs appear to be dropping out of the 'bomb' button.", /* control_details */
  &spaceod_get_ctrl_name
};

const char *spaceod_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Laser";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo panic_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This game has a cocktail mode, so player 2 inputs are defined in mame.", /* control_details */
  &panic_get_ctrl_name
};

const char *panic_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Holing";
    case IPT_BUTTON2: return BTN2 "Closing";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo spacezap_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "A very simple game. the directional buttons point the laser up, down, left or right. Shoot all the aliens before they destroy the base.", /* control_details */
  &spacezap_get_ctrl_name
};

const char *spacezap_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo speakres_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The cpo generically labels the joystick 'control.'", /* control_details */
  &speakres_get_ctrl_name
};

const char *speakres_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo spectar_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The fire decal also has an icon of a rocket.", /* control_details */
  &spectar_get_ctrl_name
};

const char *spectar_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo spdcoin_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &spdcoin_get_ctrl_name
};

const char *spdcoin_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo speedfrk_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "Speed is controlled by the shifter. Pressing the pedal makes the car move forward at the selected speed. Stay on the road and avoid all cars to avoid crashing.", /* control_details */
  &speedfrk_get_ctrl_name
};

const char *speedfrk_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_DIAL: return "Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo speedrcr_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The game has three volcano buttons mounted on the control panel, these buttons are used to fire the three weapons on your car. They are unlabeled but are referred to as A, B, and C in the game's test menu. The start button doubles as a jump button. In mame an extra button and an extra pedal are defined but this doesn't reflect the original hardware.", /* control_details */
  &speedrcr_get_ctrl_name
};

const char *speedrcr_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "A";
    case IPT_BUTTON2: return BTN2 "B";
    case IPT_BUTTON3: return BTN3 "C";
    case IPT_PADDLE: return "Left";
    case (IPT_PADDLE + IPT_EXTENSION): return "Right";
    case IPT_PEDAL: return "Accelerate";
  } /* end of switch */

  return "";
}

const struct ControlInfo spidman_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &spidman_get_ctrl_name
};

const char *spidman_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo spiders_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Teh original cpo simply depicts two arrows with the label 'Movement'.", /* control_details */
  &spiders_get_ctrl_name
};

const char *spiders_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_LEFT: return "Move Left";
    case IPT_JOYSTICK_RIGHT: return "Move Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo sprint1_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "Note that the gear buttons are remapped from the button defaults. The number labels denote shift position.", /* control_details */
  &sprint1_get_ctrl_name
};

const char *sprint1_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Accelerate";
    case IPT_BUTTON2: return BTN2 "1";
    case IPT_BUTTON3: return BTN3 "2";
    case IPT_BUTTON4: return BTN4 "3";
    case IPT_BUTTON5: return BTN5 "4";
    case IPT_DIAL: return "Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo starcas_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mame simulates this game using a 2-way joystick, but the actual game used Directional buttons labeled Left and Right. There was also a Rock-Ola version of the Control Panel (black background) which used pictograms for the button labels. Controls were the same, however.", /* control_details */
  &starcas_get_ctrl_name
};

const char *starcas_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Thrust";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
  } /* end of switch */

  return "";
}

const struct ControlInfo starforc_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &starforc_get_ctrl_name
};

const char *starforc_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo stargrds_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The player start buttons double as the 'Weapon' button and the cpo labels it so.", /* control_details */
  &stargrds_get_ctrl_name
};

const char *stargrds_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICKLEFT_UP: return "Move Up";
    case IPT_JOYSTICKLEFT_DOWN: return "Move Down";
    case IPT_JOYSTICKLEFT_LEFT: return "Move Left";
    case IPT_JOYSTICKLEFT_RIGHT: return "Move Right";
    case IPT_JOYSTICKRIGHT_UP: return "Shoot Up";
    case IPT_JOYSTICKRIGHT_DOWN: return "Shoot Down";
    case IPT_JOYSTICKRIGHT_LEFT: return "Shoot Left";
    case IPT_JOYSTICKRIGHT_RIGHT: return "Shoot Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo starhawk_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Each player has an 8-way Joystick with a Fire Button on top. There are three buttons on the control panel that control the speed of the targeting crosshairs. Shoot as many ships as possible.", /* control_details */
  &starhawk_get_ctrl_name
};

const char *starhawk_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Slow";
    case IPT_BUTTON3: return BTN3 "Medium";
    case IPT_BUTTON4: return BTN4 "Fast";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo starjack_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "On the original control panel, the start buttons were double-wired to the bomb buttons.", /* control_details */
  &starjack_get_ctrl_name
};

const char *starjack_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo startrek_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &startrek_get_ctrl_name
};

const char *startrek_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Thrust";
    case IPT_BUTTON3: return BTN3 "Photons";
    case IPT_BUTTON4: return BTN4 "Warp";
    case IPT_DIAL: return "Rotate Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Rotate Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo starwars_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Buttons correspond to the Trigger and Thumb buttons on the yoke. Aircraft style controls, moving control down moves aiming cursor up.", /* control_details */
  &starwars_get_ctrl_name
};

const char *starwars_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Fire";
    case IPT_BUTTON3: return BTN3 "Fire";
    case IPT_BUTTON4: return BTN4 "Fire";
    case IPT_AD_STICK_X: return "Left";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "Right";
    case IPT_AD_STICK_Y: return "Up";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo stargate_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Joystick is on left side of control panel with reverse button the the right of it so it can be hit with thumb. Fire and thrust are on right side of control panel with smart bomb, inviso, and hyperspace to the left in a 45 degree angle.", /* control_details */
  &stargate_get_ctrl_name
};

const char *stargate_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "FIRE";
    case IPT_BUTTON2: return BTN2 "THRUST";
    case IPT_BUTTON3: return BTN3 "SMART BOMB";
    case IPT_BUTTON4: return BTN4 "REVERSE";
    case IPT_BUTTON5: return BTN5 "INVISO";
    case IPT_BUTTON6: return BTN6 "HYPERSPACE";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo sgunner_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &sgunner_get_ctrl_name
};

const char *sgunner_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Missile";
    case IPT_LIGHTGUN_X: return "Aim Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Aim Right";
    case IPT_LIGHTGUN_Y: return "Aim Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Aim Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo sgunner2_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &sgunner2_get_ctrl_name
};

const char *sgunner2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Missile";
    case IPT_LIGHTGUN_X: return "Aim Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Aim Right";
    case IPT_LIGHTGUN_Y: return "Aim Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Aim Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo stocker_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "", /* control_details */
  &stocker_get_ctrl_name
};

const char *stocker_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "High / Low";
    case IPT_DIAL: return "Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo stratab_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This game only has one start button. You press it multiple times for up to 4 players. Mame has two player inputs for cocktail modes, so a person must assume that in cocktail mode teams take turns with the two control panels.", /* control_details */
  &stratab_get_ctrl_name
};

const char *stratab_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Hook Left";
    case IPT_BUTTON2: return BTN2 "Hook Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo stratgyx_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This game used a very stylish, metal, top-fire joystick.", /* control_details */
  &stratgyx_get_ctrl_name
};

const char *stratgyx_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Tank Fire";
    case IPT_BUTTON2: return BTN2 "Turrent Rotate Left";
    case IPT_BUTTON3: return BTN3 "Turrent Rotate Right";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo sf_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The original, dedicated, Street Fighter cabinet only had two, giant, semi-analog buttons. How hard the button was pressed determined which of the three attack strengths registered. The conversion kit and second revision of this game used the classic sf2 layout well all know and love.", /* control_details */
  &sf_get_ctrl_name
};

const char *sf_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Light Punch";
    case IPT_BUTTON2: return BTN2 "Middle Punch";
    case IPT_BUTTON3: return BTN3 "Heavy Punch";
    case IPT_BUTTON4: return BTN4 "Light Kick";
    case IPT_BUTTON5: return BTN5 "Middle Kick";
    case IPT_BUTTON6: return BTN6 "Heavy Kick";
    case IPT_JOYSTICK_UP: return "Jump";
    case IPT_JOYSTICK_DOWN: return "Crouch";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo sfa2_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &sfa2_get_ctrl_name
};

const char *sfa2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jab Punch";
    case IPT_BUTTON2: return BTN2 "Strong Punch";
    case IPT_BUTTON3: return BTN3 "Fierce Punch";
    case IPT_BUTTON4: return BTN4 "Short Kick";
    case IPT_BUTTON5: return BTN5 "Strong Kick";
    case IPT_BUTTON6: return BTN6 "Roundhouse Kick";
    case IPT_JOYSTICK_UP: return "Jump";
    case IPT_JOYSTICK_DOWN: return "Crouch";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo sfa3_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &sfa3_get_ctrl_name
};

const char *sfa3_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jab Punch";
    case IPT_BUTTON2: return BTN2 "Strong Punch";
    case IPT_BUTTON3: return BTN3 "Fierce Punch";
    case IPT_BUTTON4: return BTN4 "Short Kick";
    case IPT_BUTTON5: return BTN5 "Strong Kick";
    case IPT_BUTTON6: return BTN6 "Roundhouse Kick";
    case IPT_JOYSTICK_UP: return "Jump";
    case IPT_JOYSTICK_DOWN: return "Crouch";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo sfa_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &sfa_get_ctrl_name
};

const char *sfa_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jab Punch";
    case IPT_BUTTON2: return BTN2 "Strong Punch";
    case IPT_BUTTON3: return BTN3 "Fierce Punch";
    case IPT_BUTTON4: return BTN4 "Short Kick";
    case IPT_BUTTON5: return BTN5 "Strong Kick";
    case IPT_BUTTON6: return BTN6 "Roundhouse Kick";
    case IPT_JOYSTICK_UP: return "Jump";
    case IPT_JOYSTICK_DOWN: return "Crouch";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}


const struct ControlInfo sf2_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &sf2_get_ctrl_name
};


const char *sf2_get_ctrl_name(int type)
{
  switch(type)
  {
    case (IPT_OSD_DESCRIPTION): return "8-way Joystick+joy8way";
    case IPT_BUTTON1: return BTN1 "Jab Punch";
    case IPT_BUTTON2: return BTN2 "Strong Punch";
    case IPT_BUTTON3: return BTN3 "Fierce Punch";
    case IPT_BUTTON4: return BTN4 "Short Kick";
    case IPT_BUTTON5: return BTN5 "Forward Kick";
    case IPT_BUTTON6: return BTN6 "Roundhouse Kick";
    case IPT_JOYSTICK_UP:    return "Jump";
    case IPT_JOYSTICK_DOWN:  return "Crouch";
    case IPT_JOYSTICK_LEFT:  return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo sfiii2_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &sfiii2_get_ctrl_name
};

const char *sfiii2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jab Punch";
    case IPT_BUTTON2: return BTN2 "Strong Punch";
    case IPT_BUTTON3: return BTN3 "Fierce Punch";
    case IPT_BUTTON4: return BTN4 "Short Kick";
    case IPT_BUTTON5: return BTN5 "Strong Kick";
    case IPT_BUTTON6: return BTN6 "Roundhouse Kick";
    case IPT_JOYSTICK_UP: return "Jump";
    case IPT_JOYSTICK_DOWN: return "Crouch";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo sfiii3_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &sfiii3_get_ctrl_name
};

const char *sfiii3_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jab Punch";
    case IPT_BUTTON2: return BTN2 "Strong Punch";
    case IPT_BUTTON3: return BTN3 "Fierce Punch";
    case IPT_BUTTON4: return BTN4 "Short Kick";
    case IPT_BUTTON5: return BTN5 "Strong Kick";
    case IPT_BUTTON6: return BTN6 "Roundhouse Kick";
    case IPT_JOYSTICK_UP: return "Jump";
    case IPT_JOYSTICK_DOWN: return "Crouch";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo sfiii_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &sfiii_get_ctrl_name
};

const char *sfiii_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jab Punch";
    case IPT_BUTTON2: return BTN2 "Strong Punch";
    case IPT_BUTTON3: return BTN3 "Fierce Punch";
    case IPT_BUTTON4: return BTN4 "Short Kick";
    case IPT_BUTTON5: return BTN5 "Strong Kick";
    case IPT_BUTTON6: return BTN6 "Roundhouse Kick";
    case IPT_JOYSTICK_UP: return "Jump";
    case IPT_JOYSTICK_DOWN: return "Crouch";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo sftm_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &sftm_get_ctrl_name
};

const char *sftm_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Light Punch";
    case IPT_BUTTON2: return BTN2 "Middle Punch";
    case IPT_BUTTON3: return BTN3 "Heavy Punch";
    case IPT_BUTTON4: return BTN4 "Light Kick";
    case IPT_BUTTON5: return BTN5 "Middle Kick";
    case IPT_BUTTON6: return BTN6 "Heavy Kick";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo strider_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &strider_get_ctrl_name
};

const char *strider_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Sword";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo sbowling_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &sbowling_get_ctrl_name
};

const char *sbowling_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo strkforc_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The 'weapon' refers to your secondary weapon. Also note that the start button transforms your ship and on the original panel, the start button was labeled 'Start/Transform'", /* control_details */
  &strkforc_get_ctrl_name
};

const char *strkforc_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Weapon Select";
    case IPT_BUTTON2: return BTN2 "Fire";
    case IPT_BUTTON3: return BTN3 "Weapon";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo s1945_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &s1945_get_ctrl_name
};

const char *s1945_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo s1945iii_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &s1945iii_get_ctrl_name
};

const char *s1945iii_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Loop";
    case IPT_BUTTON3: return BTN3 "Special";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo subs_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This game is essentially unplayable in mame because in the original game, the two monitors were on opposite ends of the cab. Player 1 couldn't see player 2 and vice-versa. In mame the two monitors are combiend and thus it runs the effect.", /* control_details */
  &subs_get_ctrl_name
};

const char *subs_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire Torpedo";
    case IPT_DIAL: return "Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo ssriders_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &ssriders_get_ctrl_name
};

const char *ssriders_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo sbagman_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The action button picks things up and drops them.", /* control_details */
  &sbagman_get_ctrl_name
};

const char *sbagman_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Action";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo sbrkout_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The original game used a 3-position rotary switch to select between 3 different variations: Progressive, Double, and Cavity.", /* control_details */
  &sbrkout_get_ctrl_name
};

const char *sbrkout_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Serve";
    case IPT_BUTTON2: return BTN2 "Progressive";
    case IPT_BUTTON3: return BTN3 "Double";
    case IPT_BUTTON4: return BTN4 "Cavity";
    case (IPT_PADDLE + IPT_EXTENSION): return "Right";
    case IPT_PADDLE: return "Left";
  } /* end of switch */

  return "";
}

const struct ControlInfo scobra_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The original CP labelled both buttons as 'Discharge Buttons.'  Sidewinder Missile is a bit of an overstatement for little tiny blips.", /* control_details */
  &scobra_get_ctrl_name
};

const char *scobra_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Sidewinder Missile";
    case IPT_BUTTON2: return BTN2 "Bombs";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo scontra_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &scontra_get_ctrl_name
};

const char *scontra_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo spdodgeb_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Press boht buttons to jump.", /* control_details */
  &spdodgeb_get_ctrl_name
};

const char *spdodgeb_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Offensive Throw / Defensive Catch";
    case IPT_BUTTON2: return BTN2 "offensive Pass / Defensive Duck";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo sgemf_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &sgemf_get_ctrl_name
};

const char *sgemf_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Punch";
    case IPT_BUTTON2: return BTN2 "Kick";
    case IPT_BUTTON3: return BTN3 "Special";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo shimpact_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Obviously the action depends upon the position you are playing and what team you are on.", /* control_details */
  &shimpact_get_ctrl_name
};

const char *shimpact_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Action";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo marukin_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &marukin_get_ctrl_name
};

const char *marukin_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo smgp_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "The shifter switches are formula 1 style, meaning that they are mounted behind the wheel for quick shifting.", /* control_details */
  &smgp_get_ctrl_name
};

const char *smgp_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shift Down";
    case IPT_BUTTON2: return BTN2 "Shift Up";
    case IPT_PADDLE: return "Left";
    case (IPT_PADDLE + IPT_EXTENSION): return "Right";
    case IPT_PEDAL: return "Accelerate";
    case IPT_PEDAL2: return "Brake";
  } /* end of switch */

  return "";
}

const struct ControlInfo superpac_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &superpac_get_ctrl_name
};

const char *superpac_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Super Speed";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo spbactn_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "This game was actually a 'video pinball' table with real controls and everything. Note that this game is gonna be unplayable on a panel without pinball buttons.", /* control_details */
  &spbactn_get_ctrl_name
};

const char *spbactn_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Left Flipper";
    case IPT_BUTTON2: return BTN2 "Right Flipper";
    case IPT_BUTTON3: return BTN3 "Plunger";
  } /* end of switch */

  return "";
}

const struct ControlInfo spnchout_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "Each button has a dual function. They are labeled in the order of netrual postion and up respectively. The Hook button only deleivers the knock out blow when the screen flashes to use it. The Hook button is a huge plunger button, similar to what you would see on a gameshow.", /* control_details */
  &spnchout_get_ctrl_name
};

const char *spnchout_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Left Blow to Head/Body";
    case IPT_BUTTON2: return BTN2 "Right Blow to Head/Body";
    case IPT_BUTTON3: return BTN3 "Uppercut / Hook / Knock Out Blow";
    case IPT_JOYSTICK_UP: return "Guard Up";
    case IPT_JOYSTICK_DOWN: return "Guard Down";
    case IPT_JOYSTICK_LEFT: return "Dodge Left";
    case IPT_JOYSTICK_RIGHT: return "Dodge Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo sqix_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &sqix_get_ctrl_name
};

const char *sqix_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Draw";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo srmp7_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &srmp7_get_ctrl_name
};

const char *srmp7_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo srmp2_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &srmp2_get_ctrl_name
};

const char *srmp2_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo srmp3_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &srmp3_get_ctrl_name
};

const char *srmp3_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo srmp4_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &srmp4_get_ctrl_name
};

const char *srmp4_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo sspeedr_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "Please note that with default mame mappings, the shifter and gas pedal will interfere with each other.", /* control_details */
  &sspeedr_get_ctrl_name
};

const char *sspeedr_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "High / Low";
    case IPT_DIAL: return "Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
    case IPT_PEDAL: return "Accelerate";
  } /* end of switch */

  return "";
}

const struct ControlInfo ssprint_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Player one is blue, Player 2 is Red, Player 3 is yellow.", /* control_details */
  &ssprint_get_ctrl_name
};

const char *ssprint_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
    case IPT_DIAL: return "Left";
    case IPT_PEDAL: return "Gas";
  } /* end of switch */

  return "";
}

const struct ControlInfo ssf2_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The ssf2 cpo image I found was very fuzzy. If you have a DEDICATED ssf2 cpo image please correct any mistakes I might have made. The labels to this game are very important as not only is it one of the very last dedicated capcom fighter cabs, but it's labels become the 'universal standard' for future capcom fighters.", /* control_details */
  &ssf2_get_ctrl_name
};

const char *ssf2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jab Punch";
    case IPT_BUTTON2: return BTN2 "Strong Punch";
    case IPT_BUTTON3: return BTN3 "Fierce Punch";
    case IPT_BUTTON4: return BTN4 "Short Kick";
    case IPT_BUTTON5: return BTN5 "Strong Kick";
    case IPT_BUTTON6: return BTN6 "Roundhouse Kick";
    case IPT_JOYSTICK_UP: return "Jump";
    case IPT_JOYSTICK_DOWN: return "Crouch";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo sstrike_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The 'trackball' actually consists of a small scale version of the beginning of a bowling alley and a cue ball with various sensors to track it's movement. This game basically recycles the hardware of Slick Shot into a bowling game.", /* control_details */
  &sstrike_get_ctrl_name
};

const char *sstrike_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Right Hook";
    case IPT_BUTTON2: return BTN2 "Left Hook";
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo stonebal_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "", /* control_details */
  &stonebal_get_ctrl_name
};

const char *stonebal_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot/Fight";
    case IPT_BUTTON2: return BTN2 "Pass/Tackle";
    case IPT_BUTTON3: return BTN3 "Push";
  } /* end of switch */

  return joy4way_labels(type);
}

const struct ControlInfo szaxxon_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The control panel had duplicate Fire buttons on the panel, as well as the joystick trigger button. The Joystick had an LED that would light up when the trigger was pulled. Aircraft style controls - Pulling back on the joystick causes aircraft to climb.", /* control_details */
  &szaxxon_get_ctrl_name
};

const char *szaxxon_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo superman_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Hold Punch button down momentarily to release Blast Punch. During shooting scenes the Kick button actually emits Heat Vision instead of kicking.", /* control_details */
  &superman_get_ctrl_name
};

const char *superman_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Punch";
    case IPT_BUTTON2: return BTN2 "Kick";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo swimmer_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &swimmer_get_ctrl_name
};

const char *swimmer_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Dive";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo tnk3_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This rotary is a unique one. It almost looks like a dial at first glance, but the dial can also be shifted in 8 directions, just like a rotary 8-way.", /* control_details */
  &tnk3_get_ctrl_name
};

const char *tnk3_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Cannon";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_DIAL: return "Aim Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Aim Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo ttmahjng_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &ttmahjng_get_ctrl_name
};

const char *ttmahjng_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo tailg_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "The original game had an ambidexterous setup. The controls were setup as Shield, Fire, Site Control(Joystick), Fire, Shield.", /* control_details */
  &tailg_get_ctrl_name
};

const char *tailg_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Shield";
    case IPT_AD_STICK_X: return "Left";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "Right";
    case IPT_AD_STICK_Y: return "Up";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo hotgmck_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &hotgmck_get_ctrl_name
};

const char *hotgmck_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo hotgmck3_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &hotgmck3_get_ctrl_name
};

const char *hotgmck3_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo hgkairak_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &hgkairak_get_ctrl_name
};

const char *hgkairak_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo fromanc2_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &fromanc2_get_ctrl_name
};

const char *fromanc2_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo fromanc4_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &fromanc4_get_ctrl_name
};

const char *fromanc4_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo fromancr_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &fromancr_get_ctrl_name
};

const char *fromancr_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo tank8_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Note that this game lacks any labels. This is probably due to the self-explainatory layout. Also not that oddly enough, on this game the trigger button is NOT mirroed to the left stick. The only trigger is on the right one.", /* control_details */
  &tank8_get_ctrl_name
};

const char *tank8_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICKLEFT_UP: return "Left Tread Forward";
    case IPT_JOYSTICKLEFT_DOWN: return "Left Tread Backward";
    case IPT_JOYSTICKRIGHT_UP: return "Right Tread Forward";
    case IPT_JOYSTICKRIGHT_DOWN: return "Right Tread Backward";
  } /* end of switch */

  return "";
}

const struct ControlInfo tankbatt_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &tankbatt_get_ctrl_name
};

const char *tankbatt_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo tapper_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This game used a real beer tap instead of a shifter. You pull down on the tap to pour and release to serve. In mame it's emulated as a single button.", /* control_details */
  &tapper_get_ctrl_name
};

const char *tapper_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Pour / Serve";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo targ_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &targ_get_ctrl_name
};

const char *targ_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo tazmania_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &tazmania_get_ctrl_name
};

const char *tazmania_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Zapper";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo tbowl_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &tbowl_get_ctrl_name
};

const char *tbowl_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Start / Jump";
    case IPT_BUTTON2: return BTN2 "Snap / Pass / Tackle / Kick";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo tmnt_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Pressing both buttons does a special attack.", /* control_details */
  &tmnt_get_ctrl_name
};

const char *tmnt_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jump";
    case IPT_BUTTON2: return BTN2 "Attack";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo tmnt2_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Both buttons do a special attack.", /* control_details */
  &tmnt2_get_ctrl_name
};

const char *tmnt2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jump";
    case IPT_BUTTON2: return BTN2 "Attack";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo tehkanwc_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Two buttons were usually wired to the same single button input per player, one on each side of the TB. Mame has a hack so you can play with 8-way joyaticks, but the original had trackballs /* control_details */ mame also has the trackballs, but since no keys are mapped to the TBs (to enable the joystick hack), the TBs don't show in the tab input menu. There apparently were joystick bootlegs of this game; mame only has one version, so the bootlegs might have been hardware hacks no just the inputs (or mame is missing the different ROMs).", /* control_details */
  &tehkanwc_get_ctrl_name
};

const char *tehkanwc_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Kick";
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo tekken_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The cpo itself in this game labels the punch and kick buttons as just 'punch' and 'kick' grouped. The bezel labes them in detail. Please note that the punch buttons are on the top row of the tekken games, so remap accordingly.", /* control_details */
  &tekken_get_ctrl_name
};

const char *tekken_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Left Punch";
    case IPT_BUTTON2: return BTN2 "Right Punch";
    case IPT_BUTTON3: return BTN3 "Left Kick";
    case IPT_BUTTON4: return BTN4 "Right Kick";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo tekken2_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The cpo itself in this game labels the punch and kick buttons as just 'punch' and 'kick' grouped. The bezel labes them in detail. Please note that the punch buttons are on the top row of the tekken games, so remap accordingly.", /* control_details */
  &tekken2_get_ctrl_name
};

const char *tekken2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Left Punch";
    case IPT_BUTTON2: return BTN2 "Right Punch";
    case IPT_BUTTON3: return BTN3 "Left Kick";
    case IPT_BUTTON4: return BTN4 "Right Kick";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo tekken3_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The cpo itself in this game labels the punch and kick buttons as just 'punch' and 'kick' grouped. The bezel labes them in detail. Please note that the punch buttons are on the top row of the tekken games, so remap accordingly.", /* control_details */
  &tekken3_get_ctrl_name
};

const char *tekken3_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Left Punch";
    case IPT_BUTTON2: return BTN2 "Right Punch";
    case IPT_BUTTON3: return BTN3 "Left Kick";
    case IPT_BUTTON4: return BTN4 "Right Kick";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo telmahjn_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &telmahjn_get_ctrl_name
};

const char *telmahjn_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo tempest_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Super Zapper kills all enemies. Three Zaps per level.", /* control_details */
  &tempest_get_ctrl_name
};

const char *tempest_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Super Zapper";
    case IPT_DIAL: return "Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo tengai_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Mame lists 3 buttons although only 2 actually work", /* control_details */
  &tengai_get_ctrl_name
};

const char *tengai_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_BUTTON3: return BTN3 "??";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo term2_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &term2_get_ctrl_name
};

const char *term2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Trigger";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_LIGHTGUN_X: return "Aim Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Aim Right";
    case IPT_LIGHTGUN_Y: return "Aim Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Aim Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo terracre_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &terracre_get_ctrl_name
};

const char *terracre_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Formation";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo terraf_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &terraf_get_ctrl_name
};

const char *terraf_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Formation";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo atetris_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Atari Tetris uses a 4-way joystick, though only 3 positions are connected/used (left,right,down). Also the rotate button starts the game. We don't label it start though because on every single tetris machine there is a seperate start button which is apparently wired to button 1 to avoid confusion.", /* control_details */
  &atetris_get_ctrl_name
};

const char *atetris_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Rotate";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "";
  } /* end of switch */

  return "";
}

const struct ControlInfo tetris_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &tetris_get_ctrl_name
};

const char *tetris_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Rotate";
    case IPT_JOYSTICK_UP: return "";
    case IPT_JOYSTICK_DOWN: return "Drop";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo tetrisp_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &tetrisp_get_ctrl_name
};

const char *tetrisp_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Rotate";
    case IPT_BUTTON2: return BTN2 "Rotate";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo tetrisp2_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "As everybody knows how to play tetris by the time this game was relased, the controls are completely un-labeled on the real panel.", /* control_details */
  &tetrisp2_get_ctrl_name
};

const char *tetrisp2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Rotate Clockwise";
    case IPT_BUTTON2: return BTN2 "Rotate Anti Clockwise";
    case IPT_BUTTON3: return BTN3 "Bomb";
    case IPT_JOYSTICK_UP: return "";
    case IPT_JOYSTICK_DOWN: return "Drop";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo ctribe_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &ctribe_get_ctrl_name
};

const char *ctribe_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Punch";
    case IPT_BUTTON2: return BTN2 "Kick";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo elecyoyo_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &elecyoyo_get_ctrl_name
};

const char *elecyoyo_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo esb_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Buttons 1 and 4 correspond to the Yoke triggers. Buttons 2 and 3 correspond to the Yoke thumb buttons. These shoot TOW cables on the Probots stages and Fire on the other stages. Game uses aircraft style controls, i.e. pulling the yoke grips down in MAME causes the cursor to move upward.", /* control_details */
  &esb_get_ctrl_name
};

const char *esb_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Fire / Shoot TOW Cable";
    case IPT_BUTTON3: return BTN3 "Fire / Shoot TOW Cable";
    case IPT_BUTTON4: return BTN4 "Fire";
    case IPT_AD_STICK_Y: return "Up";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "Right";
    case IPT_AD_STICK_X: return "Left";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo theend_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &theend_get_ctrl_name
};

const char *theend_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo lkage_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &lkage_get_ctrl_name
};

const char *lkage_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Sword";
    case IPT_BUTTON2: return BTN2 "Star Knives";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo themj_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &themj_get_ctrl_name
};

const char *themj_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mainevt_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The action button was one of those huge, round, lighted buttons.", /* control_details */
  &mainevt_get_ctrl_name
};

const char *mainevt_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Action";
    case IPT_BUTTON2: return BTN2 "Tag";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo ninjaw_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &ninjaw_get_ctrl_name
};

const char *ninjaw_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Dagger";
    case IPT_BUTTON2: return BTN2 "Ninja Star";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo thepit_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &thepit_get_ctrl_name
};

const char *thepit_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo punisher_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &punisher_get_ctrl_name
};

const char *punisher_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo ghostb_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "In the versions in mame, there aren't seperate start buttons. The shoot button doubles as the start button. Mame's driver, however, includes normal seperate start buttons /* control_details */ they don't work. However, it seems like there were versions of this game that had the normal seperate start buttons. There also is a 3 player version. The Mame driver includes player 3 inputs in the 2 player game even though they aren't used.", /* control_details */
  &ghostb_get_ctrl_name
};

const char *ghostb_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot / Start";
    case IPT_BUTTON2: return BTN2 "Beam";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo simpsons_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &simpsons_get_ctrl_name
};

const char *simpsons_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo srumbler_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &srumbler_get_ctrl_name
};

const char *srumbler_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Escape";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo a3stooges_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "In this three player game, which player you are determines which stooge you are. P1=Larry  P2=Curly  P3=Moe", /* control_details */
  &a3stooges_get_ctrl_name
};

const char *a3stooges_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Slap / Throw";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo tinstar_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The game actually had a unique digital dial to aim with. Also mame strangely puts the firing controls on the left stick, even though the dial is on the right of the joystick.", /* control_details */
  &tinstar_get_ctrl_name
};

const char *tinstar_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICKLEFT_UP: return "Aim Up";
    case IPT_JOYSTICKLEFT_DOWN: return "Aim Down";
    case IPT_JOYSTICKLEFT_LEFT: return "Aim Left";
    case IPT_JOYSTICKLEFT_RIGHT: return "Aim Right";
    case IPT_JOYSTICKRIGHT_UP: return "Move Up";
    case IPT_JOYSTICKRIGHT_DOWN: return "Move Down";
    case IPT_JOYSTICKRIGHT_LEFT: return "Move Left";
    case IPT_JOYSTICKRIGHT_RIGHT: return "Move Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo thief_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Pacman like game.", /* control_details */
  &thief_get_ctrl_name
};

const char *thief_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo a3wonders_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "3rd button mapped in mame but not used (AFAIK). This game has 3 games in 1 and the 2 buttons act differently in each game. There doesn't seem to be anything written on the control panel but for game 1 - Attack, Jump 2 - Attack, Special Attack 3 - Push Block, Push Block", /* control_details */
  &a3wonders_get_ctrl_name
};

const char *a3wonders_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "??";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo thndrbld_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "The upright version of this game sported a force-feedback joystick, while the cockpit version used the force-feedback to shake the whole cockpit!", /* control_details */
  &thndrbld_get_ctrl_name
};

const char *thndrbld_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Grenade";
    case IPT_AD_STICK_X: return "Left";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "Right";
    case IPT_AD_STICK_Y: return "Up";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "Down";
    case IPT_AD_STICK_Z: return "Fast";
    case (IPT_AD_STICK_Z + IPT_EXTENSION): return "Slow";
  } /* end of switch */

  return "";
}

const struct ControlInfo thundfox_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Couldn't find a control panel pic. Press Button 1 for close range attack (punching, stabbing), press button 3 to use the weapon (throw grenade, shoot gun). Need to kneel down to pick up the weapons", /* control_details */
  &thundfox_get_ctrl_name
};

const char *thundfox_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "Weapon";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo thunderj_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &thunderj_get_ctrl_name
};

const char *thunderj_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo tickee_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &tickee_get_ctrl_name
};

const char *tickee_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Trigger";
    case IPT_LIGHTGUN_X: return "Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Right";
    case IPT_LIGHTGUN_Y: return "Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo tigerh_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Shooting the colored crosses provides the following power-ups: White - Forward firing Little Heli, Red - Side Firing Little Heli, Blue - Bomb. A max of two bombs and two little helis are possible. Shooting 10 yellow diamonds awards an additional life.", /* control_details */
  &tigerh_get_ctrl_name
};

const char *tigerh_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Mini-Gun";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo tigeroad_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &tigeroad_get_ctrl_name
};

const char *tigeroad_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo timber_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "OTHER:  The two buttons in mame are actually a two-way joystick. The 4-way joystick is for moving and pushing, the buttons (2-way) chops the wood.", /* control_details */
  &timber_get_ctrl_name
};

const char *timber_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Chop Left";
    case IPT_BUTTON2: return BTN2 "Chop Right";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo timecris_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "The player uses the pedal to rise up from behind cover. teh cryptic label is posted on the control panel, with a giant arrow pointing down. This is probably to make the player aware that there is a pedal on a gun game, which is obviously quite odd.", /* control_details */
  &timecris_get_ctrl_name
};

const char *timecris_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Step on It!";
    case IPT_LIGHTGUN_X: return "Aim Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Aim Right";
    case IPT_LIGHTGUN_Y: return "Aim Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Aim Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo timekill_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The distinction of left and right on these labels isn't which limb you use, but describes the position of the buttons on the control panel. Each player has two arm and leg buttons and they both do different things, even though they are labeld different. On the original control panel the arm buttons are on the top row and the legs are on the bottom with the head button centered, above both rows. So to play this game properly, some remapping will probably be required.", /* control_details */
  &timekill_get_ctrl_name
};

const char *timekill_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Left Arm";
    case IPT_BUTTON2: return BTN2 "Right Arm";
    case IPT_BUTTON3: return BTN3 "Left Leg";
    case IPT_BUTTON4: return BTN4 "Right Leg";
    case IPT_BUTTON5: return BTN5 "Head";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo timeplt_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &timeplt_get_ctrl_name
};

const char *timeplt_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo timesold_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This game used a 12 direction mechanical rotary (SNK LS-30).", /* control_details */
  &timesold_get_ctrl_name
};

const char *timesold_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Hyper Weapon";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_DIAL: return "Rotate Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Rotate Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo titlef_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The game actually used a pair of digital 'twist sticks'  basically, you moved them up and down as normal, but to press left or right you twist them. Explaining how to play is rather complicated as the game uses combinations of both stick movements to do moves.", /* control_details */
  &titlef_get_ctrl_name
};

const char *titlef_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICKLEFT_UP: return "Left Fist Up";
    case IPT_JOYSTICKLEFT_DOWN: return "Left Fist Down";
    case IPT_JOYSTICKLEFT_LEFT: return "Left Fist Left";
    case IPT_JOYSTICKLEFT_RIGHT: return "Left Fist Right";
    case IPT_JOYSTICKRIGHT_UP: return "Right Fist Up";
    case IPT_JOYSTICKRIGHT_DOWN: return "Right Fist Down";
    case IPT_JOYSTICKRIGHT_LEFT: return "Right Fist Left";
    case IPT_JOYSTICKRIGHT_RIGHT: return "Right Fist Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo toki_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &toki_get_ctrl_name
};

const char *toki_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo tmmjprd_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &tmmjprd_get_ctrl_name
};

const char *tmmjprd_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mahmajn_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mahmajn_get_ctrl_name
};

const char *mahmajn_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mahmajn2_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mahmajn2_get_ctrl_name
};

const char *mahmajn2_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo tokyogal_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &tokyogal_get_ctrl_name
};

const char *tokyogal_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo tomahawk_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The cpo has the generic 'control' label under the joystick, which was popular in that era.", /* control_details */
  &tomahawk_get_ctrl_name
};

const char *tomahawk_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo tontonb_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &tontonb_get_ctrl_name
};

const char *tontonb_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo toobin_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The buttons are arranged in a flattened pentagon shape, with the point on the bottom. The throw button is the bottom point, above that are the two forward buttons, and the two back buttons on the top. The original CP used the throw button also as the start /* control_details */ Mame has a seperate 'start' button, but both mame's 'throw' and 'start' buttons throw and start. Mame labels the five buttons a little differently than the original CP: 'throw', 'R Paddle Forward', 'L Paddle Forward', 'L Paddle Backward', and 'R Paddle backward'.", /* control_details */
  &toobin_get_ctrl_name
};

const char *toobin_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Throw Can / Start";
    case IPT_BUTTON2: return BTN2 "Paddle Forward (Right)";
    case IPT_BUTTON3: return BTN3 "Paddle Forward (Left)";
    case IPT_BUTTON4: return BTN4 "Back Paddle (Left)";
    case IPT_BUTTON5: return BTN5 "Back Paddle (Right)";
  } /* end of switch */

  return "";
}

const struct ControlInfo topspeed_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "This game has a ton of extra inputs that show up do to a digital hack. Ignore them as buttons 1-4 is all you need.", /* control_details */
  &topspeed_get_ctrl_name
};

const char *topspeed_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Accelerate";
    case IPT_BUTTON2: return BTN2 "Brake";
    case IPT_BUTTON3: return BTN3 "Nitro";
    case IPT_BUTTON4: return BTN4 "Hi / Lo";
    case IPT_PADDLE: return "Left";
    case (IPT_PADDLE + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo totcarn_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The start button is used in the game to speed up or skip hints, and to place mines/bombs.", /* control_details */
  &totcarn_get_ctrl_name
};

const char *totcarn_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICKLEFT_UP: return "Move Up";
    case IPT_JOYSTICKLEFT_DOWN: return "Move Down";
    case IPT_JOYSTICKLEFT_LEFT: return "Move Left";
    case IPT_JOYSTICKLEFT_RIGHT: return "Move Right";
    case IPT_JOYSTICKRIGHT_UP: return "Fire Up";
    case IPT_JOYSTICKRIGHT_DOWN: return "Fire Down";
    case IPT_JOYSTICKRIGHT_LEFT: return "Fire Left";
    case IPT_JOYSTICKRIGHT_RIGHT: return "Fire Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo tdfever_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "You'll usually only see a two player version of this game as the 4 player used a specialized cocktail cabinet.", /* control_details */
  &tdfever_get_ctrl_name
};

const char *tdfever_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Run";
    case IPT_BUTTON2: return BTN2 "Pass";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_DIAL: return "Rotate Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Rotate Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo toypop_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The only know control panel image of this game shows two trivia style buttons labeled 'shoot' on either side of the joysticks. Of course this is just a mirrored layout.", /* control_details */
  &toypop_get_ctrl_name
};

const char *toypop_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo trackfld_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &trackfld_get_ctrl_name
};

const char *trackfld_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Run";
    case IPT_BUTTON2: return BTN2 "Jump/Throw";
    case IPT_BUTTON3: return BTN3 "Run";
  } /* end of switch */

  return "";
}

const struct ControlInfo tranqgun_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &tranqgun_get_ctrl_name
};

const char *tranqgun_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo trisport_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &trisport_get_ctrl_name
};

const char *trisport_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Set / Start";
    case IPT_BUTTON2: return BTN2 "Select";
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo triplhnt_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "This lightgun is actually a shotgun mounted to the cabinet.", /* control_details */
  &triplhnt_get_ctrl_name
};

const char *triplhnt_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_LIGHTGUN_X: return "Aim Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Aim Right";
    case IPT_LIGHTGUN_Y: return "Aim Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Aim Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo statriv2_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "The game also has two 'play 1000' buttons defined in mame. These appear to be service buttons to change the question packs.", /* control_details */
  &statriv2_get_ctrl_name
};

const char *statriv2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "A";
    case IPT_BUTTON2: return BTN2 "B";
    case IPT_BUTTON3: return BTN3 "C";
    case IPT_BUTTON4: return BTN4 "D";
  } /* end of switch */

  return "";
}

const struct ControlInfo gtsers8_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The lighted trivia buttons are actually blank, as is the control panel overlay. There are  labeled arrows on the screen that point to the appropriate button. (Note:  even though all sources, evne the original game machines point ot alternating 2 player gameplay, it doesn't seem to work in mame... it's probably a bug.)", /* control_details */
  &gtsers8_get_ctrl_name
};

const char *gtsers8_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "1";
    case IPT_BUTTON2: return BTN2 "2";
    case IPT_BUTTON3: return BTN3 "3";
    case IPT_BUTTON4: return BTN4 "4";
    case IPT_BUTTON5: return BTN5 "5";
  } /* end of switch */

  return "";
}

const struct ControlInfo gt507uk_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The lighted trivia buttons are actually blank, as is the control panel overlay. There are  labeled arrows on the screen that point to the appropriate button. (Note:  even though all sources, evne the original game machines point ot alternating 2 player gameplay, it doesn't seem to work in mame... it's probably a bug.)", /* control_details */
  &gt507uk_get_ctrl_name
};

const char *gt507uk_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "1";
    case IPT_BUTTON2: return BTN2 "2";
    case IPT_BUTTON3: return BTN3 "3";
    case IPT_BUTTON4: return BTN4 "4";
    case IPT_BUTTON5: return BTN5 "5";
  } /* end of switch */

  return "";
}

const struct ControlInfo gt5_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The lighted trivia buttons are actually blank, as is the control panel overlay. There are  labeled arrows on the screen that point to the appropriate button. (Note:  even though all sources, evne the original game machines point ot alternating 2 player gameplay, it doesn't seem to work in mame... it's probably a bug.)", /* control_details */
  &gt5_get_ctrl_name
};

const char *gt5_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "1";
    case IPT_BUTTON2: return BTN2 "2";
    case IPT_BUTTON3: return BTN3 "3";
    case IPT_BUTTON4: return BTN4 "4";
    case IPT_BUTTON5: return BTN5 "5";
  } /* end of switch */

  return "";
}

const struct ControlInfo trvgns_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The lighted trivia buttons are actually blank, as is the contorl panel overlay. The game itself has arrows pointing down to the appropriate button. Also note that buttons a-d also act as the star buttons, again with an arrow pointing towards which is which. (A = 1 player game, B= 2 players, ect)", /* control_details */
  &trvgns_get_ctrl_name
};

const char *trvgns_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "A";
    case IPT_BUTTON2: return BTN2 "B";
    case IPT_BUTTON3: return BTN3 "C";
    case IPT_BUTTON4: return BTN4 "D";
  } /* end of switch */

  return "";
}

const struct ControlInfo triviasp_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "When a question is asked, a possible answer is displayed. You either press correct to select the given answer, or press incorrect until the correct answer is displayed and then press correct to confirm. Mame has a bunch of extra inputs defined, but all you should be concerned with are the 'red' (incorrect) and 'green' (correct) buttons.", /* control_details */
  &triviasp_get_ctrl_name
};

const char *triviasp_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Correct";
    case IPT_BUTTON2: return BTN2 "Incorrect";
  } /* end of switch */

  return "";
}

const struct ControlInfo triviabb_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "When a question is asked, a possible answer is displayed. You either press correct to select the given answer, or press incorrect until the correct answer is displayed and then press correct to confirm. Mame has a bunch of extra inputs defined, but all you should be concerned with are the 'red' (incorrect) and 'green' (correct) buttons.", /* control_details */
  &triviabb_get_ctrl_name
};

const char *triviabb_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Correct";
    case IPT_BUTTON2: return BTN2 "Incorrect";
  } /* end of switch */

  return "";
}

const struct ControlInfo triviag1_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "When a question is asked, a possible answer is displayed. You either press correct to select the given answer, or press incorrect until the correct answer is displayed and then press correct to confirm. Mame has a bunch of extra inputs defined, but all you should be concerned with are the 'red' (incorrect) and 'green' (correct) buttons.", /* control_details */
  &triviag1_get_ctrl_name
};

const char *triviag1_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Correct";
    case IPT_BUTTON2: return BTN2 "Incorrect";
  } /* end of switch */

  return "";
}

const struct ControlInfo triviag2_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "When a question is asked, a possible answer is displayed. You either press correct to select the given answer, or press incorrect until the correct answer is displayed and then press correct to confirm. Mame has a bunch of extra inputs defined, but all you should be concerned with are the 'red' (incorrect) and 'green' (correct) buttons.", /* control_details */
  &triviag2_get_ctrl_name
};

const char *triviag2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Correct";
    case IPT_BUTTON2: return BTN2 "Incorrect";
  } /* end of switch */

  return "";
}

const struct ControlInfo triviayp_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "When a question is asked, a possible answer is displayed. You either press correct to select the given answer, or press incorrect until the correct answer is displayed and then press correct to confirm. Mame has a bunch of extra inputs defined, but all you should be concerned with are the 'red' (incorrect) and 'green' (correct) buttons.", /* control_details */
  &triviayp_get_ctrl_name
};

const char *triviayp_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Correct";
    case IPT_BUTTON2: return BTN2 "Incorrect";
  } /* end of switch */

  return "";
}

const struct ControlInfo trog_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Like many 4 player games, which character you choose determines which controls you'll use and vice-versa.", /* control_details */
  &trog_get_ctrl_name
};

const char *trog_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Punch";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo tron_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The joystick in this game was unique. It was an 8-way leaf joystick with a larqe actuator and a diagonal 4-way restrictor making it possible (but difficult) to hit the diagonals. The 4-way mode was useful for the Tanks stage, and necessary for the Light Cycle stage. Controls worked as follows: Light Cycles: The joystick controls the direction of travel and the trigger controls the speed of the bike. Grid Bugs: The stick controls the movement of your character and the spinner controls the direction of fire. Tanks: The stick controls the movement of your tank and the spinner controls the direction of fire. MCP Cone: The stick controls the movement of your character and the spinner controls the direction of fire.", /* control_details */
  &tron_get_ctrl_name
};

const char *tron_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_DIAL: return "Aim Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Aim Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo tubep_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "this game doesn't have any labels.", /* control_details */
  &tubep_get_ctrl_name
};

const char *tubep_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo tunhunt_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "", /* control_details */
  &tunhunt_get_ctrl_name
};

const char *tunhunt_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Shield";
    case IPT_AD_STICK_X: return "Left";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "Right";
    case IPT_AD_STICK_Y: return "Up";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo turbo_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "The shifter doesn't appear to work properly. The lo button seems to act more like a brake than anything else even though the game doesn't have a brake. The hi button toggles gears.", /* control_details */
  &turbo_get_ctrl_name
};

const char *turbo_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Accelerate";
    case IPT_BUTTON2: return BTN2 "Lo";
    case IPT_BUTTON3: return BTN3 "Hi";
    case IPT_DIAL: return "Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo turbofrc_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "3rd player in mame not working??", /* control_details */
  &turbofrc_get_ctrl_name
};

const char *turbofrc_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo toutrun_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "The shifter has a side button for turbo, thus the name of the game.", /* control_details */
  &toutrun_get_ctrl_name
};

const char *toutrun_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "High / Low";
    case IPT_BUTTON2: return BTN2 "Turbo";
    case IPT_PADDLE: return "Left";
    case (IPT_PADDLE + IPT_EXTENSION): return "Right";
    case IPT_PEDAL: return "Accelerate";
    case IPT_PEDAL2: return "Brake";
  } /* end of switch */

  return "";
}

const struct ControlInfo tshoot_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Grenade Button is actually mounted on top of the machine gun. Technically it counts as a part of the gun, but the button itself is a stock lighted button. This game had an interesting gimmick where feathers were blown in front of the screen between two layers of plexi if a round was successful. Somone should take advantage of mame's switchable artwork system and re-create this effect via a series of feather animations.", /* control_details */
  &tshoot_get_ctrl_name
};

const char *tshoot_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Grenade";
    case IPT_BUTTON3: return BTN3 "Gobble!";
    case IPT_LIGHTGUN_X: return "Aim Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Aim Right";
    case IPT_LIGHTGUN_Y: return "Aim Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Aim Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo tutankhm_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The fire buttons are actually supposed to be a 2 way joystick, but for whatever reason, the mame driver sets them as buttons.", /* control_details */
  &tutankhm_get_ctrl_name
};

const char *tutankhm_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire Left";
    case IPT_BUTTON2: return BTN2 "Fire Right";
    case IPT_BUTTON3: return BTN3 "Flash";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo twincobr_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &twincobr_get_ctrl_name
};

const char *twincobr_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo twineagl_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The conversion kit came with ?Button? and ?Missile? labels even though the flyer and the conversion manual state they are ?Bomb? and ?Missile? buttons", /* control_details */
  &twineagl_get_ctrl_name
};

const char *twineagl_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Missile";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo twineag2_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &twineag2_get_ctrl_name
};

const char *twineag2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_BUTTON3: return BTN3 "Special";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo twotiger_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Mame used to incorrectly define this game as a spinner. Now it properly shows up as a one-axis yoke. The 'misc' entry was added to show that it doesn't use the traditional star wars, 2-axis yoke. The three player start button selects dogfight mode.", /* control_details */
  &twotiger_get_ctrl_name
};

const char *twotiger_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_BUTTON3: return BTN3 "Speed";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "Right";
    case IPT_AD_STICK_X: return "Left";
    case IPT_AD_STICK_Y: return "";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "";
  } /* end of switch */

  return "";
}

const struct ControlInfo earthjkr_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Hold down A to increase shot power", /* control_details */
  &earthjkr_get_ctrl_name
};

const char *earthjkr_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "A-Shoot";
    case IPT_BUTTON2: return BTN2 "B-Bomb";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo unsquad_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &unsquad_get_ctrl_name
};

const char *unsquad_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Special Weapon";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo vball_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "A hits the ball and B jumps.", /* control_details */
  &vball_get_ctrl_name
};

const char *vball_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "A";
    case IPT_BUTTON2: return BTN2 "B";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo usclssic_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &usclssic_get_ctrl_name
};

const char *usclssic_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Select Club";
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo ultramhm_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &ultramhm_get_ctrl_name
};

const char *ultramhm_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo ultratnk_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &ultratnk_get_ctrl_name
};

const char *ultratnk_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICKLEFT_UP: return "Up";
    case IPT_JOYSTICKLEFT_DOWN: return "Down";
    case IPT_JOYSTICKRIGHT_UP: return "Up";
    case IPT_JOYSTICKRIGHT_DOWN: return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo utoukond_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &utoukond_get_ctrl_name
};

const char *utoukond_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "Bomb";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo undrfire_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The guns second buton is a shotgun pump.", /* control_details */
  &undrfire_get_ctrl_name
};

const char *undrfire_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_LIGHTGUN_X: return "Aim Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Aim Right";
    case IPT_LIGHTGUN_Y: return "Aim Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Aim Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo uniwars_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &uniwars_get_ctrl_name
};

const char *uniwars_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Firing Button";
    case IPT_JOYSTICK_LEFT: return "Control Lever (Left)";
    case IPT_JOYSTICK_RIGHT: return "Control Lever (Right)";
  } /* end of switch */

  return "";
}

const struct ControlInfo upndown_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &upndown_get_ctrl_name
};

const char *upndown_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo valkyrie_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Hold down attack button to use magic.", /* control_details */
  &valkyrie_get_ctrl_name
};

const char *valkyrie_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "??";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo vandyke_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &vandyke_get_ctrl_name
};

const char *vandyke_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo vanguard_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The buttons on this control panel are arranged in a diamond shape. As each button fires in a different direction it is very difficult to play this game without a diamond patterened layout. Also the joystick is labeled control, but for obvious reasons the labels in this entry have the usual labeling.", /* control_details */
  &vanguard_get_ctrl_name
};

const char *vanguard_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire Back";
    case IPT_BUTTON2: return BTN2 "Fire Forward";
    case IPT_BUTTON3: return BTN3 "Fire Down";
    case IPT_BUTTON4: return BTN4 "Fire Up";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo varth_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &varth_get_ctrl_name
};

const char *varth_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Special";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo vendetta_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &vendetta_get_ctrl_name
};

const char *vendetta_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Punch";
    case IPT_BUTTON2: return BTN2 "Kick";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo venture_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &venture_get_ctrl_name
};

const char *venture_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo victory_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The game used a tempest style spinner, three round lighted buttons for normal functions, and a large, rectangular, trivia-style button for the doomsday weapon activation.", /* control_details */
  &victory_get_ctrl_name
};

const char *victory_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Thrust";
    case IPT_BUTTON3: return BTN3 "Shields";
    case IPT_BUTTON4: return BTN4 "Doomsday";
    case IPT_DIAL: return "Rotate Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Rotate Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo victroad_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &victroad_get_ctrl_name
};

const char *victroad_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Grenade";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_DIAL: return "Rotate Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Rotate Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo hustler_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The joystick is a twist joystick.", /* control_details */
  &hustler_get_ctrl_name
};

const char *hustler_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
  } /* end of switch */

  return "";
}

const struct ControlInfo videopin_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This game had a control panel that repliactes real pinball controls. It even had a section you could nudge in the front and a plunger. The plunger appears to be digital, but since it really adds to the feel of the game, I tacked on the 'other' flag. The hardcoded defaults for the flippers are left ctrl and right ctrl. It is suggested that you place a videopin.ini in your personal ctrlr folder and remap them to match visual pinball defaults.", /* control_details */
  &videopin_get_ctrl_name
};

const char *videopin_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Left Flipper";
    case IPT_BUTTON2: return BTN2 "Right Flipper";
    case IPT_BUTTON3: return BTN3 "Nudge";
    case IPT_JOYSTICK_UP: return "";
    case IPT_JOYSTICK_DOWN: return "Pull plunger";
  } /* end of switch */

  return "";
}

const struct ControlInfo vigilant_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This game lacks labels for the buttons, even on the official cpo and in the manual. These are simply the actions they do. Trivia:  The cpo of this game has 'I'm Bad!' graffiti on it which is a tribute to the game BadDudes, relased by the same company eariler that year. In that game the character would yell the phrase at the end of each level.", /* control_details */
  &vigilant_get_ctrl_name
};

const char *vigilant_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Punch";
    case IPT_BUTTON2: return BTN2 "Kick";
    case IPT_JOYSTICK_UP: return "Jump";
    case IPT_JOYSTICK_DOWN: return "Duck";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo vimana_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "If you hold the shoot button for a while you increase the spread of your bullets.", /* control_details */
  &vimana_get_ctrl_name
};

const char *vimana_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_BUTTON2: return BTN2 "Circle Bomb";
    case IPT_BUTTON3: return BTN3 "??";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo vindictr_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "There are two button on each stick (trigger and thumb buttons). The thumb buttons are to rotate the tanks' turrent if you bought the ability to rotate (and it's not damaged). The right trigger is the normal fire button, the left trigger button is to fire the special weapon. If you have different types of special weapons, the start is used to switch between the different types. The odd numbered buttons are the triggers and the even numbered ones are the thumb switches for the left and right joysticks respectively. Note:  If you have cheats enabled the game inputs are hacked to use a 4way joystick as the controls. There isn't an option to turn it off in the cheat menu, so if you wish to play the game correctly, turn cheats off.", /* control_details */
  &vindictr_get_ctrl_name
};

const char *vindictr_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Special";
    case IPT_BUTTON2: return BTN2 "Rotate left";
    case IPT_BUTTON3: return BTN3 "Fire";
    case IPT_BUTTON4: return BTN4 "Rotate right";
    case IPT_JOYSTICKRIGHT_UP: return "Right forward";
    case IPT_JOYSTICKLEFT_DOWN: return "Left back";
    case IPT_JOYSTICKLEFT_UP: return "Left forward";
    case IPT_JOYSTICKRIGHT_DOWN: return "Right back";
  } /* end of switch */

  return "";
}

const struct ControlInfo vindctr2_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "There are two button on each stick (trigger and thumb buttons). The thumb buttons are to rotate the tanks' turrent if you bought the ability to rotate (and it's not damaged). The right trigger is the normal fire button, the left trigger button is to fire the special weapon. If you have different types of special weapons, the start is used to switch between the different types. The odd numbered buttons are the trigger sticks and the even numbered ones are the thumbsticks on the left and right stck respectively.", /* control_details */
  &vindctr2_get_ctrl_name
};

const char *vindctr2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "special";
    case IPT_BUTTON2: return BTN2 "rotate left";
    case IPT_BUTTON3: return BTN3 "fire";
    case IPT_BUTTON4: return BTN4 "rotate right";
    case IPT_JOYSTICKRIGHT_UP: return "Right forward";
    case IPT_JOYSTICKLEFT_DOWN: return "Left back";
    case IPT_JOYSTICKLEFT_UP: return "Left forward";
    case IPT_JOYSTICKRIGHT_DOWN: return "Right back";
  } /* end of switch */

  return "";
}

const struct ControlInfo viofight_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "As this game is a taito game, it is generally sold as a convrsion kit with the buttons mounted in a 'double dragon' layout with the punch/kick buttons at the bottom of the triangle. Pressing punch and jump at the smae time does a special move. Also the offical cpo doesn't have any labels for anything. This is based on parts of the manual and documentation for teh game.", /* control_details */
  &viofight_get_ctrl_name
};

const char *viofight_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Punch";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "Kick";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo viper_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "This game actually uses two trigger sticks that are mounted stationary on the montior, which moves as you pull on the sticks. As you pull, the area of the screen moves as well. This gives the illusion that you are manning a gun turrent. Each stick has two thumb buttons but there are only two inputs. To confuse things even more, both inputs do the same thing. (Fire)", /* control_details */
  &viper_get_ctrl_name
};

const char *viper_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Fire";
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo vf_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Note that on a real vf cabinet the defense button was to the left adn slightly below the punch button. Those of you with neogeo layouts shoudl have not problem replicating the layout.", /* control_details */
  &vf_get_ctrl_name
};

const char *vf_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Punch";
    case IPT_BUTTON2: return BTN2 "Kick";
    case IPT_BUTTON3: return BTN3 "Defense";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo vf2_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Note that on a real vf2 cabinet the defense button was to the left adn slightly below the punch button. Those of you with neogeo layouts shoudl have not problem replicating the layout.", /* control_details */
  &vf2_get_ctrl_name
};

const char *vf2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Punch";
    case IPT_BUTTON2: return BTN2 "Kick";
    case IPT_BUTTON3: return BTN3 "Defense";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo vsgongf_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &vsgongf_get_ctrl_name
};

const char *vsgongf_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "A";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo rbibb_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &rbibb_get_ctrl_name
};

const char *rbibb_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "A";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo balonfgt_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &balonfgt_get_ctrl_name
};

const char *balonfgt_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "A";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo vsbball_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &vsbball_get_ctrl_name
};

const char *vsbball_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "A";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo btlecity_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &btlecity_get_ctrl_name
};

const char *btlecity_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "A";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo cstlevna_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &cstlevna_get_ctrl_name
};

const char *cstlevna_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "A";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo cluclu_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &cluclu_get_ctrl_name
};

const char *cluclu_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "A";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo drmario_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &drmario_get_ctrl_name
};

const char *drmario_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "A";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo duckhunt_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &duckhunt_get_ctrl_name
};

const char *duckhunt_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "A";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo excitebk_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &excitebk_get_ctrl_name
};

const char *excitebk_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "A";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo vsfdf_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &vsfdf_get_ctrl_name
};

const char *vsfdf_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "A";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo vsgradus_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &vsgradus_get_ctrl_name
};

const char *vsgradus_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "A";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo vsgshoe_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &vsgshoe_get_ctrl_name
};

const char *vsgshoe_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_LIGHTGUN_X: return "Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Right";
    case IPT_LIGHTGUN_Y: return "Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo hogalley_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &hogalley_get_ctrl_name
};

const char *hogalley_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_LIGHTGUN_X: return "Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Right";
    case IPT_LIGHTGUN_Y: return "Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo hotsmash_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. This game is unique to the system in that it uses a spinner. As it's one of the last games released for the system, it can be assumed that this is the only vs game to do so.", /* control_details */
  &hotsmash_get_ctrl_name
};

const char *hotsmash_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_DIAL: return "Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo iceclimb_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &iceclimb_get_ctrl_name
};

const char *iceclimb_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "A";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo iceclmrj_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &iceclmrj_get_ctrl_name
};

const char *iceclmrj_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "A";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo machridr_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &machridr_get_ctrl_name
};

const char *machridr_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "A";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo vsmahjng_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &vsmahjng_get_ctrl_name
};

const char *vsmahjng_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo mightybj_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &mightybj_get_ctrl_name
};

const char *mightybj_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "A";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo jajamaru_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &jajamaru_get_ctrl_name
};

const char *jajamaru_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "A";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo vspinbal_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &vspinbal_get_ctrl_name
};

const char *vspinbal_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "A";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo platoon_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &platoon_get_ctrl_name
};

const char *platoon_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "A";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo bnglngby_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &bnglngby_get_ctrl_name
};

const char *bnglngby_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "A";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo vsslalom_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &vsslalom_get_ctrl_name
};

const char *vsslalom_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jump";
    case IPT_JOYSTICK_UP: return "Lean Forward";
    case IPT_JOYSTICK_DOWN: return "Brake";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo vssoccer_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &vssoccer_get_ctrl_name
};

const char *vssoccer_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "A";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo starlstr_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &starlstr_get_ctrl_name
};

const char *starlstr_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "A";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo smgolf_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &smgolf_get_ctrl_name
};

const char *smgolf_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "A";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo suprmrio_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &suprmrio_get_ctrl_name
};

const char *suprmrio_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "A";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo vsskykid_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &vsskykid_get_ctrl_name
};

const char *vsskykid_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "A";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo supxevs_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &supxevs_get_ctrl_name
};

const char *supxevs_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "A";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo tkoboxng_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &tkoboxng_get_ctrl_name
};

const char *tkoboxng_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "A";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo vstennis_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B button, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &vstennis_get_ctrl_name
};

const char *vstennis_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "A";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo vstetris_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &vstetris_get_ctrl_name
};

const char *vstetris_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "A";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo goonies_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &goonies_get_ctrl_name
};

const char *goonies_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "A";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo topgun_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. Although the cabinets had buttons for 3 and 4 player start, most of the games were only two player.", /* control_details */
  &topgun_get_ctrl_name
};

const char *topgun_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "A";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo wrecking_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The Nintendo Vs. System was released along side the original NES game console. The games it plays are virtually identical. This is the earliest known mvs cabinet. Almost all Vs cabinets had a layout exactly like the NES at home, with a joystick, A and B buttons, or a zapper. This cabinet is really two cabinets joined together. Two pairs of people can play two different games at the same time.", /* control_details */
  &wrecking_get_ctrl_name
};

const char *wrecking_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "B";
    case IPT_BUTTON2: return BTN2 "A";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo wacko_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The trackball moves the player. There are two 4-way joysticks, one one each side of the trackball, but they are both wired to the same input. Mame maps both sticks to the left stick of a dual stick combo to avoid the conflicting default keyboard mapping of the normal joystick and the trackball /* control_details */ mame's right stick input type is not used. (Note for HowardC:  Accepted for now, but I'll try to get the mame devs to accept a fixed one. Remapping to avoid conflict is silly as almost everyone maps the 'left joystick' to match their regular joystick. Now if it was mapped to joystick right then I could have seen it.)  Keep an eye on this game for driver changes.", /* control_details */
  &wacko_get_ctrl_name
};

const char *wacko_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
    case IPT_JOYSTICKRIGHT_RIGHT: return "-";
    case IPT_JOYSTICKRIGHT_LEFT: return "-";
    case IPT_JOYSTICKRIGHT_DOWN: return "-";
    case IPT_JOYSTICKRIGHT_UP: return "-";
    case IPT_JOYSTICKLEFT_RIGHT: return "Zap Right";
    case IPT_JOYSTICKLEFT_LEFT: return "Zap Left";
    case IPT_JOYSTICKLEFT_DOWN: return "Zap Down";
    case IPT_JOYSTICKLEFT_UP: return "Zap Up";
    case IPT_TRACKBALL_X: return "Krooz Left";
    case IPT_TRACKBALL_Y: return "Krooz Up";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Krooz Right";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Krooz Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo mj4simai_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &mj4simai_get_ctrl_name
};

const char *mj4simai_get_ctrl_name(int type)
{
  switch(type)
  {
/* P1NumButtons=0 */
  } /* end of switch */

  return "";
}

const struct ControlInfo wargods_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The game uses the same williams/midway classic 'X' layout, so remapping will be required. The only difference is the run button hs ben replaced with a lighted 3d button, which allows you to move on the z-axis. It should be noted that not all revisions use the lighted button and many use a standard pushbutton with the mk3 layout.", /* control_details */
  &wargods_get_ctrl_name
};

const char *wargods_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "High Punch";
    case IPT_BUTTON2: return BTN2 "Block";
    case IPT_BUTTON3: return BTN3 "High Kick";
    case IPT_BUTTON4: return BTN4 "Low Punch";
    case IPT_BUTTON5: return BTN5 "Low Kick";
    case IPT_BUTTON6: return BTN6 "3D";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo wotw_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &wotw_get_ctrl_name
};

const char *wotw_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Shield";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo warlords_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The player buttons simply start the game. They do not do anything else and the mame start buttons are deactivated in this game.", /* control_details */
  &warlords_get_ctrl_name
};

const char *warlords_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Start";
    case IPT_PADDLE: return "Left";
    case (IPT_PADDLE + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo warpwarp_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This game is also known as Warp Warp.", /* control_details */
  &warpwarp_get_ctrl_name
};

const char *warpwarp_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo warrior_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Warrior had two top fire style joysticks, one per player. Moving the joystick would move your knight. Moving the joystick while pressing the button swings the knights sword. You cannot move and fight simultaneously. Movement directions are relative to the screen, not the direction the night is fighting. ie: Left is always toward the left of the screen. The knights are almost always facing each other.", /* control_details */
  &warrior_get_ctrl_name
};

const char *warrior_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Sword";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo suzume_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Mahjong games are NOT compatable with ctrlr files. As a matter of fact they pretty much all have the same layout and all have the same controls. The controls are hardcoded, so remapping isn't reccomended, especially considering the fact that a full keyboard of buttons are required to play.", /* control_details */
  &suzume_get_ctrl_name
};

const char *suzume_get_ctrl_name(int type)
{
  switch(type)
  {
  } /* end of switch */

  return "";
}

const struct ControlInfo wecleman_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "", /* control_details */
  &wecleman_get_ctrl_name
};

const char *wecleman_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Accelerate";
    case IPT_BUTTON2: return BTN2 "Brake";
    case IPT_BUTTON3: return BTN3 "Low Gear";
    case IPT_BUTTON4: return BTN4 "High Gear";
    case IPT_PADDLE: return "Left";
    case (IPT_PADDLE + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo wfortune_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "This game is just like the tv show. Everyone spins the same wheel which is mapped to player one's controls. The wheel is a glorified, oversized, spinner with a wof 'wheel' sticker on top of it. When not spinning, the wheel moves the cursor while the select button selects the action highlighted. It should be noted that the wheel won't spin left while in 'spin the wheel' mode.", /* control_details */
  &wfortune_get_ctrl_name
};

const char *wfortune_get_ctrl_name(int type)
{
  switch(type)
  {
/* P3NumButtons=1 */
    case (IPT_OSD_DESCRIPTION | IPF_PLAYER3): return "";
    case (IPT_BUTTON1 | IPF_PLAYER3): return "Select";
/* P2NumButtons=1 */
    case (IPT_OSD_DESCRIPTION | IPF_PLAYER2): return "";
    case (IPT_BUTTON1 | IPF_PLAYER2): return "Select";
    case IPT_BUTTON1: return BTN1 "Select";
    case IPT_DIAL: return "Spin Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Spin Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo whodunit_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This game actually used a mounted lightgun (or light shotgun I should say) but the 'other' flag that we generally tag onto special controls isn't needed as the game plays just fine with an unmounted lightgun and there have been arcade conversions utilizing unmounted guns.", /* control_details */
  &whodunit_get_ctrl_name
};

const char *whodunit_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_LIGHTGUN_X: return "Left";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Right";
    case IPT_LIGHTGUN_Y: return "Up";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo wildfang_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Special transforms your warrior into a small guy riding a tiger", /* control_details */
  &wildfang_get_ctrl_name
};

const char *wildfang_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "Special";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo moo_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Combinations of Jump, Shoot and a Direction perform various special moves. They are listed on screen as you run across them.", /* control_details */
  &moo_get_ctrl_name
};

const char *moo_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Shoot";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo willow_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Holding attack button will increase the power of the attack", /* control_details */
  &willow_get_ctrl_name
};

const char *willow_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo wizdfire_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &wizdfire_get_ctrl_name
};

const char *wizdfire_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Magic";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo wow_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The original game had a fire button on the left and a ball top joystick on the left.", /* control_details */
  &wow_get_ctrl_name
};

const char *wow_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo wolfpack_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "", /* control_details */
  &wolfpack_get_ctrl_name
};

const char *wolfpack_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_DIAL: return "Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo wboy_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &wboy_get_ctrl_name
};

const char *wboy_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Speed / Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
  } /* end of switch */

  return "";
}

const struct ControlInfo wbml_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &wbml_get_ctrl_name
};

const char *wbml_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Sword";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo wbeachvl_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "3rd button is mapped but not known what it does", /* control_details */
  &wbeachvl_get_ctrl_name
};

const char *wbeachvl_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Hit";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "Unknown";
    case IPT_JOYSTICK_UP: return "Up-Left";
    case IPT_JOYSTICK_DOWN: return "Down-Right";
    case IPT_JOYSTICK_LEFT: return "Left-Down";
    case IPT_JOYSTICK_RIGHT: return "Right-Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo wcbowl_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "When looking in the tab menu it would seem the game is only 2 player, however it is a 4 player game with each player entering the game by pressing the Player1 start button (on the control panel it is just a Start button). Player 2 start button is mapped but doesn?t do anything", /* control_details */
  &wcbowl_get_ctrl_name
};

const char *wcbowl_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Hook Left";
    case IPT_BUTTON2: return BTN2 "Hook Right";
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo wcbowldx_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &wcbowldx_get_ctrl_name
};

const char *wcbowldx_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Hook Left";
    case IPT_BUTTON2: return BTN2 "Hook Right";
    case IPT_TRACKBALL_X: return "Left";
    case (IPT_TRACKBALL_X + IPT_EXTENSION): return "Right";
    case IPT_TRACKBALL_Y: return "Up";
    case (IPT_TRACKBALL_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo wseries_ctrl =
{
  false, /* alternating_controls */
  false, /* mirrored_controls */
  "This is a simultaneous 2 player alternating game /* control_details */ a player is on the left side when pitching, on the right side when batting. The aim button is shown with two physical buttons wired to one pin in the schematics. All buttons are on one input port in the machine; mame puts them all as player 1 inputs, but on the 2 player game, the aim button(s) is more like a player 2 button. (On a one player game, all inputs are like player 1 inputs.)", /* control_details */
  &wseries_get_ctrl_name
};

const char *wseries_get_ctrl_name(int type)
{
  switch(type)
  {
/* P2NumButtons=0 */
    case (IPT_OSD_DESCRIPTION | IPF_PLAYER2): return "Baseball Pitcher+stick";
    case (IPT_AD_STICK_X | IPF_PLAYER2): return "Left";
    case ((IPT_AD_STICK_X + IPT_EXTENSION) | IPF_PLAYER2): return "Right";
    case (IPT_AD_STICK_Y | IPF_PLAYER2): return "Pitch";
    case ((IPT_AD_STICK_Y + IPT_EXTENSION) | IPF_PLAYER2): return "Windup";
    case IPT_BUTTON1: return BTN1 "Go Back";
    case IPT_BUTTON2: return BTN2 "Xtra Base";
    case IPT_BUTTON3: return BTN3 "Aim";
    case IPT_AD_STICK_X: return "Swing";
    case (IPT_AD_STICK_X + IPT_EXTENSION): return "Swing";
    case IPT_AD_STICK_Y: return "Up";
    case (IPT_AD_STICK_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo wsf_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "A and B both do varouis things, depending upon the situation.", /* control_details */
  &wsf_get_ctrl_name
};

const char *wsf_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "A";
    case IPT_BUTTON2: return BTN2 "B";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo wtennis_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The label for the button is unknown. I took an educated guess and take full responsibility for it's accuracy.", /* control_details */
  &wtennis_get_ctrl_name
};

const char *wtennis_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Swing";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo wwfsstar_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Press button A to punch, button B to kick. As with all WWF games, the two buttons do a number of things by pressing different combinations at different times including pin, ect. If anyone wishes to make a list please do so here.", /* control_details */
  &wwfsstar_get_ctrl_name
};

const char *wwfsstar_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "A";
    case IPT_BUTTON2: return BTN2 "B";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo wwfwfest_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "The A and B buttons do various things depending upon the wrestler and the situation. Generally when you can do something special you recieve a message on the screen on how to do so.", /* control_details */
  &wwfwfest_get_ctrl_name
};

const char *wwfwfest_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "A";
    case IPT_BUTTON2: return BTN2 "B";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo wwfmania_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This game has the same mame-related layout problems as the mk games. The X pattern applies. Press punch and kick at the same time to run. Note that the punch buttons are on the top row and the kick buttons are on the bottom, unlike the mk games and similar to sf games.", /* control_details */
  &wwfmania_get_ctrl_name
};

const char *wwfmania_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Punch";
    case IPT_BUTTON2: return BTN2 "Defense";
    case IPT_BUTTON3: return BTN3 "Power Punch";
    case IPT_BUTTON4: return BTN4 "Kick";
    case IPT_BUTTON5: return BTN5 "Power Kick";
    case IPT_JOYSTICK_RIGHT: return "Move Right";
    case IPT_JOYSTICK_LEFT: return "Move Left";
    case IPT_JOYSTICK_DOWN: return "Move Down";
    case IPT_JOYSTICK_UP: return "Move Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo xmen_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &xmen_get_ctrl_name
};

const char *xmen_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_BUTTON3: return BTN3 "Mutant Power";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo xmvsf_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &xmvsf_get_ctrl_name
};

const char *xmvsf_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Punch - Light";
    case IPT_BUTTON2: return BTN2 "Punch - Medium";
    case IPT_BUTTON3: return BTN3 "Punch - Heavy";
    case IPT_BUTTON4: return BTN4 "Kick - Light";
    case IPT_BUTTON5: return BTN5 "Kick - Medium";
    case IPT_BUTTON6: return BTN6 "Kick - Heavy";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo xmcota_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &xmcota_get_ctrl_name
};

const char *xmcota_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Punch - Jab ";
    case IPT_BUTTON2: return BTN2 "Punch - Strong";
    case IPT_BUTTON3: return BTN3 "Punch - Fierce";
    case IPT_BUTTON4: return BTN4 "Kick - Short";
    case IPT_BUTTON5: return BTN5 "Kick - Forward";
    case IPT_BUTTON6: return BTN6 "Kick - Roundhouse";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo xsleena_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Pressing the jump button while already in the air will do a second jump boost. Much of the data on this game is purely speculative as it is a copy of Solar Warrior. It is assumed that they use the same labels.", /* control_details */
  &xsleena_get_ctrl_name
};

const char *xsleena_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo xenophob_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This trigger stick has two thumb buttons in additon to the normal fire button. The left and right buttons each do over a dozen things, with what they do depending upon the message displayed on the screen at the time. They are appropriately labeled 'left button' and 'right button' on the screen.", /* control_details */
  &xenophob_get_ctrl_name
};

const char *xenophob_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire / Punch";
    case IPT_BUTTON2: return BTN2 "Left Button";
    case IPT_BUTTON3: return BTN3 "Right Button";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo xevious_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The labels on the original cpo are the ones in this entry, however they don't really apply to what the buttons do. Button 1 shoots and Button 2 Fires bombs. Because of this the button labels may be swapped as I don't have access to a real machine.", /* control_details */
  &xevious_get_ctrl_name
};

const char *xevious_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Zapper";
    case IPT_BUTTON2: return BTN2 "Blaster";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo xybots_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "This game used a twist stick, not to be confused with a rotary mechanical stick. Basically you can twist the stick left and right for two additional inputs.", /* control_details */
  &xybots_get_ctrl_name
};

const char *xybots_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Turn Left";
    case IPT_BUTTON3: return BTN3 "Turn Right";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo yesnoj_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &yesnoj_get_ctrl_name
};

const char *yesnoj_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Yes";
    case IPT_BUTTON2: return BTN2 "No";
  } /* end of switch */

  return "";
}

const struct ControlInfo yiear_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &yiear_get_ctrl_name
};

const char *yiear_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Punch";
    case IPT_BUTTON2: return BTN2 "Kick";
    case IPT_JOYSTICK_UP: return "Jump";
    case IPT_JOYSTICK_DOWN: return "Stoop Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo yosakdon_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &yosakdon_get_ctrl_name
};

const char *yosakdon_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo yuyugogo_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Game in Japanese. No references available. Buttons relate to the numbers on the screen.", /* control_details */
  &yuyugogo_get_ctrl_name
};

const char *yuyugogo_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "1";
    case IPT_BUTTON2: return BTN2 "2";
    case IPT_BUTTON3: return BTN3 "3";
    case IPT_BUTTON4: return BTN4 "4";
    case IPT_BUTTON5: return BTN5 "??";
  } /* end of switch */

  return "";
}

const struct ControlInfo zaxxon_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "The fire button is also placed on the control panel. The button on the trigger stick lights up when it's time for you to do some shooting.", /* control_details */
  &zaxxon_get_ctrl_name
};

const char *zaxxon_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo zerohour_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &zerohour_get_ctrl_name
};

const char *zerohour_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo zeropnt_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &zeropnt_get_ctrl_name
};

const char *zeropnt_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_LIGHTGUN_Y: return "Up";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Right";
    case IPT_LIGHTGUN_X: return "Left";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo zeropnt2_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &zeropnt2_get_ctrl_name
};

const char *zeropnt2_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Down";
    case IPT_LIGHTGUN_Y: return "Up";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Right";
    case IPT_LIGHTGUN_X: return "Left";
  } /* end of switch */

  return "";
}

const struct ControlInfo zerowing_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "Control wise this game is pretty standard, but the game's claim to fame is the wording of the translated text, or more accurately the poor wording of the translated text. This is commonly referred to as 'Engrish'  Ever wondered where the 'All Your Base Are Belong To Us.' line comes from?  It's this game. So for a good laugh check it out. All your controls are belong to us!!!!", /* control_details */
  &zerowing_get_ctrl_name
};

const char *zerowing_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Shield";
    case IPT_JOYSTICK_RIGHT: return "Right";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_UP: return "Up";
  } /* end of switch */

  return "";
}

const struct ControlInfo zerozone_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &zerozone_get_ctrl_name
};

const char *zerozone_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Rotate";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo zigzag_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This game is a pirated version of digdug. With the execption of a new title, the game plays exactly the same.", /* control_details */
  &zigzag_get_ctrl_name
};

const char *zigzag_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Pump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo zingzip_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &zingzip_get_ctrl_name
};

const char *zingzip_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Bomb";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo zoar_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This is probably the only 2d shooter ever to utilize the z axis. Instead of being able to speedup or slowdown with the up and down directions, these directions allow you to make the craft raise or lower to the ground. The top speed key doesn't appear to do anything until you try to move left or right. When you do you will move much more quickly.", /* control_details */
  &zoar_get_ctrl_name
};

const char *zoar_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "High Missile";
    case IPT_BUTTON2: return BTN2 "Low Missile";
    case IPT_BUTTON3: return BTN3 "Top Speed";
    case IPT_JOYSTICK_UP: return "Gain Altitude";
    case IPT_JOYSTICK_DOWN: return "Lose Altitude";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo zodiack_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &zodiack_get_ctrl_name
};

const char *zodiack_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo zombraid_ctrl =
{
  false, /* alternating_controls */
  true, /* mirrored_controls */
  "Controls were sawed-off shotguns with pump action reload, this is mapped to button 2", /* control_details */
  &zombraid_get_ctrl_name
};

const char *zombraid_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Fire";
    case IPT_BUTTON2: return BTN2 "Reload";
    case IPT_LIGHTGUN_Y: return "Up";
    case (IPT_LIGHTGUN_X + IPT_EXTENSION): return "Right";
    case IPT_LIGHTGUN_X: return "Left";
    case (IPT_LIGHTGUN_Y + IPT_EXTENSION): return "Down";
  } /* end of switch */

  return "";
}

const struct ControlInfo zookeep_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &zookeep_get_ctrl_name
};

const char *zookeep_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Jump";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo zunkyou_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &zunkyou_get_ctrl_name
};

const char *zunkyou_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Attack";
    case IPT_BUTTON2: return BTN2 "Special Attack";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Left";
    case IPT_JOYSTICK_RIGHT: return "Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo zwackery_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "This game has an identical control panel layout as discs of tron. Unfortunately due to the fact that it's a platformer, it is extremely akward to play unless you have those exact controls.", /* control_details */
  &zwackery_get_ctrl_name
};

const char *zwackery_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Sword";
    case IPT_BUTTON2: return BTN2 "Shield";
    case IPT_BUTTON3: return BTN3 "Pick Up";
    case IPT_BUTTON4: return BTN4 "Cast Spell";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
    case IPT_JOYSTICK_LEFT: return "Run Left";
    case IPT_JOYSTICK_RIGHT: return "Run Right";
    case IPT_DIAL: return "Aim Sword Left";
    case (IPT_DIAL + IPT_EXTENSION): return "Aim Sword Right";
  } /* end of switch */

  return "";
}

const struct ControlInfo zzyzzyxx_ctrl =
{
  true, /* alternating_controls */
  true, /* mirrored_controls */
  "", /* control_details */
  &zzyzzyxx_get_ctrl_name
};

const char *zzyzzyxx_get_ctrl_name(int type)
{
  switch(type)
  {
    case IPT_BUTTON1: return BTN1 "Make Brick";
    case IPT_JOYSTICK_UP: return "Up";
    case IPT_JOYSTICK_DOWN: return "Down";
  } /* end of switch */

  return "";
}
