// FBNEO NES/Famicom and FDS emulator
// (c)2019-2020 dink, kev, iq_132

#include "tiles_generic.h"
#include "bitswap.h"
#include "m6502_intf.h"
#include "nes_apu.h"
#include "ay8910.h"			// mapper 69 (sunsoft / gimmick!)
#include "burn_ym2413.h"	// mapper 85 (vrc7 / lagrange point)
#include "burn_gun.h"		// zapper games
#include "burn_led.h"		// fds disk status
#if !defined (_MSC_VER)
#include <unistd.h>         // for unlink()/rename() in ips_patch()/ips_make()
#endif
#include <errno.h>          // .. unlink()/rename()


static UINT8 DrvReset = 0;
static UINT32 DrvPalette[(0x40 * 8) /*nes*/ + 0x100 /*icons*/];
static UINT8 NESRecalc;

static UINT8 NESJoy1[8]     = { 0, 0, 0, 0, 0, 0, 0, 0 };
static UINT8 NESJoy2[8]     = { 0, 0, 0, 0, 0, 0, 0, 0 };
static UINT8 NESJoy3[8]     = { 0, 0, 0, 0, 0, 0, 0, 0 };
static UINT8 NESJoy4[8]     = { 0, 0, 0, 0, 0, 0, 0, 0 };
static UINT8 NESCoin[8]     = { 0, 0, 0, 0, 0, 0, 0, 0 };
static UINT8 DrvInputs[4]   = { 0, 0, 0, 0 };
static UINT8 DrvDips[4]     = { 0, 0, 0, 0 };

static UINT32 JoyShifter[2] = { 0, 0 };
static UINT8 JoyStrobe      = 0;

// Zapper emulation
static INT16 ZapperX;
static INT16 ZapperY;
static UINT8 ZapperFire;
static UINT8 ZapperReload;
static UINT8 ZapperReloadTimer;

// FDS-Buttons
static UINT8 FDSEject;
static UINT8 FDSSwap;

// FDS-Timer (for insert/swap robot)
static UINT32 FDSFrameCounter;
static UINT32 FDSFrameAction;
static UINT32 FDSFrameDiskIcon;

// game-specific options not found in header.  see bottom of cartridge_load()
static UINT32 NESMode = 0;
#define NO_WORKRAM		0x0001 // 6000-7fff reads data openbus
#define BUS_CONFLICTS	0x0002 // rom conflicts with writes, needs special handling
#define ALT_MMC3        0x0004 // alternate mmc3 scanline timing
#define BAD_HOMEBREW    0x0008 // writes OAMDATA while rendering (can't possibly work on a real NES/FC)
#define USE_4SCORE      0x0100 // 4-Player device (NES)
#define USE_HORI4P      0x0200 // 4-Player device Mode 2 (Famicom)
#define USE_ZAPPER      0x0400 // Zapper Gun device
#define MAPPER_NOCLEAR  0x0800 // preserve mapper regs on soft-reset
#define IS_PAL          0x1000 // PAL-mode (not fully supported)
#define IS_FDS          0x2000 // Famicom Disk System
#define SHOW_OVERSCAN   0x4000 // - for debugging -
#define ALT_TIMING      0x8000 // for games that use "BIT PPUSTATUS; BIT PPUSTATUS; BPL -"
							   // Assimilate, Star Wars, full_palette.nes, etc.
#define ALT_TIMING2     0x0080 // Don Doko Don 2 doesn't like the nmi delay that gunnac, b-wings, etc needs.
#define VS_ZAPPER		0x0010 // VS. UniSystem Zapper
#define VS_REVERSED     0x0020 // VS. p1/p2 -> p2/p1 (inputs swapped)
#define RAM_RANDOM      0x0040 // Init. ram w/random bytes (Go! Dizzy Go!)
#define APU_HACKERY    0x10000 // Sam's Journey likes to clock the apu sweep gen via writes to 2017
#define FLASH_EEPROM   0x20000 // Flash eeprom (flashrom), loads / saves .ips file

// Usually for Multi-Cart mappers
static UINT32 RESETMode = 0;
#define RESET_POWER     0x0001
#define RESET_BUTTON    0x0002

// PPU types
enum {
	RP2C02 = 0, // NES/FC
	RP2C03,     // VS. (... and below!)
	RP2C04A,
	RP2C04B,
	RP2C04C,
	RP2C04D,
	RP2C05A,
	RP2C05B,
	RP2C05C,
	RP2C05D,
	RP2C05E
};

static const UINT8 PPUTypes[][6] = {
	{ "2C02" },     // NES/FC
	{ "2C03" },     // VS. (... and below!)
	{ "2C04A" },
	{ "2C04B" },
	{ "2C04C" },
	{ "2C04D" },
	{ "2C05A" },
	{ "2C05B" },
	{ "2C05C" },
	{ "2C05D" },
	{ "2C05E" }
};

static INT32 PPUType;

static struct BurnInputInfo NESInputList[] =
{
	{"P1 Select",	  BIT_DIGITAL,   NESJoy1 + 2, "p1 select" },
	{"P1 Start",	  BIT_DIGITAL,   NESJoy1 + 3, "p1 start"  },
	{"P1 Up",	  	  BIT_DIGITAL,   NESJoy1 + 4, "p1 up"     },
	{"P1 Down",	  	  BIT_DIGITAL,   NESJoy1 + 5, "p1 down"   },
	{"P1 Left",		  BIT_DIGITAL,   NESJoy1 + 6, "p1 left"   },
	{"P1 Right",	  BIT_DIGITAL,   NESJoy1 + 7, "p1 right"  },
	{"P1 Button B",	  BIT_DIGITAL,   NESJoy1 + 1, "p1 fire 1" },
	{"P1 Button A",	  BIT_DIGITAL,   NESJoy1 + 0, "p1 fire 2" },

	{"P2 Select",	  BIT_DIGITAL,   NESJoy2 + 2, "p2 select" },
	{"P2 Start",	  BIT_DIGITAL,   NESJoy2 + 3, "p2 start"  },
	{"P2 Up",	  	  BIT_DIGITAL,   NESJoy2 + 4, "p2 up"     },
	{"P2 Down",	  	  BIT_DIGITAL,   NESJoy2 + 5, "p2 down"   },
	{"P2 Left",		  BIT_DIGITAL,   NESJoy2 + 6, "p2 left"   },
	{"P2 Right",	  BIT_DIGITAL,   NESJoy2 + 7, "p2 right"  },
	{"P2 Button B",	  BIT_DIGITAL,   NESJoy2 + 1, "p2 fire 1" },
	{"P2 Button A",	  BIT_DIGITAL,   NESJoy2 + 0, "p2 fire 2" },

	{"Reset", 		  BIT_DIGITAL,   &DrvReset  , "reset"     },
	{"Dip A",		  BIT_DIPSWITCH, DrvDips + 0, "dip"       },
	{"Dip B",		  BIT_DIPSWITCH, DrvDips + 1, "dip"       },
	{"Dip C",		  BIT_DIPSWITCH, DrvDips + 2, "dip"       },
};

STDINPUTINFO(NES)

static struct BurnInputInfo NESVSInputList[] =
{
	{"P1 Coin",	  	  BIT_DIGITAL,   NESCoin + 0, "p1 coin"   },
	{"P1 Select",	  BIT_DIGITAL,   NESJoy1 + 3, "p1 select" },
	{"P1 Start",	  BIT_DIGITAL,   NESJoy1 + 2, "p1 start"  },
	{"P1 Up",	  	  BIT_DIGITAL,   NESJoy1 + 4, "p1 up"     },
	{"P1 Down",	  	  BIT_DIGITAL,   NESJoy1 + 5, "p1 down"   },
	{"P1 Left",		  BIT_DIGITAL,   NESJoy1 + 6, "p1 left"   },
	{"P1 Right",	  BIT_DIGITAL,   NESJoy1 + 7, "p1 right"  },
	{"P1 Button B",	  BIT_DIGITAL,   NESJoy1 + 1, "p1 fire 1" },
	{"P1 Button A",	  BIT_DIGITAL,   NESJoy1 + 0, "p1 fire 2" },

	{"P2 Select",	  BIT_DIGITAL,   NESJoy2 + 3, "p2 select" },
	{"P2 Start",	  BIT_DIGITAL,   NESJoy2 + 2, "p2 start"  },
	{"P2 Up",	  	  BIT_DIGITAL,   NESJoy2 + 4, "p2 up"     },
	{"P2 Down",	  	  BIT_DIGITAL,   NESJoy2 + 5, "p2 down"   },
	{"P2 Left",		  BIT_DIGITAL,   NESJoy2 + 6, "p2 left"   },
	{"P2 Right",	  BIT_DIGITAL,   NESJoy2 + 7, "p2 right"  },
	{"P2 Button B",	  BIT_DIGITAL,   NESJoy2 + 1, "p2 fire 1" },
	{"P2 Button A",	  BIT_DIGITAL,   NESJoy2 + 0, "p2 fire 2" },

	{"Reset", 		  BIT_DIGITAL,   &DrvReset  , "reset"     },
	{"Dip A",		  BIT_DIPSWITCH, DrvDips + 0, "dip"       },
	{"Dip B",		  BIT_DIPSWITCH, DrvDips + 1, "dip"       },
	{"Dip C",		  BIT_DIPSWITCH, DrvDips + 2, "dip"       },
	{"Dip D",		  BIT_DIPSWITCH, DrvDips + 3, "dip"       },
};

STDINPUTINFO(NESVS)

#define A(a, b, c, d) {a, b, (UINT8*)(c), d}
static struct BurnInputInfo NESZapperInputList[] =
{
	{"P1 Select",	  BIT_DIGITAL,   NESJoy1 + 2, "p1 select" },
	{"P1 Start",	  BIT_DIGITAL,   NESJoy1 + 3, "p1 start"  },
	{"P1 Up",	  	  BIT_DIGITAL,   NESJoy1 + 4, "p1 up"     },
	{"P1 Down",	  	  BIT_DIGITAL,   NESJoy1 + 5, "p1 down"   },
	{"P1 Left",		  BIT_DIGITAL,   NESJoy1 + 6, "p1 left"   },
	{"P1 Right",	  BIT_DIGITAL,   NESJoy1 + 7, "p1 right"  },
	{"P1 Button B",	  BIT_DIGITAL,   NESJoy1 + 1, "p1 fire 1" },
	{"P1 Button A",	  BIT_DIGITAL,   NESJoy1 + 0, "p1 fire 2" },

	A("P2 Gun X",     BIT_ANALOG_REL, &ZapperX,   "p2 x-axis" ),
	A("P2 Gun Y",     BIT_ANALOG_REL, &ZapperY,   "p2 y-axis" ),
	{"P2 Fire",       BIT_DIGITAL,  &ZapperFire,  "p2 fire 1" },
	{"P2 Reload",     BIT_DIGITAL,  &ZapperReload,"p2 fire 2" },

	{"Reset", 		  BIT_DIGITAL,   &DrvReset  , "reset"     },
	{"Dip A",		  BIT_DIPSWITCH, DrvDips + 0, "dip"       },
	{"Dip B",		  BIT_DIPSWITCH, DrvDips + 1, "dip"       },
	{"Dip C",		  BIT_DIPSWITCH, DrvDips + 2, "dip"       },
};

STDINPUTINFO(NESZapper)

static struct BurnInputInfo NESVSZapperInputList[] =
{
	{"P1 Coin",	  	  BIT_DIGITAL,   NESCoin + 0, "p1 coin"   },

	A("P1 Gun X",     BIT_ANALOG_REL, &ZapperX,   "p1 x-axis" ),
	A("P1 Gun Y",     BIT_ANALOG_REL, &ZapperY,   "p1 y-axis" ),
	{"P1 Fire",       BIT_DIGITAL,  &ZapperFire,  "p1 fire 1" },
	{"P1 Reload",     BIT_DIGITAL,  &ZapperReload,"p1 fire 2" },

	{"Reset", 		  BIT_DIGITAL,   &DrvReset  , "reset"     },
	{"Dip A",		  BIT_DIPSWITCH, DrvDips + 0, "dip"       },
	{"Dip B",		  BIT_DIPSWITCH, DrvDips + 1, "dip"       },
	{"Dip C",		  BIT_DIPSWITCH, DrvDips + 2, "dip"       },
	{"Dip D",		  BIT_DIPSWITCH, DrvDips + 3, "dip"       },
};
#undef A
STDINPUTINFO(NESVSZapper)

static struct BurnInputInfo NES4ScoreInputList[] =
{
	{"P1 Select",	  BIT_DIGITAL,   NESJoy1 + 2, "p1 select" },
	{"P1 Start",	  BIT_DIGITAL,   NESJoy1 + 3, "p1 start"  },
	{"P1 Up",	  	  BIT_DIGITAL,   NESJoy1 + 4, "p1 up"     },
	{"P1 Down",	  	  BIT_DIGITAL,   NESJoy1 + 5, "p1 down"   },
	{"P1 Left",		  BIT_DIGITAL,   NESJoy1 + 6, "p1 left"   },
	{"P1 Right",	  BIT_DIGITAL,   NESJoy1 + 7, "p1 right"  },
	{"P1 Button B",	  BIT_DIGITAL,   NESJoy1 + 1, "p1 fire 1" },
	{"P1 Button A",	  BIT_DIGITAL,   NESJoy1 + 0, "p1 fire 2" },

	{"P2 Select",	  BIT_DIGITAL,   NESJoy2 + 2, "p2 select" },
	{"P2 Start",	  BIT_DIGITAL,   NESJoy2 + 3, "p2 start"  },
	{"P2 Up",	  	  BIT_DIGITAL,   NESJoy2 + 4, "p2 up"     },
	{"P2 Down",	  	  BIT_DIGITAL,   NESJoy2 + 5, "p2 down"   },
	{"P2 Left",		  BIT_DIGITAL,   NESJoy2 + 6, "p2 left"   },
	{"P2 Right",	  BIT_DIGITAL,   NESJoy2 + 7, "p2 right"  },
	{"P2 Button B",	  BIT_DIGITAL,   NESJoy2 + 1, "p2 fire 1" },
	{"P2 Button A",	  BIT_DIGITAL,   NESJoy2 + 0, "p2 fire 2" },

	{"P3 Select",	  BIT_DIGITAL,   NESJoy3 + 2, "p3 select" },
	{"P3 Start",	  BIT_DIGITAL,   NESJoy3 + 3, "p3 start"  },
	{"P3 Up",	  	  BIT_DIGITAL,   NESJoy3 + 4, "p3 up"     },
	{"P3 Down",	  	  BIT_DIGITAL,   NESJoy3 + 5, "p3 down"   },
	{"P3 Left",		  BIT_DIGITAL,   NESJoy3 + 6, "p3 left"   },
	{"P3 Right",	  BIT_DIGITAL,   NESJoy3 + 7, "p3 right"  },
	{"P3 Button B",	  BIT_DIGITAL,   NESJoy3 + 1, "p3 fire 1" },
	{"P3 Button A",	  BIT_DIGITAL,   NESJoy3 + 0, "p3 fire 2" },

	{"P4 Select",	  BIT_DIGITAL,   NESJoy4 + 2, "p4 select" },
	{"P4 Start",	  BIT_DIGITAL,   NESJoy4 + 3, "p4 start"  },
	{"P4 Up",	  	  BIT_DIGITAL,   NESJoy4 + 4, "p4 up"     },
	{"P4 Down",	  	  BIT_DIGITAL,   NESJoy4 + 5, "p4 down"   },
	{"P4 Left",		  BIT_DIGITAL,   NESJoy4 + 6, "p4 left"   },
	{"P4 Right",	  BIT_DIGITAL,   NESJoy4 + 7, "p4 right"  },
	{"P4 Button B",	  BIT_DIGITAL,   NESJoy4 + 1, "p4 fire 1" },
	{"P4 Button A",	  BIT_DIGITAL,   NESJoy4 + 0, "p4 fire 2" },

	{"Reset", 		  BIT_DIGITAL,   &DrvReset  , "reset"     },
	{"Dip A",		  BIT_DIPSWITCH, DrvDips + 0, "dip"       },
	{"Dip B",		  BIT_DIPSWITCH, DrvDips + 1, "dip"       },
	{"Dip C",		  BIT_DIPSWITCH, DrvDips + 2, "dip"       },
};

STDINPUTINFO(NES4Score)

static struct BurnInputInfo NESFDSInputList[] =
{
	{"P1 Select",	  BIT_DIGITAL,   NESJoy1 + 2, "p1 select" },
	{"P1 Start",	  BIT_DIGITAL,   NESJoy1 + 3, "p1 start"  },
	{"P1 Up",	  	  BIT_DIGITAL,   NESJoy1 + 4, "p1 up"     },
	{"P1 Down",	  	  BIT_DIGITAL,   NESJoy1 + 5, "p1 down"   },
	{"P1 Left",		  BIT_DIGITAL,   NESJoy1 + 6, "p1 left"   },
	{"P1 Right",	  BIT_DIGITAL,   NESJoy1 + 7, "p1 right"  },
	{"P1 Button B",	  BIT_DIGITAL,   NESJoy1 + 1, "p1 fire 1" },
	{"P1 Button A",	  BIT_DIGITAL,   NESJoy1 + 0, "p1 fire 2" },

	{"P2 Microphone", BIT_DIGITAL,   NESJoy2 + 2, "p2 select" },
	{"P2 Up",	  	  BIT_DIGITAL,   NESJoy2 + 4, "p2 up"     },
	{"P2 Down",	  	  BIT_DIGITAL,   NESJoy2 + 5, "p2 down"   },
	{"P2 Left",		  BIT_DIGITAL,   NESJoy2 + 6, "p2 left"   },
	{"P2 Right",	  BIT_DIGITAL,   NESJoy2 + 7, "p2 right"  },
	{"P2 Button B",	  BIT_DIGITAL,   NESJoy2 + 1, "p2 fire 1" },
	{"P2 Button A",	  BIT_DIGITAL,   NESJoy2 + 0, "p2 fire 2" },

	{"Swap Disk Side",	  BIT_DIGITAL, &FDSSwap,  "swap"      },
	{"Eject/Insert Disk", BIT_DIGITAL, &FDSEject, "eject"     },

	{"Reset", 		  BIT_DIGITAL,   &DrvReset  , "reset"     },
	{"Dip A",		  BIT_DIPSWITCH, DrvDips + 0, "dip"       },
	{"Dip B",		  BIT_DIPSWITCH, DrvDips + 1, "dip"       },
	{"Dip C",		  BIT_DIPSWITCH, DrvDips + 2, "dip"       },
};

STDINPUTINFO(NESFDS)

static struct BurnDIPInfo NESDIPList[] =
{
	DIP_OFFSET(0x11)
	{0x00, 0xff, 0xff, 0x00, NULL			},
	{0x01, 0xff, 0xff, 0x00, NULL			},
	{0x02, 0xff, 0xff, 0x00, NULL			},

	{0   , 0xfe, 0   ,    2, "Sprite Limit"	},
	{0x00, 0x01, 0x01, 0x01, "Off"			},
	{0x00, 0x01, 0x01, 0x00, "On"			},

	{0   , 0xfe, 0   ,    2, "Aspect Ratio"	},
	{0x01, 0x01, 0x01, 0x00, "Off"			},
	{0x01, 0x01, 0x01, 0x01, "4:3"			},

	{0   , 0xfe, 0   ,    2, "Stereoizer"	},
	{0x01, 0x01, 0x02, 0x00, "Off"			},
	{0x01, 0x01, 0x02, 0x02, "On"			},

	{0   , 0xfe, 0   ,    2, "DMC Bit-Reversal"	},
	{0x01, 0x01, 0x08, 0x00, "Off"			},
	{0x01, 0x01, 0x08, 0x08, "On"			},

	{0   , 0xfe, 0   ,    3, "Palette"		},
	{0x02, 0x01, 0x03, 0x00, "Famicom"		},
	{0x02, 0x01, 0x03, 0x01, "RGB"			},
	{0x02, 0x01, 0x03, 0x02, "Royaltea"		},
};

STDDIPINFO(NES)

static struct BurnDIPInfo NESZapperDIPList[] =
{
	DIP_OFFSET(0x0d)
	{0x00, 0xff, 0xff, 0x00, NULL			},
	{0x01, 0xff, 0xff, 0x00, NULL			},
	{0x02, 0xff, 0xff, 0x00, NULL			},

	{0   , 0xfe, 0   ,    2, "Sprite Limit"	},
	{0x00, 0x01, 0x01, 0x01, "Off"			},
	{0x00, 0x01, 0x01, 0x00, "On"			},

	{0   , 0xfe, 0   ,    2, "Aspect Ratio"	},
	{0x01, 0x01, 0x01, 0x00, "Off"			},
	{0x01, 0x01, 0x01, 0x01, "4:3"			},

	{0   , 0xfe, 0   ,    2, "Stereoizer"	},
	{0x01, 0x01, 0x02, 0x00, "Off"			},
	{0x01, 0x01, 0x02, 0x02, "On"			},

	{0   , 0xfe, 0   ,    2, "DMC Bit-Reversal"	},
	{0x01, 0x01, 0x08, 0x00, "Off"			},
	{0x01, 0x01, 0x08, 0x08, "On"			},

	{0   , 0xfe, 0   ,    3, "Palette"		},
	{0x02, 0x01, 0x03, 0x00, "Famicom"		},
	{0x02, 0x01, 0x03, 0x01, "RGB"			},
	{0x02, 0x01, 0x03, 0x02, "Royaltea"		},
};

STDDIPINFO(NESZapper)

static struct BurnDIPInfo NESVS_DIPList[] =    		// VS. Unisystem
{
	DIP_OFFSET(0x12)

	{0   , 0xfe, 0   ,    2, "Sprite Limit"	},
	{0x00, 0x01, 0x01, 0x01, "Off"			},
	{0x00, 0x01, 0x01, 0x00, "On"			},

	{0   , 0xfe, 0   ,    2, "Aspect Ratio"	},
	{0x01, 0x01, 0x01, 0x00, "Off"			},
	{0x01, 0x01, 0x01, 0x01, "4:3"			},

	{0   , 0xfe, 0   ,    2, "Stereoizer"	},
	{0x01, 0x01, 0x02, 0x00, "Off"			},
	{0x01, 0x01, 0x02, 0x02, "On"			},

	{0   , 0xfe, 0   ,    2, "DMC Bit-Reversal"	},
	{0x01, 0x01, 0x08, 0x00, "Off"			},
	{0x01, 0x01, 0x08, 0x08, "On"			},

	{0   , 0xfe, 0   ,    2, "Dip 1"		},
	{0x03, 0x01, 0x01, 0x00, "Off"			},
	{0x03, 0x01, 0x01, 0x01, "On"			},

	{0   , 0xfe, 0   ,    2, "Dip 2"		},
	{0x03, 0x01, 0x02, 0x00, "Off"			},
	{0x03, 0x01, 0x02, 0x02, "On"			},

	{0   , 0xfe, 0   ,    2, "Dip 3"		},
	{0x03, 0x01, 0x04, 0x00, "Off"			},
	{0x03, 0x01, 0x04, 0x04, "On"			},

	{0   , 0xfe, 0   ,    2, "Dip 4"		},
	{0x03, 0x01, 0x08, 0x00, "Off"			},
	{0x03, 0x01, 0x08, 0x08, "On"			},

	{0   , 0xfe, 0   ,    2, "Dip 5"		},
	{0x03, 0x01, 0x10, 0x00, "Off"			},
	{0x03, 0x01, 0x10, 0x10, "On"			},

	{0   , 0xfe, 0   ,    2, "Dip 6"		},
	{0x03, 0x01, 0x20, 0x00, "Off"			},
	{0x03, 0x01, 0x20, 0x20, "On"			},

	{0   , 0xfe, 0   ,    2, "Dip 7"		},
	{0x03, 0x01, 0x40, 0x00, "Off"			},
	{0x03, 0x01, 0x40, 0x40, "On"			},

	{0   , 0xfe, 0   ,    2, "Dip 8"		},
	{0x03, 0x01, 0x80, 0x00, "Off"			},
	{0x03, 0x01, 0x80, 0x80, "On"			},
};

static struct BurnDIPInfo NESVS_DefaultsDIPList[] = // VS. Unisystem, default config
{
	{0x00, 0xff, 0xff, 0x00, NULL			},
	{0x01, 0xff, 0xff, 0x00, NULL			},
	{0x02, 0xff, 0xff, 0x00, NULL			},
	{0x03, 0xff, 0xff, 0x00, NULL			},
};

static struct BurnDIPInfo vsdip_bit_1_DIPList[]=
{
	{0x00, 0xff, 0xff, 0x00, NULL			},
	{0x01, 0xff, 0xff, 0x00, NULL			},
	{0x02, 0xff, 0xff, 0x00, NULL			},
	{0x03, 0xff, 0xff, 0x02, NULL			},
};

static struct BurnDIPInfo vsdip_bit_0_DIPList[]=
{
	{0x00, 0xff, 0xff, 0x00, NULL			},
	{0x01, 0xff, 0xff, 0x00, NULL			},
	{0x02, 0xff, 0xff, 0x00, NULL			},
	{0x03, 0xff, 0xff, 0x01, NULL			},
};

STDDIPINFOEXT(NESVS, NESVS_Defaults, NESVS_)  // NESVSDipInfo = NESVS_ + NESVS_Defaults
STDDIPINFOEXT(NESVSFromBelow, vsdip_bit_1_, NESVS_)  // vs. from below defaults
STDDIPINFOEXT(NESVSBit0High, vsdip_bit_0_, NESVS_)  // vs. pinball, stroke & match golf defaults

static struct BurnDIPInfo NESVSZapperDIPList[] =	// VS. Unisystem
{
	DIP_OFFSET(0x06)
	{0x00, 0xff, 0xff, 0x00, NULL			},
	{0x01, 0xff, 0xff, 0x00, NULL			},
	{0x02, 0xff, 0xff, 0x00, NULL			},
	{0x03, 0xff, 0xff, 0x00, NULL			},

	{0   , 0xfe, 0   ,    2, "Sprite Limit"	},
	{0x00, 0x01, 0x01, 0x01, "Off"			},
	{0x00, 0x01, 0x01, 0x00, "On"			},

	{0   , 0xfe, 0   ,    2, "Aspect Ratio"	},
	{0x01, 0x01, 0x01, 0x00, "Off"			},
	{0x01, 0x01, 0x01, 0x01, "4:3"			},

	{0   , 0xfe, 0   ,    2, "Stereoizer"	},
	{0x01, 0x01, 0x02, 0x00, "Off"			},
	{0x01, 0x01, 0x02, 0x02, "On"			},

	{0   , 0xfe, 0   ,    2, "DMC Bit-Reversal"	},
	{0x01, 0x01, 0x08, 0x00, "Off"			},
	{0x01, 0x01, 0x08, 0x08, "On"			},

	{0   , 0xfe, 0   ,    2, "Dip 1"		},
	{0x03, 0x01, 0x01, 0x00, "Off"			},
	{0x03, 0x01, 0x01, 0x01, "On"			},

	{0   , 0xfe, 0   ,    2, "Dip 2"		},
	{0x03, 0x01, 0x02, 0x00, "Off"			},
	{0x03, 0x01, 0x02, 0x02, "On"			},

	{0   , 0xfe, 0   ,    2, "Dip 3"		},
	{0x03, 0x01, 0x04, 0x00, "Off"			},
	{0x03, 0x01, 0x04, 0x04, "On"			},

	{0   , 0xfe, 0   ,    2, "Dip 4"		},
	{0x03, 0x01, 0x08, 0x00, "Off"			},
	{0x03, 0x01, 0x08, 0x08, "On"			},

	{0   , 0xfe, 0   ,    2, "Dip 5"		},
	{0x03, 0x01, 0x10, 0x00, "Off"			},
	{0x03, 0x01, 0x10, 0x10, "On"			},

	{0   , 0xfe, 0   ,    2, "Dip 6"		},
	{0x03, 0x01, 0x20, 0x00, "Off"			},
	{0x03, 0x01, 0x20, 0x20, "On"			},

	{0   , 0xfe, 0   ,    2, "Dip 7"		},
	{0x03, 0x01, 0x40, 0x00, "Off"			},
	{0x03, 0x01, 0x40, 0x40, "On"			},

	{0   , 0xfe, 0   ,    2, "Dip 8"		},
	{0x03, 0x01, 0x80, 0x00, "Off"			},
	{0x03, 0x01, 0x80, 0x80, "On"			},
};

STDDIPINFO(NESVSZapper)

static struct BurnDIPInfo NES4ScoreDIPList[] =
{
	DIP_OFFSET(0x21)
	{0x00, 0xff, 0xff, 0x00, NULL			},
	{0x01, 0xff, 0xff, 0x00, NULL			},
	{0x02, 0xff, 0xff, 0x00, NULL			},

	{0   , 0xfe, 0   ,    2, "Sprite Limit"	},
	{0x00, 0x01, 0x01, 0x01, "Off"			},
	{0x00, 0x01, 0x01, 0x00, "On"			},

	{0   , 0xfe, 0   ,    2, "Aspect Ratio"	},
	{0x01, 0x01, 0x01, 0x00, "Off"			},
	{0x01, 0x01, 0x01, 0x01, "4:3"			},

	{0   , 0xfe, 0   ,    2, "Stereoizer"	},
	{0x01, 0x01, 0x02, 0x00, "Off"			},
	{0x01, 0x01, 0x02, 0x02, "On"			},

	{0   , 0xfe, 0   ,    2, "DMC Bit-Reversal"	},
	{0x01, 0x01, 0x08, 0x00, "Off"			},
	{0x01, 0x01, 0x08, 0x08, "On"			},

	{0   , 0xfe, 0   ,    3, "Palette"		},
	{0x02, 0x01, 0x03, 0x00, "Famicom"		},
	{0x02, 0x01, 0x03, 0x01, "RGB"			},
	{0x02, 0x01, 0x03, 0x02, "Royaltea"		},
};

STDDIPINFO(NES4Score)

static struct BurnDIPInfo NESFDSDIPList[] =
{
	DIP_OFFSET(0x12)
	{0x00, 0xff, 0xff, 0x00, NULL			},
	{0x01, 0xff, 0xff, 0x00, NULL			},
	{0x02, 0xff, 0xff, 0x00, NULL			},

	{0   , 0xfe, 0   ,    2, "Sprite Limit"	},
	{0x00, 0x01, 0x01, 0x01, "Off"			},
	{0x00, 0x01, 0x01, 0x00, "On"			},

	{0   , 0xfe, 0   ,    2, "Auto Insert/Eject" },
	{0x00, 0x01, 0x02, 0x02, "Off"			},
	{0x00, 0x01, 0x02, 0x00, "On"			},

	{0   , 0xfe, 0   ,    2, "Aspect Ratio"	},
	{0x01, 0x01, 0x01, 0x00, "Off"			},
	{0x01, 0x01, 0x01, 0x01, "4:3"			},

	{0   , 0xfe, 0   ,    2, "Stereoizer"	},
	{0x01, 0x01, 0x02, 0x00, "Off"			},
	{0x01, 0x01, 0x02, 0x02, "On"			},

	{0   , 0xfe, 0   ,    2, "DMC Bit-Reversal"	},
	{0x01, 0x01, 0x08, 0x00, "Off"			},
	{0x01, 0x01, 0x08, 0x08, "On"			},

	{0   , 0xfe, 0   ,    3, "Palette"		},
	{0x02, 0x01, 0x03, 0x00, "Famicom"		},
	{0x02, 0x01, 0x03, 0x01, "RGB"			},
	{0x02, 0x01, 0x03, 0x02, "Royaltea"		},
};

STDDIPINFO(NESFDS)

#define SCREEN_WIDTH 256
#define SCREEN_HEIGHT (240-16) // top and bottom 8px is overscan
#define SCREEN_HEIGHT_PAL (SCREEN_HEIGHT + 8)

static UINT8* NES_CPU_RAM;

static UINT8* rom;
static INT32 cyc_counter = 0; // frame-based cycle counter
static UINT64 mega_cyc_counter = 0; // "from reset"-based cycle counter

static UINT8 cpu_open_bus;
static INT32 scanline, pixel;
static UINT8 (*read_nt)(UINT16 address);
static void (*write_nt)(UINT16 address, UINT8 data);

enum Scanline  { VISIBLE = 0, POSTRENDER, VBLANK, PRERENDER };
enum Mirroring { VERTICAL = 0, HORIZONTAL, SINGLE_LOW, SINGLE_HIGH, FOUR_SCREEN, SACHEN };

// Reference: https://wiki.nesdev.com/w/index.php?title=PPU_registers

union PPUCTRL
{
#ifdef LSB_FIRST
	struct {
		UINT8 nttab   : 2;  // Base nametable address (0 = $2000; 1 = $2400; 2 = $2800; 3 = $2C00)
		UINT8 incr    : 1;  // VRAM address increment (0 = 1, 1 = 32)
		UINT8 sprtab  : 1;  // Sprite Pattern table address for 8x8 sprites
		UINT8 bgtab   : 1;  // Background pattern table address
		UINT8 sprsize : 1;  // Sprite size, 8x8 / 8x16
		UINT8 slave   : 1;  // PPU master/slave select
		UINT8 nmi     : 1;  // Generate NMI @ VBL
	} bit;
	UINT8 reg;
#else
	UINT8 reg;
	struct {
		UINT8 nmi     : 1;  // Generate NMI @ VBL
		UINT8 slave   : 1;  // PPU master/slave select
		UINT8 sprsize : 1;  // Sprite size, 8x8 / 8x16
		UINT8 bgtab   : 1;  // Background pattern table address
		UINT8 sprtab  : 1;  // Sprite Pattern table address for 8x8 sprites
		UINT8 incr    : 1;  // VRAM address increment (0 = 1, 1 = 32)
		UINT8 nttab   : 2;  // Base nametable address (0 = $2000; 1 = $2400; 2 = $2800; 3 = $2C00)
	} bit;
#endif
};

union PPUMASK
{
#ifdef LSB_FIRST
	struct {
		UINT8 gray    : 1;  // Grayscale
		UINT8 bgLeft  : 1;  // Show background in left 8 px of screen
		UINT8 sprLeft : 1;  // Show sprite in left 8 px
		UINT8 bg      : 1;  // Show background
		UINT8 spr     : 1;  // Show sprites
		UINT8 red     : 1;  // Emphasize red
		UINT8 green   : 1;  // Emphasize green
		UINT8 blue    : 1;  // Emphasize blue
	} bit;
	UINT8 reg;
#else
	UINT8 reg;
	struct {
		UINT8 blue    : 1;  // Emphasize blue
		UINT8 green   : 1;  // Emphasize green
		UINT8 red     : 1;  // Emphasize red
		UINT8 spr     : 1;  // Show sprites
		UINT8 bg      : 1;  // Show background
		UINT8 sprLeft : 1;  // Show sprite in left 8 px
		UINT8 bgLeft  : 1;  // Show background in left 8 px of screen
		UINT8 gray    : 1;  // Grayscale
	} bit;
#endif
};

union PPUSTATUS
{
#ifdef LSB_FIRST
	struct {
		UINT8 bus     : 5;  // Open bus
		UINT8 spovrf  : 1;  // Sprite overflow (8+ sprites/scanline)
		UINT8 sp0hit  : 1;  // Sprite 0 Hit
		UINT8 VBlank  : 1;  // Vertical blanking
	} bit;
	UINT8 reg;
#else
	UINT8 reg;
	struct {
		UINT8 VBlank  : 1;  // Vertical blanking
		UINT8 sp0hit  : 1;  // Sprite 0 Hit
		UINT8 spovrf  : 1;  // Sprite overflow (8+ sprites/scanline)
		UINT8 bus     : 5;  // Open bus
	} bit;
#endif
};

struct OAMBUF
{
	UINT8 idx;   // # in OAM
	UINT8 x;     // following 4 bytes (x, y, tile, attr) mirror oam_ram
	UINT8 y;
	UINT8 tile;
	UINT8 attr;
	UINT8 tileL; // tile data from CHR
	UINT8 tileH;
};

struct cartridge {
	UINT8   *Cart;
	UINT8   *CartOrig; // for mapper 30 ips saves
	INT32    CartSize;

	UINT8	*PRGRom;
	INT32	 PRGRomSize;
	INT32	 PRGRomMask;

	UINT8	*WorkRAM;
	INT32	 WorkRAMSize;
	INT32	 WorkRAMMask;
	INT32	 BatteryBackedSRAM;

	UINT8	*CHRRom;
	INT32	 CHRRomSize;
	UINT8	*CHRRam;
	INT32	 CHRRamSize;

	UINT8   *ExtData;
	INT32    ExtDataSize;

	INT32	 Mapper;
	INT32	 SubMapper;
	INT32	 Mirroring;
	INT32	 Trainer;
	UINT32	 Crc;

	INT32	 FDSMode;
	INT32	 FDSDiskSides;
	UINT8	*FDSDiskRawOrig;	// FDS Disk loaded (unmodified)
	INT32    FDSDiskRawOrigSize;

	UINT8	*FDSDiskRaw;		// FDS Disk loaded (possibly modified)
	INT32    FDSDiskRawSize;
	UINT8	*FDSDisk;			// Same as above, but ptr adjusted to skip the header (if avail.)
	INT32    FDSDiskSize;
};

static cartridge Cart;

// forward decl's (used in mappers)
static void set_mirroring(INT32 mode);
static void nametable_map(INT32 nt, INT32 ntbank);
static void nametable_mapraw(INT32 nt, UINT8 *ntraw, UINT8 type);
static void nametable_mapall(INT32 ntbank0, INT32 ntbank1, INT32 ntbank2, INT32 ntbank3);

enum { MEM_RAM = 0, MEM_RAM_RO = 1, MEM_ROM = 2 };
static void mapper_set_chrtype(INT32 type);

static INT32 mapper_init(INT32 mappernum);
static UINT8 (*mapper_prg_read)(UINT16 addr);
static UINT8 mapper_prg_read_int(UINT16 address); // mapper_prg_read points here by default
static void (*mapper_write)(UINT16 address, UINT8 data) = NULL;
static void (*mapper_map)() = NULL;
static void (*mapper_scanline)() = NULL;                // once per scanline
static void (*mapper_cycle)() = NULL;                   // once per cpu-cycle
static void (*mapper_ppu_clock)(UINT16 busaddr) = NULL; // called during visible & prerender
static void (*mapper_ppu_clockall)(UINT16 busaddr) = NULL; // called during every cycle
static void (*mapper_scan_cb)() = NULL;                 // state scanning
static void (*mapper_scan_cb_nvram)() = NULL;           // state scanning (nvram)

// loading & saving FDS Disk & Mapper 30 (flash eeprom) Carts
static void LoadIPSPatch(TCHAR *desc, UINT8 *rom_, INT32 rom_size);
static void SaveIPSPatch(TCHAR *desc, UINT8 *rom_orig, UINT8 *rom_, INT32 rom_size);

static INT32 cartridge_load(UINT8* ROMData, UINT32 ROMSize, UINT32 ROMCRC)
{
	if (ROMData == NULL || ROMSize < 16384 ) {
		bprintf(0, _T("Invalid ROM data!\n"));
		return 1;
	}

	if (memcmp("NES\x1a", &ROMData[0], 4)) {
		bprintf(0, _T("Invalid ROM header!\n"));
		return 1;
	}

	NESMode = 0;

	INT32 nes20 = (ROMData[7] & 0xc) == 0x8;

	memset(&Cart, 0, sizeof(Cart));

	Cart.Cart = ROMData;
	Cart.CartSize = ROMSize;
	Cart.CartOrig = BurnMalloc(ROMSize);
	memcpy(Cart.CartOrig, Cart.Cart, ROMSize);

	Cart.Crc = ROMCRC;
	Cart.PRGRomSize = ROMData[4] * 0x4000;
	Cart.CHRRomSize = ROMData[5] * 0x2000;

	if (Cart.Crc == 0x2a798367) {
		// JY 45-in-1 can't be represented by regular nes header.
		Cart.CHRRomSize = 128 * 0x4000;
	}

	PPUType = RP2C02;

	if (nes20 && (ROMData[7] & 0x3) == 1) {
		switch (ROMData[13] & 0x0f) {
			case 0:
			case 1:
			case 6:
			case 7: PPUType = RP2C03; break;
			case 2: PPUType = RP2C04A; break;
			case 3: PPUType = RP2C04B; break;
			case 4: PPUType = RP2C04C; break;
			case 5: PPUType = RP2C04D; break;
			case 8: PPUType = RP2C05A; break;
			case 9: PPUType = RP2C05B; break;
			case 0xa: PPUType = RP2C05C; break;
			case 0xb: PPUType = RP2C05D; break;
			case 0xc: PPUType = RP2C05E; break;
		}
		bprintf(0, _T("VS. System - PPU %S (%x)\n"), PPUTypes[PPUType], PPUType);
		ROMData[6] |= 8; // "fix to 4-screen mode" - nesdev wiki
	}

	bprintf(0, _T("PRG Size: %d\n"), Cart.PRGRomSize);
	bprintf(0, _T("CHR Size: %d\n"), Cart.CHRRomSize);

	if (ROMData[6] & 0x8)
		Cart.Mirroring = 4;
	else
		Cart.Mirroring = ROMData[6] & 1;

	switch (Cart.Mirroring) {
		case 0: set_mirroring(HORIZONTAL); break;
		case 1: set_mirroring(VERTICAL); break;
		case 4: set_mirroring(FOUR_SCREEN); break;
	}

	// Parse MAPPER iNES + NES 2.0
	Cart.Mapper = (ROMData[6] >> 4) | (ROMData[7] & 0xf0);

	if (!memcmp("DiskDude!", &ROMData[7], 9)) {
		bprintf(PRINT_ERROR, _T("``DiskDude!'' spam, ignoring upper bits of mapper.\n"));

		Cart.Mapper &= 0x0f; // remove spam from upper bits of mapper
	}

	if (nes20) {
		Cart.Mapper |= (ROMData[8] & 0x0f) << 8;
		Cart.SubMapper = (ROMData[8] & 0xf0) >> 4;

		if (Cart.Mapper & 0xf00 || Cart.SubMapper != 0)
			bprintf(0, _T("NES 2.0 Extended Mapper: %d\tSub: %d\n"), Cart.Mapper, Cart.SubMapper);
	}

	Cart.BatteryBackedSRAM = (ROMData[6] & 0x2) >> 1;

	// Mapper EXT-hardware inits
	// Initted here, because mapper_init() is called on reset
	if (Cart.Mapper == 30 || Cart.Mapper == 406 || Cart.Mapper == 451) { // UNIROM-512 (30), Haradius Zero (406), Haratyler (451) ips patch
		if (Cart.BatteryBackedSRAM) {
			NESMode |= FLASH_EEPROM; // enable IPS loads/saves
			Cart.BatteryBackedSRAM = 0; // disable sram
		}
	}

	if (NESMode & FLASH_EEPROM) {
		TCHAR desc[64];
		_stprintf(desc, _T("Mapper %d"), Cart.Mapper);

		// Load IPS patch (aka: flasheeprom-saves @ exit)
		LoadIPSPatch(desc, Cart.Cart, Cart.CartSize);
	}

	if (Cart.Mapper == 69) { // SunSoft fme-7 (5b) audio expansion - ay8910
		AY8910Init(0, 1789773 / 2, 1);
		AY8910SetAllRoutes(0, 0.70, BURN_SND_ROUTE_BOTH);
		AY8910SetBuffered(M6502TotalCycles, 1789773);
	}

	if (Cart.Mapper == 85) { // VRC7 audio expansion - YM2413
		BurnYM2413Init(3579545, 1);
		BurnYM2413SetAllRoutes(2.00, BURN_SND_ROUTE_BOTH);
	}

	Cart.Trainer = (ROMData[6] & 0x4) >> 2;
	Cart.PRGRom = ROMData + 0x10 + (Cart.Trainer ? 0x200 : 0);

	// Default CHR-Ram size (8k), always set-up (for advanced mappers, etc)
	Cart.CHRRamSize = 0x2000;

	if (nes20) {
		// NES2.0 header specifies CHR-Ram size (Nalle Land, Haunted Halloween '86, VS. Topgun, VS. Castlevania)
		Cart.CHRRamSize = 64 << (ROMData[0xb] & 0xf);

		// Detect Extended Data (Super Russian Roulette..)
		INT32 total_nes_rom = 0x10 + (Cart.Trainer ? 0x200 : 0) + Cart.PRGRomSize + Cart.CHRRomSize;
		Cart.ExtDataSize = (ROMSize > total_nes_rom) ? (ROMSize - total_nes_rom) : 0;

		if (Cart.ExtDataSize) {
			bprintf(0, _T("%x bytes Extended Data detected\n"), Cart.ExtDataSize);
			Cart.ExtData = ROMData + total_nes_rom;
		}
	}

	if (Cart.Mapper == 30 || Cart.Mapper == 111) { // UNROM-512, GTROM(Cheapocabra) defaults to 32k chr-ram
		Cart.CHRRamSize = 0x8000;
	}

	if (Cart.Crc == 0xf0847322) {
		Cart.CHRRamSize = 0x4000; // 16k chr-ram for Videomation
	}

	if (Cart.Crc == 0xdd65a6cc) { // Street Heroes 262
		Cart.Mapper = 262;
	}

	Cart.CHRRam = (UINT8*)BurnMalloc(Cart.CHRRamSize);

	if (Cart.CHRRomSize) {
		Cart.CHRRom = Cart.PRGRom + Cart.PRGRomSize;
		mapper_set_chrtype(MEM_ROM);
		bprintf(0, _T("Using ROM-supplied CHR data\n"));
	} else {
		mapper_set_chrtype(MEM_RAM);
		bprintf(0, _T("Using RAM CHR data (%dk bytes)\n"), Cart.CHRRamSize / 1024);
	}

	// set-up Cart PRG-RAM/WORK-RAM (6000-7fff)

	Cart.WorkRAMSize = (Cart.Mapper != 5) ? 0x2000 : (8 * 0x2000);

	if (nes20) {
		// NES2.0 header specifies NV-Ram size (ex. Nova the Squirrel)
		INT32 l_shift0 = ((ROMData[0xa] & 0xf0) >> 4); // sram
		INT32 l_shift1 = ((ROMData[0xa] & 0x0f) >> 0); // work-ram
		INT32 use = (l_shift0 > l_shift1) ? l_shift0 : l_shift1; // use the larger of the 2?
		Cart.WorkRAMSize = (use == 0) ? 0 : (64 << use);
	}

	if (PPUType > RP2C02) Cart.WorkRAMSize = 0x800; // VS. 6000-7fff 2k (mirrored)

	switch (ROMCRC) {
		case 0x478a04d8:
			Cart.WorkRAMSize = 0x4000; // Genghis Khan 16k SRAM/WRAM
			break;

		case 0x6f5f3bd2:
		case 0x6f8906ad:
			Cart.WorkRAMSize = 0x8000; // Final Fantasy 1 & 2 (Japan/T-eng) 32k SRAM/WRAM
			break;
	}

	bprintf(0, _T("Cartridge RAM: %d\n"), Cart.WorkRAMSize);
	Cart.WorkRAM = (UINT8*)BurnMalloc(Cart.WorkRAMSize);
	if (Cart.WorkRAMSize == 0) NESMode |= NO_WORKRAM;

	if (Cart.Trainer) {
		// This is not a trainer in the traditional sense.  It was a little
		// block of ram on early nes/fc copy-machines to simulate certain
		// mappers with code.
		bprintf(0, _T("ROM has Trainer code, mapping @ 0x7000.\n"));
		if (Cart.WorkRAMSize == 0x2000) {
			memcpy(Cart.WorkRAM + 0x1000, ROMData + 0x10, 0x200);
		} else {
			bprintf(PRINT_ERROR, _T("Invalid WorkRam size, can't use Trainer data.\n"));
		}
	}

	// set-up MAPPER
	bprintf(0, _T("Cartridge Mapper: %d   Mirroring: "), Cart.Mapper);
	switch (Cart.Mirroring) {
		case 0: bprintf(0, _T("Horizontal")); break;
		case 1: bprintf(0, _T("Vertical")); break;
		case 4: bprintf(0, _T("Four-Screen")); break;
		default: bprintf(0, _T("???")); break;
	}
	bprintf(0, _T(" (%d)\n"), Cart.Mirroring);

	if (mapper_init(Cart.Mapper) == -1) {
		bprintf(0, _T("Unsupported mapper\n"));
		return 1;
	}

	if (Cart.BatteryBackedSRAM) {
		bprintf(0, _T("Game has battery-backed sRAM\n"));
	}

	Cart.PRGRomMask = Cart.PRGRomSize - 1;
	Cart.WorkRAMMask = Cart.WorkRAMSize - 1;

	// Game-specific stuff:
	// Mapper 7 or 4-way mirroring usually gets no workram (6000-7fff)
	if (Cart.Mapper == 7 || (Cart.Mirroring == 4 && !(PPUType > RP2C02)))
		NESMode |= NO_WORKRAM; // VS. is exempt from this limitation.

	NESMode |= (ROMCRC == 0xab29ab28) ? BUS_CONFLICTS : 0; // Dropzone
	NESMode |= (ROMCRC == 0xe3a6d7f6) ? BUS_CONFLICTS : 0; // Cybernoid
	NESMode |= (ROMCRC == 0x552a903a) ? BUS_CONFLICTS : 0; // Huge Insect
	NESMode |= (ROMCRC == 0xb90a1ca1) ? NO_WORKRAM : 0; // Low G Man
	NESMode |= (ROMCRC == 0xa905cc12) ? NO_WORKRAM : 0; // Bill & Ted
	NESMode |= (ROMCRC == 0xc00c4ea5) ? APU_HACKERY : 0; // Sam's Journey
	NESMode |= (ROMCRC == 0x585f3500) ? ALT_MMC3 : 0; // Darkwing Duck (T-Chi)
	NESMode |= (ROMCRC == 0x38f65b2d) ? BAD_HOMEBREW : 0; // Battler (HB)
	NESMode |= (ROMCRC == 0x273aeace) ? ALT_TIMING : 0; // full_nes_palette
	NESMode |= (ROMCRC == 0x6673e5da) ? ALT_TIMING : 0; // t.atom
	NESMode |= (ROMCRC == 0xd5e10c90) ? ALT_TIMING : 0; // astro boy
	NESMode |= (ROMCRC == 0xc9f3f439) ? ALT_TIMING : 0; // vs. freedom force
	NESMode |= (ROMCRC == 0x53eb8950) ? ALT_TIMING : 0; // freedom force
	NESMode |= (ROMCRC == 0x560142bc) ? ALT_TIMING2 : 0; // don doko don 2
	NESMode |= (ROMCRC == 0xe39e0be2) ? ALT_TIMING2 : 0; // laser invasion
	NESMode |= (ROMCRC == 0x47d22165) ? BAD_HOMEBREW : 0; // animal clipper
	NESMode |= (ROMCRC == 0x70eac605) ? ALT_TIMING : 0; // deblock
	NESMode |= (ROMCRC == 0x3616c7dd) ? ALT_TIMING : 0; // days of thunder
	NESMode |= (ROMCRC == 0xeb506bf9) ? ALT_TIMING : 0; // star wars
	NESMode |= (ROMCRC == 0xa2d504a8) ? ALT_TIMING : 0; // assimilate
	NESMode |= (ROMCRC == 0x4df9d7c8) ? ALT_TIMING : 0; // overlord
	NESMode |= (ROMCRC == 0x85784e11) ? ALT_TIMING : 0; // blargg full palette
	NESMode |= (ROMCRC == 0x5da28b4f) ? ALT_TIMING : 0; // cmc! wall demo
	NESMode |= (ROMCRC == 0xab862073) ? ALT_TIMING : 0; // ultimate frogger champ.
	NESMode |= (ROMCRC == 0x2a798367) ? ALT_TIMING : 0; // jy 45-in-1
	NESMode |= (ROMCRC == 0xb9fd4de8) ? ALT_TIMING : 0; // over obj (glitch as boss materializes w/o this)
	NESMode |= (ROMCRC == 0xb4255e99) ? (IS_PAL | SHOW_OVERSCAN) : 0; // Moonglow (HB)
	NESMode |= (ROMCRC == 0x78716f4f) ? RAM_RANDOM : 0; // Go! Dizzy Go!
	NESMode |= (ROMCRC == 0x8c4f37e2) ? RAM_RANDOM : 0; // Minna no Taabou no Nakayoshi Daisakusen (Japan)
	NESMode |= (ROMCRC == 0x17336a80) ? RAM_RANDOM : 0; // Minna no Taabou no Nakayoshi Daisakusen (T-Eng)
	NESMode |= (ROMCRC == 0xc0b4bce5) ? RAM_RANDOM : 0; // Terminator 2 (T2) - Judgement Day
	NESMode |= (ROMCRC == 0xdfdec378) ? RAM_RANDOM : 0; // Huang Di (Player jumps through the top of screen without this)
	NESMode |= (ROMCRC == 0x4d58c832) ? IS_PAL : 0; // Hammerin' Harry
	NESMode |= (ROMCRC == 0x149e367f) ? IS_PAL : 0; // Lion King, The
	NESMode |= (ROMCRC == 0xbf80b241) ? IS_PAL : 0; // Mr. Gimmick
	NESMode |= (ROMCRC == 0x4cf12d39) ? IS_PAL : 0; // Elite
	NESMode |= (ROMCRC == 0x3a0b6dd2) ? IS_PAL : 0; // Hero Quest
	NESMode |= (ROMCRC == 0x6d1e30a7) ? IS_PAL : 0; // TMHT
	NESMode |= (ROMCRC == 0xa5bbb96b) ? IS_PAL : 0; // TMHTII
	NESMode |= (ROMCRC == 0x6453f65e) ? IS_PAL : 0; // Uforia
	NESMode |= (ROMCRC == 0x55cbc495) ? IS_PAL : 0; // Super Turrican
	NESMode |= (ROMCRC == 0x11a245a0) ? IS_PAL : 0; // Rod Land
	NESMode |= (ROMCRC == 0xa535e1be) ? IS_PAL : 0; // Rackets and Rivals
	NESMode |= (ROMCRC == 0x8236d3e0) ? IS_PAL : 0; // Probotector
	NESMode |= (ROMCRC == 0x1d2fb2b7) ? IS_PAL : 0; // Shadow Warriors
	NESMode |= (ROMCRC == 0x96b6a919) ? IS_PAL : 0; // Shadow Warriors II
	NESMode |= (ROMCRC == 0x22ad4753) ? IS_PAL : 0; // Parodius
	NESMode |= (ROMCRC == 0xdcd55bec) ? IS_PAL : 0; // Aladdin
	NESMode |= (ROMCRC == 0xe08a5881) ? IS_PAL : 0; // Beauty and the Beast
	NESMode |= (ROMCRC == 0xcbde707e) ? IS_PAL : 0; // International Cricket
	NESMode |= (ROMCRC == 0xe2685bbf) ? IS_PAL : 0; // Kick Off
	NESMode |= (ROMCRC == 0xab21ab5f) ? IS_PAL : 0; // Noah's Ark
	NESMode |= (ROMCRC == 0xab29ab28) ? IS_PAL : 0; // Dropzone
	NESMode |= (ROMCRC == 0xde7e6767) ? IS_PAL : 0; // Asterix
	NESMode |= (ROMCRC == 0xdc7a16e6) ? IS_PAL : 0; // Parasol Stars
	NESMode |= (ROMCRC == 0xfac97247) ? IS_PAL : 0; // Rainbow Islands (Ocean)
	NESMode |= (ROMCRC == 0x732b1a7a) ? IS_PAL : 0; // Smurfs, The

	if (NESMode) {
		bprintf(0, _T("Game-specific configuration:\n"));

		for (UINT32 i = 1; i != 0x0000; i <<= 1) {
			switch (NESMode & i) {
				case NO_WORKRAM:
					bprintf(0, _T("*  Disabling cart. work-ram (6000-7fff)\n"));
					break;

				case BUS_CONFLICTS:
					bprintf(0, _T("*  Enabling BUS-CONFLICTS.\n"));
					break;

				case ALT_TIMING:
					bprintf(0, _T("*  Enabling ALT-TIMING.\n"));
					break;

				case ALT_TIMING2:
					bprintf(0, _T("*  Enabling ALT-TIMING2.\n"));
					break;

				case APU_HACKERY:
					bprintf(0, _T("*  Enabling APU_HACKERY.\n"));
					break;

				case IS_PAL:
					bprintf(0, _T("*  Enabling PAL weirdness.\n"));
					break;

				case RAM_RANDOM:
					bprintf(0, _T("*  Init RAM w/random bytes.\n"));
					break;

				case FLASH_EEPROM:
					bprintf(0, _T("*  Flash EEPROM loads/saves.\n"));
					break;
			}
		}
	}

	return 0;
}

static INT32 filediff(TCHAR *file1, TCHAR *file2)
{
	FILE *fp1, *fp2;
	INT32 len1, len2;
	UINT8 c1, c2;

	fp1 = _tfopen(file1, _T("rb"));
	if (!fp1) return -1;
	fp2 = _tfopen(file2, _T("rb"));
	if (!fp2) {
		fclose(fp1);
		return -2;
	}

	fseek(fp1, 0, SEEK_END);
	len1 = ftell(fp1);
	fseek(fp1, 0, SEEK_SET);

	fseek(fp2, 0, SEEK_END);
	len2 = ftell(fp2);
	fseek(fp2, 0, SEEK_SET);

	if (!len1 || !len2 || len1 != len2) {
		fclose(fp1);
		fclose(fp2);
		bprintf(0, _T("filediff(): length mismatch\n"));
		return -3;
	}

	for (INT32 i = 0; i < len1; i++) {
		fread(&c1, 1, 1, fp1);
		fread(&c2, 1, 1, fp2);
		if (c1 != c2) {
			fclose(fp1);
			fclose(fp2);
			bprintf(0, _T("filediff(): difference at offset $%x\n"));
			return -3;
		}
	}

	fclose(fp1);
	fclose(fp2);

	return 0; // file1 == file2
}

static INT32 ips_make(UINT8 *orig_data, UINT8 *new_data, INT32 size_data, TCHAR *ips_dir, TCHAR *ips_fn)
{
	#ifndef BUILD_WIN32
	#define _wunlink unlink
	#define _wrename rename
	#endif
	char iPATCH[6] = "PATCH";
	char iEOF[4] = "EOF";
	TCHAR ips_path_fn[MAX_PATH];
	TCHAR ips_path_fn_temp[MAX_PATH];
	INT32 ips_address;
	UINT8 ips_address_c[3];

	INT32 ips_length;
	UINT8 ips_length_c[2];

	INT32 rle_good;
	INT32 rle_length;
	UINT8 rle_byte;

	INT32 is_difference = 0;
	for (INT32 i = 0; i < size_data; i++)
	{
		if (orig_data[i] != new_data[i]) {
			is_difference = 1;
			break;
		}
	}

	if (is_difference == 0) return -2; // no change!

	_stprintf(ips_path_fn, _T("%s%s"), ips_dir, ips_fn);
	_stprintf(ips_path_fn_temp, _T("%s%s.temp"), ips_dir, ips_fn);

	bprintf(0, _T("ips_make() writing to [%s]\n"), ips_path_fn_temp);
	FILE *f = _tfopen(ips_path_fn_temp, _T("wb"));
	if (!f) return -1; // uhoh! (can't open file for writing)

	fwrite(&iPATCH, 1, 5, f);
	for (INT32 i = 0; i < size_data; i++)
	{
		if (orig_data[i] == new_data[i]) continue;

		ips_address = i;

		rle_good = 0;
		rle_length = 0;
		rle_byte = new_data[i];
		ips_length = 0;

		if (ips_address == 0x454f46) { // 'EOF'
			ips_length = 1; // Patch @ BAD ADDRESS (0x454f46), let's go back 1 byte and start here.
			ips_address--;
			if (rle_byte == new_data[ips_address]) {
				//printf("BAD ADDRESS-1 + RLE possible.\n");
				rle_length++;
			}
		}

		while ( (i < size_data) && (ips_length < 0xfce2)
			   && ((orig_data[i] != new_data[i])
				   || (rle_good && rle_byte == new_data[i])) ) // rle-opti: so we don't create multiple rle-chunks if a couple bytes are unchanged
		{
			if (rle_byte == new_data[i]) {
				if (rle_length == ips_length && rle_length > 3) {
					rle_good = 1;
				}
				rle_length++;
				if (rle_length > 5 && rle_good == 0) {
					// dump patch from before rle so the next contiguous block
					// is the rle block.
					if (i - rle_length == 0x454f46-1) {
						// this is not a good spot to rewind to.. abort rle for now.
						rle_length = 0;
					} else {
						i -= rle_length;
						ips_length -= rle_length;
						i--;
						break;
					}
				}
			} else if (rle_good) {
				i--;
				break;
			} else {
				rle_length = 0;
				rle_byte = new_data[i];
			}

			ips_length++;
			i++;
		}
		//printf("%spatchy @ %x   len %x  rle_len %x\n", ((rle_good)?"RLE-":""),ips_address, ips_length, rle_length);
		ips_address_c[0] = (ips_address >> 16) & 0xff;
		ips_address_c[1] = (ips_address >>  8) & 0xff;
		ips_address_c[2] = (ips_address >>  0) & 0xff;

		if (rle_good) ips_length = 0;

		ips_length_c[0] = (ips_length >> 8) & 0xff;
		ips_length_c[1] = (ips_length >> 0) & 0xff;

		fwrite(&ips_address_c, 1, 3, f);
		fwrite(&ips_length_c, 1, 2, f);
		if (rle_good) {
			ips_length_c[0] = (rle_length >> 8) & 0xff;
			ips_length_c[1] = (rle_length >> 0) & 0xff;
			fwrite(&ips_length_c, 1, 2, f);
			fwrite(&rle_byte, 1, 1, f);
		} else {
			fwrite(&new_data[ips_address], 1, ips_length, f);
		}
	}

	fwrite(&iEOF, 1, 3, f);

	fclose(f);

	// Check if the newly written patch is the same as previously written..
	if (filediff(ips_path_fn_temp, ips_path_fn)) {
		// Patch differs!
		// re-order backups
		const INT32 MAX_BACKUPS = 10;
		for (INT32 i = MAX_BACKUPS; i >= 0; i--) {
			TCHAR szBackupNameTo[MAX_PATH];
			TCHAR szBackupNameFrom[MAX_PATH];

			_stprintf(szBackupNameTo, _T("%s%s.backup%d"), ips_dir, ips_fn, i + 1);
			_stprintf(szBackupNameFrom, _T("%s%s.backup%d"), ips_dir, ips_fn, i);
			if (i == MAX_BACKUPS) {
				_wunlink(szBackupNameFrom); // make sure there is only MAX_BACKUPS :)
			} else {
				_wrename(szBackupNameFrom, szBackupNameTo); //derp.ips.backup0 -> derp.ips.backup1
				if (i == 0) {
					_wrename(ips_path_fn, szBackupNameFrom); //derp.ips -> derp.ips.backup0
				}
			}
		}
		// Rename temp patch filename to real patch filename
		int rc = _wrename(ips_path_fn_temp, ips_path_fn);
		bprintf(0, _T("wrename rc = %d   errno = %d\n"), rc, errno);
		bprintf(0, _T("-- lastly temp to non-temp -- rename %s %s\n"), ips_path_fn_temp, ips_path_fn);
		bprintf(0, _T("--- Fresh new IPS patch written: %s\n"), ips_path_fn);
	} else {
		bprintf(0, _T("--- IPS Patch from this session same as last - aborting write!\n"));
		return -2; // no change!
	}

	return 0;
}

static INT32 ips_patch(UINT8 *data, INT32 size_data, TCHAR *ips_fn)
{
	UINT8 buf[7] = "\0\0\0\0\0\0";

	UINT32 ips_address;
	UINT32 ips_length;

	INT32 rle_repeat;
	UINT8 rle_byte;

	FILE *f = _tfopen(ips_fn, _T("rb"));
	if (!f) return -1;

	fread(&buf, 1, 5, f);
	if (memcmp(&buf, "PATCH", 5) != 0) {
		fclose(f);
		return -2;
	}

	while (!feof(f))
	{
		memset(&buf, 0, 3);
		fread(buf, 1, 3, f);
		if (memcmp(&buf, "EOF", 3) == 0) {
			break;
		}
		ips_address = ((buf[0] << 16) & 0xff0000) | ((buf[1] << 8) & 0xff00) | (buf[2] & 0xff);

		memset(&buf, 0, 3);
		fread(buf, 1, 2, f);
		ips_length = ((buf[0] << 8) & 0xff00) | (buf[1] & 0xff);

		if (ips_length == 0) { // RLE chunk
			fread(buf, 1, 3, f);
			rle_repeat = ((buf[0] << 8) & 0xff00) | (buf[1] & 0xff);
			rle_byte = buf[2];

			if (ips_address + rle_repeat <= size_data) { // ok to patch
				memset(&data[ips_address], rle_byte, rle_repeat);
			} else {
				//printf("patch grow disabled, aborting.\n");
				break;
			}
		} else { // normal chunk
			if (ips_address + ips_length <= size_data) { // ok to patch
				fread(&data[ips_address], 1, ips_length, f);
			} else {
				//printf("patch grow disabled, aborting.\n");
				break;
			}
		}
	}

	fclose(f);

	return 0;
}

static void SaveIPSPatch(TCHAR *desc, UINT8 *rom_orig, UINT8 *rom_, INT32 rom_size)
{
	TCHAR patch_fn[MAX_PATH];
	_stprintf(patch_fn, _T("%s.ips"), BurnDrvGetText(DRV_NAME));
	INT32 ips = ips_make(rom_orig, rom_, rom_size, szAppEEPROMPath, patch_fn);
	bprintf(0, _T("* %s patch: "), desc);
	switch (ips) {
		case  0: bprintf(0, _T("Saved.\n")); break;
		case -1: bprintf(0, _T("Can't Save (File I/O Error).\n")); break;
		case -2: bprintf(0, _T("No Change.\n")); break;
	}
}

static void LoadIPSPatch(TCHAR *desc, UINT8 *rom_, INT32 rom_size)
{
	TCHAR szFilename[MAX_PATH];
	_stprintf(szFilename, _T("%s%s.ips"), szAppEEPROMPath, BurnDrvGetText(DRV_NAME));
	INT32 ips = ips_patch(rom_, rom_size, szFilename);
	bprintf(0, _T("* %s ips patch: %s\n"), desc, (ips == 0) ? _T("Loaded") : _T("Can't Load/Not Found."));
}

static INT32 fds_load(UINT8* ROMData, UINT32 ROMSize, UINT32 ROMCRC)
{
	bprintf(0, _T("FDS Loader\n"));
	if (NULL == ROMData || ROMSize < 8192 ) {
		bprintf(0, _T("Invalid ROM data!\n"));
		return 1;
	}

	// FDS mem map:
	// 6000 - dfff RAM
	// e000 - ffff ROM (FDS Bios)

	memset(&Cart, 0, sizeof(Cart));

	PPUType = RP2C02;

	Cart.FDSMode = 1;
	Cart.FDSDiskRaw = (UINT8*)BurnMalloc(0x100000);
	Cart.FDSDiskRawOrig = (UINT8*)BurnMalloc(0x100000);
	Cart.FDSDisk = Cart.FDSDiskRaw;
	Cart.FDSDiskRawSize = ROMSize;
	Cart.FDSDiskRawOrigSize = ROMSize;
	Cart.FDSDiskSize = ROMSize;
	Cart.FDSDiskSides = ROMSize / 65500;
	if (BurnLoadRom(Cart.FDSDiskRaw, 0, 1)) return 1; // load FDS Disk Image
	if (BurnLoadRom(Cart.FDSDiskRawOrig, 0, 1)) return 1; // load FDS Disk Image

	// Load IPS patch (aka: disk-saves @ exit)
	LoadIPSPatch(_T("FDS Disk"), Cart.FDSDiskRaw, Cart.FDSDiskRawSize);

	if (!memcmp("FDS\x1a", &Cart.FDSDiskRaw[0], 4) && ROMSize > 0x10) {
		Cart.FDSDisk += 0x10;
		Cart.FDSDiskSize -= 0x10;
		bprintf(0, _T("* Skipping useless fds header..\n"));
	}

	Cart.Crc = ROMCRC;
	Cart.PRGRomSize = 0x8000;
	Cart.CHRRomSize = 0; // ram only
	Cart.Mirroring = 1; // for bios, but fds-mapper-controlled
	Cart.Mapper = 0x808; // fake mapper# for fds

	bprintf(0, _T("Disk Size: %d (%d sides)\n"), ROMSize, Cart.FDSDiskSides);
	bprintf(0, _T("PRG Size: %d\n"), Cart.PRGRomSize);
	bprintf(0, _T("CHR Size: %d\n"), Cart.CHRRomSize);

	switch (Cart.Mirroring) {
		case 0: set_mirroring(HORIZONTAL); break;
		case 1: set_mirroring(VERTICAL); break;
		case 4: set_mirroring(FOUR_SCREEN); break;
	}

//	Cart.BatteryBackedSRAM = (ROMData[6] & 0x2) >> 1;
	Cart.PRGRom = ROMData;

	// Default CHR-Ram size (8k), always set-up (for advanced mappers, etc)
	Cart.CHRRamSize = 0x2000;
	Cart.CHRRam = (UINT8*)BurnMalloc(Cart.CHRRamSize);
	mapper_set_chrtype(MEM_RAM);
	bprintf(0, _T("Using RAM CHR data (%dk bytes)\n"), Cart.CHRRamSize / 1024);

	// set-up Cart PRG-RAM/WORK-RAM (6000-7fff)
	Cart.WorkRAMSize = 0x2000;
	bprintf(0, _T("Cartridge RAM: %d\n"), Cart.WorkRAMSize);
	Cart.WorkRAM = (UINT8*)BurnMalloc(Cart.WorkRAMSize);

	// set-up MAPPER
	bprintf(0, _T("Cartridge Mapper: %d   Mirroring: "), Cart.Mapper);
	switch (Cart.Mirroring) {
		case 0: bprintf(0, _T("Horizontal")); break;
		case 1: bprintf(0, _T("Vertical")); break;
		case 4: bprintf(0, _T("Four-Screen")); break;
		default: bprintf(0, _T("???")); break;
	}
	bprintf(0, _T(" (%d)\n"), Cart.Mirroring);

	if (mapper_init(Cart.Mapper) == -1) {
		bprintf(0, _T("Unsupported mapper\n"));
		return 1;
	}

	if (Cart.BatteryBackedSRAM) {
		bprintf(0, _T("Game has battery-backed sRAM\n"));
	}

	Cart.PRGRomMask = Cart.PRGRomSize - 1;
	Cart.WorkRAMMask = Cart.WorkRAMSize - 1;

	// Game-specific stuff:
	NESMode = IS_FDS;

	if (NESMode) {
		bprintf(0, _T("Game-specific configuration:\n"));

		switch (NESMode) {
			case NO_WORKRAM:
				bprintf(0, _T("*  Disabling cart. work-ram (6000-7fff)\n"));
				break;

			case BUS_CONFLICTS:
				bprintf(0, _T("*  Enabling BUS-CONFLICTS.\n"));
				break;

			case ALT_TIMING:
				bprintf(0, _T("*  Enabling ALT-TIMING.\n"));
				break;

			case IS_PAL:
				bprintf(0, _T("*  Enabling PAL weirdness.\n"));
				break;
		}
	}

	return 0;
}

// ---- mapper system begins! ----
static UINT32 PRGMap[4];
static UINT8  PRGType[4];
static UINT32 CHRMap[8];
static UINT8  CHRType[8]; // enum { MEM_RAM = 0, MEM_RAM_RO = 1, MEM_ROM = 2};
static UINT8  mapper_regs[0x20]; // General-purpose mapper registers (8bit)
static UINT16 mapper_regs16[0x20]; // General-purpose mapper registers (16bit)
static INT32 mapper_irq_exec; // cycle-delayed irq for mapper_irq();
static void mapper_irq(INT32 cyc); // forward

// mapping expansion ram/rom (6000 - 7fff)  refer to mapper69 for hookup info
static INT32 PRGExpMap;
static void  (*cart_exp_write)(UINT16 address, UINT8 data) = NULL;
static UINT8 (*cart_exp_read)(UINT16 address) = NULL;
static INT32 cart_exp_write_abort; // abort fallthrough - see mapper68
// mapping 4020 - 5fff, use these callbacks. refer to Sachen 8259
static void  (*psg_area_write)(UINT16 address, UINT8 data) = NULL;
static UINT8 (*psg_area_read)(UINT16 address) = NULL;
static UINT8 read_nt_int(UINT16 address);

static void mapper_map_prg(INT32 pagesz, INT32 slot, INT32 bank, INT32 type = MEM_ROM) // 8000 - ffff
{
	INT32 ramromsize = (type == MEM_ROM) ? Cart.PRGRomSize : Cart.WorkRAMSize;

	if (!ramromsize) return;

	if (bank < 0) { // negative bank == map page from end of rom
		bank = (ramromsize / (pagesz * 1024)) + bank;
	}

	for (INT32 i = 0; i < (pagesz / 8); i++) {
		PRGMap[(pagesz / 8) * slot + i] = (pagesz * 1024 * bank + 0x2000 * i) % ramromsize;
		PRGType[(pagesz / 8) * slot + i] = type;
	}
}

static void mapper_map_exp_prg(INT32 bank, INT32 type = MEM_ROM) // 6000 - 7fff area (cartridge expansion ram/sram or battery backed ram)
{
	INT32 ramromsize = (type == MEM_ROM) ? Cart.PRGRomSize : Cart.WorkRAMSize;

	if (bank < 0) { // negative bank == map page from end of rom
		bank = (ramromsize / 0x2000) + bank;
	}

	PRGExpMap = (0x2000 * bank) % ramromsize;
}

static void mapper_set_chrtype(INT32 type)
{
	for (INT32 i = 0; i < 8; i++)
		CHRType[i] = type;
}

static void mapper_map_chr(INT32 pagesz, INT32 slot, INT32 bank)
{
	for (INT32 i = 0; i < pagesz; i++) {
		switch (CHRType[pagesz * slot + i]) {
			case MEM_ROM:
				CHRMap[pagesz * slot + i] = (pagesz * 1024 * bank + 1024 * i) % Cart.CHRRomSize;
				break;

			case MEM_RAM:
			case MEM_RAM_RO:
				CHRMap[pagesz * slot + i] = (pagesz * 1024 * bank + 1024 * i) % Cart.CHRRamSize;
				break;
		}
	}
}

#define MAP_CHR_RAMROM_DEBUG 0

static void mapper_map_chr_ramrom(INT32 pagesz, INT32 slot, INT32 bank, INT32 type)
{
	if (type > MEM_ROM) {
		bprintf(0, _T("mapper_map_chr_ramrom(): invalid type field!!\n"));
	}

#if MAP_CHR_RAMROM_DEBUG
	bprintf(0, _T("mapper_map_chr_ramrom(%x, %x, %x, %x)\n"), pagesz, slot, bank, type);
#endif

	for (INT32 i = 0; i < pagesz; i++) {
		switch (type) {
			case MEM_ROM:
				CHRMap[pagesz * slot + i] = (pagesz * 1024 * bank + 1024 * i) % Cart.CHRRomSize;
				CHRType[pagesz * slot + i] = MEM_ROM;
#if MAP_CHR_RAMROM_DEBUG
				bprintf(0, _T("ROM: CHRMap[%x] = %x\n"),pagesz * slot + i, (pagesz * 1024 * bank + 1024 * i) % Cart.CHRRomSize);
#endif
				break;

			case MEM_RAM:
			case MEM_RAM_RO:
				CHRMap[pagesz * slot + i] = (pagesz * 1024 * bank + 1024 * i) % Cart.CHRRamSize;
				CHRType[pagesz * slot + i] = type;
#if MAP_CHR_RAMROM_DEBUG
				bprintf(0, _T("RAM: CHRMap[%x] = %x\n"),pagesz * slot + i, (pagesz * 1024 * bank + 1024 * i) % Cart.CHRRamSize);
#endif
				break;
		}
	}
}

static UINT8 mapper_prg_read_int(UINT16 address) // mapper_prg_read points here
{
	switch (PRGType[(address & ~0x8000) / 0x2000]) {
		case MEM_ROM:
			return Cart.PRGRom[PRGMap[(address & ~0x8000) / 0x2000] + (address & 0x1fff)];
		case MEM_RAM:
			return Cart.WorkRAM[PRGMap[(address & ~0x8000) / 0x2000] + (address & 0x1fff)];
	}

	bprintf(0, _T("PRGType[] corruption?\n"));
	return 0x00;
}

static void mapper_prg_write(UINT16 address, UINT8 data)
{
	switch (PRGType[(address & ~0x8000) / 0x2000]) {
		case MEM_RAM:
			Cart.WorkRAM[PRGMap[(address & ~0x8000) / 0x2000] + (address & 0x1fff)] = data;
	}
}

static UINT8 mapper_chr_read(UINT16 address)
{
	switch (CHRType[address / 1024]) {
		case MEM_ROM:
			return Cart.CHRRom[CHRMap[address / 1024] + (address & (1024 - 1))];

		case MEM_RAM:
		case MEM_RAM_RO:
			return Cart.CHRRam[CHRMap[address / 1024] + (address & (1024 - 1))];
	}

	return 0x00;
}

static void mapper_chr_write(UINT16 address, UINT8 data)
{
	if (CHRType[address / 1024] == MEM_RAM) {
		Cart.CHRRam[CHRMap[address / 1024] + (address & (1024 - 1))] = data;
	}
}

// Flippy Disk ICON (thanks iq_132! :)
static UINT8 disk_ab[] = {
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
	0x00, 0x07, 0x07, 0x07, 0x03, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x03, 0x07, 0x07, 0x07, 0x00, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
	0x00, 0x07, 0x07, 0x07, 0x03, 0x07, 0x07, 0x00, 0x00, 0x07, 0x07, 0x0f, 0x07, 0x07, 0x07, 0x00, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x0f, 0x01, 0x0e, 0x01, 0x03, 0x09, 0x09, 0x09, 0x09, 0x09,
	0x00, 0x07, 0x07, 0x07, 0x0f, 0x07, 0x07, 0x00, 0x00, 0x07, 0x07, 0x03, 0x07, 0x07, 0x07, 0x00, 0x09, 0x04, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x0c, 0x0d, 0x00, 0x0d, 0x0e, 0x0a, 0x00, 0x02, 0x09, 0x09, 0x09, 0x09,
	0x00, 0x07, 0x07, 0x07, 0x03, 0x07, 0x07, 0x00, 0x00, 0x07, 0x07, 0x0f, 0x07, 0x07, 0x07, 0x00, 0x09, 0x04, 0x04, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x0d, 0x00, 0x00, 0x0c, 0x09, 0x0f, 0x00, 0x00, 0x06, 0x09, 0x09, 0x09,
	0x00, 0x07, 0x07, 0x07, 0x03, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x03, 0x07, 0x07, 0x07, 0x00, 0x09, 0x04, 0x04, 0x04, 0x09, 0x09, 0x09, 0x09, 0x09, 0x08, 0x00, 0x00, 0x0d, 0x09, 0x09, 0x09, 0x0a, 0x00, 0x00, 0x03, 0x09, 0x09,
	0x00, 0x07, 0x07, 0x07, 0x03, 0x07, 0x07, 0x00, 0x00, 0x07, 0x07, 0x03, 0x07, 0x07, 0x07, 0x00, 0x09, 0x04, 0x04, 0x04, 0x04, 0x09, 0x09, 0x09, 0x09, 0x02, 0x00, 0x00, 0x06, 0x09, 0x09, 0x09, 0x0d, 0x00, 0x00, 0x06, 0x09, 0x09,
	0x00, 0x07, 0x07, 0x07, 0x03, 0x07, 0x00, 0x09, 0x09, 0x00, 0x07, 0x03, 0x07, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x09, 0x09, 0x09, 0x00, 0x00, 0x00, 0x0e, 0x09, 0x09, 0x09, 0x02, 0x00, 0x00, 0x0a, 0x09, 0x09,
	0x00, 0x07, 0x07, 0x07, 0x0f, 0x07, 0x00, 0x09, 0x09, 0x00, 0x07, 0x0f, 0x07, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x09, 0x03, 0x00, 0x00, 0x00, 0x01, 0x09, 0x09, 0x09, 0x02, 0x00, 0x00, 0x00, 0x0c, 0x09,
	0x00, 0x07, 0x07, 0x07, 0x07, 0x03, 0x07, 0x00, 0x00, 0x07, 0x03, 0x07, 0x07, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x09, 0x09, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x09,
	0x00, 0x07, 0x07, 0x07, 0x07, 0x03, 0x07, 0x07, 0x07, 0x07, 0x03, 0x07, 0x07, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x09, 0x09, 0x09, 0x01, 0x00, 0x00, 0x00, 0x0d, 0x0e, 0x01, 0x0e, 0x05, 0x00, 0x00, 0x00, 0x08, 0x09,
	0x00, 0x07, 0x07, 0x07, 0x07, 0x07, 0x03, 0x03, 0x03, 0x03, 0x07, 0x07, 0x07, 0x07, 0x07, 0x00, 0x09, 0x04, 0x04, 0x04, 0x09, 0x09, 0x09, 0x09, 0x06, 0x00, 0x00, 0x00, 0x01, 0x09, 0x09, 0x09, 0x0d, 0x00, 0x00, 0x00, 0x0b, 0x09,
	0x00, 0x03, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x03, 0x00, 0x09, 0x04, 0x04, 0x09, 0x09, 0x09, 0x09, 0x09, 0x02, 0x00, 0x00, 0x00, 0x01, 0x09, 0x09, 0x09, 0x02, 0x00, 0x00, 0x00, 0x01, 0x09,
	0x00, 0x03, 0x07, 0x07, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x07, 0x07, 0x03, 0x00, 0x09, 0x04, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x06, 0x00, 0x00, 0x00, 0x01, 0x09, 0x09, 0x09, 0x0d, 0x00, 0x00, 0x00, 0x01, 0x09,
	0x00, 0x07, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x07, 0x00, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x02, 0x00, 0x00, 0x00, 0x01, 0x09, 0x09, 0x09, 0x02, 0x00, 0x00, 0x00, 0x01, 0x09,
	0x00, 0x07, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x07, 0x00, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
	0x00, 0x07, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x07, 0x00, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
	0x00, 0x07, 0x07, 0x07, 0x03, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x0f, 0x07, 0x07, 0x07, 0x00, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
	0x00, 0x07, 0x07, 0x07, 0x03, 0x07, 0x07, 0x00, 0x00, 0x07, 0x07, 0x03, 0x07, 0x07, 0x07, 0x00, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x0d, 0x0e, 0x0c, 0x09, 0x09, 0x09, 0x09,
	0x00, 0x07, 0x07, 0x07, 0x0f, 0x07, 0x07, 0x00, 0x00, 0x07, 0x07, 0x03, 0x07, 0x07, 0x07, 0x00, 0x09, 0x04, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x06, 0x00, 0x00, 0x00, 0x0b, 0x03, 0x06, 0x00, 0x00, 0x00, 0x01, 0x09, 0x09, 0x09,
	0x00, 0x07, 0x07, 0x07, 0x03, 0x07, 0x07, 0x00, 0x00, 0x07, 0x07, 0x0f, 0x07, 0x07, 0x07, 0x00, 0x09, 0x04, 0x04, 0x09, 0x09, 0x09, 0x09, 0x09, 0x0e, 0x00, 0x00, 0x00, 0x03, 0x09, 0x03, 0x00, 0x00, 0x00, 0x00, 0x09, 0x09, 0x09,
	0x00, 0x07, 0x07, 0x07, 0x03, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x03, 0x07, 0x07, 0x07, 0x00, 0x09, 0x04, 0x04, 0x04, 0x09, 0x09, 0x09, 0x09, 0x06, 0x00, 0x00, 0x00, 0x03, 0x09, 0x03, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x09, 0x09,
	0x00, 0x07, 0x07, 0x07, 0x03, 0x07, 0x07, 0x00, 0x00, 0x07, 0x07, 0x03, 0x07, 0x07, 0x07, 0x00, 0x09, 0x04, 0x04, 0x04, 0x04, 0x09, 0x09, 0x09, 0x0e, 0x00, 0x00, 0x00, 0x03, 0x09, 0x0b, 0x00, 0x00, 0x00, 0x0a, 0x09, 0x09, 0x09,
	0x00, 0x07, 0x07, 0x07, 0x03, 0x07, 0x00, 0x09, 0x09, 0x00, 0x07, 0x03, 0x07, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x09, 0x09, 0x06, 0x00, 0x00, 0x00, 0x0a, 0x0d, 0x0a, 0x00, 0x0a, 0x02, 0x03, 0x09, 0x09, 0x09,
	0x00, 0x07, 0x07, 0x07, 0x0f, 0x07, 0x00, 0x09, 0x09, 0x00, 0x07, 0x0f, 0x07, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x09, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x02, 0x0c, 0x09, 0x09, 0x09,
	0x00, 0x07, 0x07, 0x07, 0x07, 0x03, 0x07, 0x00, 0x00, 0x07, 0x03, 0x07, 0x07, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x09, 0x09, 0x06, 0x00, 0x00, 0x00, 0x0f, 0x09, 0x0b, 0x00, 0x00, 0x00, 0x05, 0x09, 0x09, 0x09,
	0x00, 0x07, 0x07, 0x07, 0x07, 0x03, 0x07, 0x07, 0x07, 0x07, 0x03, 0x07, 0x07, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x09, 0x09, 0x09, 0x0e, 0x00, 0x00, 0x00, 0x0c, 0x09, 0x09, 0x00, 0x00, 0x00, 0x00, 0x03, 0x09, 0x09,
	0x00, 0x07, 0x07, 0x07, 0x07, 0x07, 0x03, 0x03, 0x03, 0x03, 0x07, 0x07, 0x07, 0x07, 0x07, 0x00, 0x09, 0x04, 0x04, 0x04, 0x09, 0x09, 0x09, 0x09, 0x0e, 0x00, 0x00, 0x00, 0x0c, 0x09, 0x09, 0x00, 0x00, 0x00, 0x00, 0x03, 0x09, 0x09,
	0x00, 0x03, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x03, 0x00, 0x09, 0x04, 0x04, 0x09, 0x09, 0x09, 0x09, 0x09, 0x06, 0x00, 0x00, 0x00, 0x0c, 0x09, 0x09, 0x00, 0x00, 0x00, 0x0a, 0x09, 0x09, 0x09,
	0x00, 0x03, 0x07, 0x07, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x07, 0x07, 0x03, 0x00, 0x09, 0x04, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x0e, 0x00, 0x00, 0x00, 0x01, 0x03, 0x06, 0x00, 0x00, 0x0a, 0x0f, 0x09, 0x09, 0x09,
	0x00, 0x07, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x07, 0x00, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x02, 0x01, 0x0c, 0x09, 0x09, 0x09, 0x09,
	0x00, 0x07, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x07, 0x00, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
	0x00, 0x07, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x07, 0x00, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09
};

static UINT8 disk_ab_pal[] = {
	0x01, 0x01, 0x01,
	0x87, 0x87, 0x87,
	0x4c, 0x4c, 0x4c,
	0xc4, 0xc4, 0xc4,
	0x25, 0x1d, 0xed,
	0x27, 0x27, 0x27,
	0x66, 0x66, 0x66,
	0xb1, 0xe5, 0xef,
	0xa6, 0xa6, 0xa6,
	0xff, 0xff, 0xff,
	0x19, 0x19, 0x19,
	0x98, 0x98, 0x98,
	0xe1, 0xe1, 0xe1,
	0x3b, 0x3b, 0x3b,
	0x75, 0x75, 0x75,
	0xba, 0xba, 0xba
};

// ---[ mapper FDS (Famicom Disk System) #0x808 (2056)
#define mapperFDS_ioenable		(mapper_regs[0x1f - 0]) // 4023
#define mapperFDS_control		(mapper_regs[0x1f - 1]) // 4025

#define mapperFDS_eighth_bit 	(mapper_regs[0x1f - 2])
#define mapperFDS_in_irq		(mapper_regs[0x1f - 3])

#define mapperFDS_irqenable		(mapper_regs[0x1f - 4])
#define mapperFDS_irqrepeat		(mapper_regs[0x1f - 5])
#define mapperFDS_irqcount		(mapper_regs16[0x1f - 0])
#define mapperFDS_irqlatch		(mapper_regs16[0x1f - 1])

#define mapperFDS_diskside		(mapper_regs[0x1f - 6])
#define mapperFDS_diskinsert	(mapper_regs[0x1f - 7])
#define mapperFDS_diskaccessed	(mapper_regs[0x1f - 8])
#define mapperFDS_diskaddr		(mapper_regs16[0x1f - 2])
#define mapperFDS_diskirqcount	(mapper_regs16[0x1f - 3])
#define mapperFDS_arm_timer() 	do { mapperFDS_diskirqcount = 150; } while (0)
#define mapperFDS_filesize      (mapper_regs16[0x1f - 4])
#define mapperFDS_blockid       (mapper_regs16[0x1f - 5])
#define mapperFDS_blockstart    (mapper_regs16[0x1f - 6])
#define mapperFDS_blocklen      (mapper_regs16[0x1f - 7])
#define fds_disk() 				(Cart.FDSDisk[(mapperFDS_diskside * 65500) + mapperFDS_blockstart + mapperFDS_diskaddr])

static char fdsfile[10]; // for debugging.. remove later!

enum FDS_FrameActions { FA_IDLE = 0, INSERT_DISK = 1, SWAP_DISK = 2, FA_FADEOUT};
enum FDS_DiskBlockIDs { DSK_INIT = 0, DSK_VOLUME, DSK_FILECNT, DSK_FILEHDR, DSK_FILEDATA };

static void FDS_FrameAction(INT32 todo);

static void FDS_Insert(INT32 status)
{
	static INT32 debounce = 0;
	if (status && debounce == 0) {
		mapperFDS_diskinsert ^= 1;
		bprintf(0, _T("FDS_Insert: %d\n"), mapperFDS_diskinsert);
	}
	debounce = status;
}

static void FDS_SwapSides(INT32 status, INT32 no_debounce = 0)
{
	static INT32 debounce = 0;
	if (status && (debounce == 0 || no_debounce) && mapperFDS_diskinsert == 0) {
		mapperFDS_diskside = (mapperFDS_diskside + 1) % Cart.FDSDiskSides;
		bprintf(0, _T("FDS_SwapSides: %d\n"), mapperFDS_diskside);
	}
	debounce = status;
}

static void FDS_SwapSidesAuto(INT32 status)
{
	static INT32 debounce = 0;
	if (status && debounce == 0) {
		FDS_FrameAction(SWAP_DISK);
	}
	debounce = status;
}

static void FDS_FrameAction(INT32 todo)
{
	FDSFrameCounter = 0;
	FDSFrameAction = todo;
}

static void FDS_FrameTicker()
{
	switch (FDSFrameAction) {
		case FA_IDLE:
			break;

		case INSERT_DISK:
			if (FDSFrameCounter == 5) {
				mapperFDS_diskinsert = 1;
				FDSFrameAction = FA_IDLE;
			}
			break;

		case SWAP_DISK:
			if (FDSFrameCounter == 0) {
				FDSFrameDiskIcon = ((mapperFDS_diskside + 1) % Cart.FDSDiskSides) & 1;
			}
			if (FDSFrameCounter == 5) {
				mapperFDS_diskinsert = 0;
			}
			if (FDSFrameCounter == 75) {
				bprintf(0, _T("(auto) "));
				FDS_SwapSides(1, 1);
			}
			if (FDSFrameCounter == 155) {
				mapperFDS_diskinsert = 1;
				FDSFrameAction = FA_FADEOUT;
			}
			break;
		case FA_FADEOUT:
			if (FDSFrameCounter == 155+20) {
				FDSFrameAction = FA_IDLE;
			}
			break;
	}
	FDSFrameCounter++;
}

struct fds_sound {
	UINT8 volmaster;
	UINT8 wavwren_hold;
	UINT8 volgain; // r:4090 w:4080
	UINT8 modgain; // r:4092 w:4084
	UINT8 waveram[0x40];
	UINT8 modwaveram[0x40];

	UINT8 env_master;

	UINT32 wavefreq;
	UINT32 wavepos;
	UINT32 modphase;
	UINT32 modfreq;
	INT32 mod_accu;

	UINT8 mod_counter;
	UINT8 env_all_stop;
	UINT8 wav_stop;
	UINT8 mod_cnt_stop;

	INT32 env_vol_accu;
	UINT8 env_vol_stop;
	UINT8 env_vol_direction;
	UINT8 env_vol_period;

	INT32 env_mod_accu;
	UINT8 env_mod_stop;
	UINT8 env_mod_direction;
	UINT8 env_mod_period;

	INT32 filt_prev;
	INT32 filt_sa;
	INT32 filt_sb;
};

static fds_sound fds;

static void mapperFDS_reset()
{
	BurnLEDReset();

	memset(&fds, 0, sizeof(fds));

	// Auto-"Insertion/Swap" robot
	if (~DrvDips[0] & 2)
		FDS_FrameAction(INSERT_DISK);

	// Init 2khz lp filter coefficient @ 1.786mhz
	double omeg = exp(-2.0 * 3.1415926 * 2000 / (29781 * 60));
    fds.filt_sa = (INT32)(omeg * (double)(1 << 12));
    fds.filt_sb = (1 << 12) - fds.filt_sa;
}

static void mapperFDS_scan()
{
	SCAN_VAR(fds);
	SCAN_VAR(FDSFrameCounter);
	SCAN_VAR(FDSFrameAction);

	// 6000-7fff WRAM(cart_ext) is scanned by system
	ScanVar(Cart.PRGRom, 0x6000, "PRGRAM 8000-dfff");
}

static UINT8 fds_sound_read(UINT16 address)
{
	if (address >= 0x4040 && address <= 0x407f) {
		return fds.waveram[address & 0x3f] | (cpu_open_bus & 0xc0);
	}

	switch (address) {
		case 0x4090: return (fds.volgain & 0x3f) | (cpu_open_bus & 0xc0);
		case 0x4092: return (fds.modgain & 0x3f) | (cpu_open_bus & 0xc0);
	}

	return cpu_open_bus;
}

static void fds_sound_write(UINT16 address, UINT8 data)
{
	if (address >= 0x4040 && address <= 0x407f) {
		if (fds.wavwren_hold) {
			fds.waveram[address & 0x3f] = data & 0x3f;
		}
		return;
	}

	switch (address) {
		case 0x4080:
			fds.env_vol_stop = (data & 0x80) >> 7;
			fds.env_vol_direction = (data & 0x40) >> 6;
			fds.env_vol_period = data & 0x3f;
			if (data & 0x80) {
				fds.volgain = data & 0x3f;
			}
			break;
		case 0x4082:
			fds.wavefreq = (fds.wavefreq & 0x0f00) | data;
			break;
		case 0x4083:
			fds.wavefreq = (fds.wavefreq & 0x00ff) | ((data & 0xf) << 8);
			fds.env_all_stop = (data & 0x40) >> 6;
			fds.wav_stop = (data & 0x80) >> 7;

			if (data & 0x80) {
				// phase reset
				fds.wavepos = 0;
			}
			break;
		case 0x4084:
			fds.env_mod_stop = (data & 0x80) >> 7;
			fds.env_mod_direction = (data & 0x40) >> 6;
			fds.env_mod_period = data & 0x3f;
			if (data & 0x80) {
				fds.modgain = data & 0x3f;
			}
			break;
		case 0x4085:
			fds.mod_counter = data & 0x7f;
			fds.modphase &= 0x3f0000;
			break;
		case 0x4086:
			fds.modfreq = (fds.modfreq & 0x0f00) | data;
			break;
		case 0x4087:
			fds.modfreq = (fds.modfreq & 0x00ff) | ((data & 0xf) << 8);
			fds.mod_cnt_stop = (data & 0x80) >> 7;
			if (data & 0x80) {
				fds.mod_accu = 0;
			}
			break;
		case 0x4088:
			if (fds.mod_cnt_stop) {
				fds.modwaveram[(fds.modphase >> 16) & 0x3f] = data & 7;
				fds.modphase = (fds.modphase + 0x10000) & 0x3fffff;
				fds.modwaveram[(fds.modphase >> 16) & 0x3f] = data & 7;
				fds.modphase = (fds.modphase + 0x10000) & 0x3fffff;
			}
			break;
		case 0x4089:
			fds.volmaster = data & 3;
			fds.wavwren_hold = (data & 0x80) >> 7;
			break;
		case 0x408a:
			fds.env_master = data;
			break;
	}
}

static void env_vol()
{
	if (fds.env_vol_stop == 0) {
		fds.env_vol_accu--;
		if (fds.env_vol_accu <= 0) {
			fds.env_vol_accu += ((fds.env_vol_period + 1) * fds.env_master) << 3;
			if (fds.env_vol_direction) {
				if (fds.volgain < 0x3f) {
					fds.volgain++;
				}
			} else {
				if (fds.volgain > 0) {
					fds.volgain--;
				}
			}
		}
	}
}

static void env_mod()
{
	if (fds.env_mod_stop == 0) {
		fds.env_mod_accu--;
		if (fds.env_mod_accu <= 0) {
			fds.env_mod_accu += ((fds.env_mod_period + 1) * fds.env_master) << 3;
			if (fds.env_mod_direction) {
				if (fds.modgain < 0x3f) {
					fds.modgain++;
				}
			} else {
				if (fds.modgain > 0) {
					fds.modgain--;
				}
			}
		}
	}
}

static void mod_sweep()
{
	INT32 mod = 0;
	if (fds.mod_cnt_stop == 0) {
		fds.mod_accu += fds.modfreq;
		if(fds.mod_accu >= 0x10000) {
			fds.mod_accu -= 0x10000;
			const INT32 BIASTBL[8] = { 0, 1, 2, 4, 0, -4, -2, -1 };
			UINT8 w = fds.modwaveram[(fds.modphase >> 16) & 0x3f];
			fds.mod_counter = (w == 4) ? 0 : (fds.mod_counter + BIASTBL[w]) & 0x7f;
		}
		fds.modphase = (fds.modphase + fds.modfreq) & 0x3fffff;
	}

	if (fds.wav_stop == 0) {
		if (fds.modgain != 0) {
			INT32 pos = (fds.mod_counter < 64) ? fds.mod_counter : (fds.mod_counter-128);

			// nesdev to the rescue! :) (yet again!)
			INT32 temp = pos * ((fds.modgain < 0x20) ? fds.modgain : 0x20);
			INT32 remainder = temp & 0x0f;
			temp >>= 4;
			if (remainder > 0 && ~temp & 0x80) {
				temp += (pos < 0) ? -1 : 2;
			}

			if (temp >= 192) temp -= 256;
			else if (temp < -64) temp += 256;

			temp = fds.wavefreq * temp;
			remainder = temp & 0x3f;
			temp >>= 6;
			if (remainder >= 32) temp += 1;
			mod = temp;
		}

		fds.wavepos = (fds.wavepos + fds.wavefreq + mod) & 0x3fffff;
	}
}

static INT16 mapperFDS_mixer()
{
	UINT32 sample = 0;

	if (fds.env_all_stop == 0 && fds.wav_stop == 0 && fds.env_master != 0) {
		env_vol();
		env_mod();
	}

	mod_sweep();

	if (fds.wavwren_hold == 0) {
		// render sample
		INT32 voltab[4] = { 0x173, 0xf7, 0xb9, 0x95 };
		UINT8 envvol = (fds.volgain > 0x20) ? 0x20 : fds.volgain;
		sample = (fds.waveram[(fds.wavepos >> 16) & 0x3f] * envvol) * voltab[fds.volmaster];
		sample >>= 7;

		// 2khz lp filter
		sample = ((fds.filt_prev * fds.filt_sa) + (sample * fds.filt_sb)) >> 12;
		fds.filt_prev = sample;
	} else {
		sample = fds.filt_prev;
	}

	return sample;
}

static void mapperFDS_cycle()
{
	if (mapperFDS_irqenable) {
		mapperFDS_irqcount--;
		// m6502 cpu core isn't great.. compensate by running irq for 5 cycles longer.
		// Testcases: Marchen Veil HUD, KaetteKita Mario Bros (white bricks cutscene)
		if (mapperFDS_irqcount == 0xffff-5) {
			mapperFDS_irqcount = mapperFDS_irqlatch;
			if (mapperFDS_irqrepeat == 0) {
				mapperFDS_irqenable = 0;
			}
			M6502SetIRQLine(0, CPU_IRQSTATUS_ACK);
			mapperFDS_in_irq = 1;
		}
	}

	if (mapperFDS_diskirqcount > 0) {
		mapperFDS_diskirqcount--;
		if (mapperFDS_diskirqcount == 0) {
			if (mapperFDS_control & 0x80) {
				M6502SetIRQLine(0, CPU_IRQSTATUS_ACK);
				mapperFDS_eighth_bit = 1;
			}
		}
	}
}

static void mapperFDS_map()
{
	set_mirroring((mapperFDS_control & 8) ? HORIZONTAL : VERTICAL);
}

static UINT8 mapperFDS_read(UINT16 address)
{
	UINT8 ret = 0;

	if (mapperFDS_ioenable & 2 && address >= 0x4040 && address <= 0x4097)
		return fds_sound_read(address);

	if (~mapperFDS_ioenable & 1) return cpu_open_bus; // io disabled.

	switch (address) {
		case 0x4030:
			if (mapperFDS_in_irq) ret |= 1;
			if (mapperFDS_eighth_bit) ret |= 2;

			mapperFDS_in_irq = mapperFDS_eighth_bit = 0;
			M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
			break;

		case 0x4031:
			ret = 0xff;
			if (mapperFDS_diskinsert && mapperFDS_control & 0x04) {
				mapperFDS_diskaccessed = 1;

				ret = 0;

				switch (mapperFDS_blockid) {
					case DSK_FILEHDR:
						if (mapperFDS_diskaddr < mapperFDS_blocklen) {
							ret = fds_disk();
							switch (mapperFDS_diskaddr) {
								case 13: mapperFDS_filesize = ret; break;
								case 14:
									mapperFDS_filesize |= ret << 8;
									strncpy(fdsfile, (char*)&Cart.FDSDisk[(mapperFDS_diskside * 65500) + mapperFDS_blockstart + 3], 8);
									bprintf(0, _T("Read file: %S (size: %d)\n"), fdsfile, mapperFDS_filesize);
									break;
							}
							mapperFDS_diskaddr++;
						}
						break;
					default:
						if (mapperFDS_diskaddr < mapperFDS_blocklen) {
							ret = fds_disk();
							mapperFDS_diskaddr++;
						}
						break;
				}

				mapperFDS_arm_timer();
				mapperFDS_eighth_bit = 0;
				M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
			}
			break;

		case 0x4032:
			ret = cpu_open_bus & 0xf8;
			if (mapperFDS_diskinsert == 0) {
				ret |= 4 /*write protect or eject*/ | 1 /*disk not inserted*/;
			}
			if ((mapperFDS_diskinsert == 0) || (~mapperFDS_control & 1/*motor off*/) || (mapperFDS_control & 2/*transfer reset*/)) {
				ret |= 2 /*disk not ready*/;
			}
			break;

		case 0x4033: // battery status of drive unit
			ret |= 0x80;
			break;
	}

	return ret;
}

static void mapperFDS_prg_write(UINT16 address, UINT8 data)
{
	if (address >= 0x8000 && address <= 0xdfff) {
		Cart.PRGRom[address & 0x7fff] = data;
	}
}

static void mapperFDS_write(UINT16 address, UINT8 data)
{
	if (mapperFDS_ioenable & 2 && address >= 0x4040 && address <= 0x4097)
		return fds_sound_write(address, data);

	if ((~mapperFDS_ioenable & 1) && address >= 0x4024) return; // io disabled.

	switch (address) {
		case 0x4020:
			mapperFDS_irqlatch = (mapperFDS_irqlatch & 0xff00) | data;
			break;
		case 0x4021:
			mapperFDS_irqlatch = (mapperFDS_irqlatch & 0x00ff) | (data << 8);
			break;

		case 0x4022:
			mapperFDS_irqenable = (data & 2) && (mapperFDS_ioenable & 1);
			mapperFDS_irqrepeat = data & 1;
			if (mapperFDS_irqenable) {
				mapperFDS_irqcount = mapperFDS_irqlatch;
			} else {
				M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
				mapperFDS_in_irq = 0;
			}
			break;

		case 0x4023:
			mapperFDS_ioenable = data;
			if (~data & 1) {
				mapperFDS_irqenable = 0;
				M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
				mapperFDS_in_irq = mapperFDS_eighth_bit = 0;
			}
			break;

		case 0x4024:
			if (mapperFDS_diskinsert && ~mapperFDS_control & 0x04) {

				if (mapperFDS_diskaccessed == 0) {
					mapperFDS_diskaccessed = 1;
					break;
				}

				switch (mapperFDS_blockid) {
					case DSK_FILEHDR:
						if (mapperFDS_diskaddr < mapperFDS_blocklen) {
							fds_disk() = data;
							switch (mapperFDS_diskaddr) {
								case 13: mapperFDS_filesize = data; break;
								case 14:
									mapperFDS_filesize |= data << 8;
									fdsfile[0] = 0;
									strncpy(fdsfile, (char*)&Cart.FDSDisk[(mapperFDS_diskside * 65500) + mapperFDS_blockstart + 3], 8);
									bprintf(0, _T("Write file: %S (size: %d)\n"), fdsfile, mapperFDS_filesize);
									break;
							}
							mapperFDS_diskaddr++;
						}
						break;
					default:
						if (mapperFDS_diskaddr < mapperFDS_blocklen) {
							fds_disk() = data;
							mapperFDS_diskaddr++;
						}
						break;
				}

			}
			break;

		case 0x4025:
			M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);

			//bprintf(0, _T("0x4025: nCurrentFrame %d  param %x   ppc %x\n"), nCurrentFrame, data, M6502GetPrevPC(-1));
			if (mapperFDS_diskinsert) {
				if (data & 0x40 && ~mapperFDS_control & 0x40) {
					mapperFDS_diskaccessed = 0;

					mapperFDS_arm_timer();

					// blockstart  - address of block on disk
					// diskaddr    - address relative to blockstart
					mapperFDS_blockstart += mapperFDS_diskaddr;
					mapperFDS_diskaddr = 0;

					mapperFDS_blockid++;
					if (mapperFDS_blockid > DSK_FILEDATA)
						mapperFDS_blockid = DSK_FILEHDR;

					switch (mapperFDS_blockid) {
						case DSK_VOLUME:
							mapperFDS_blocklen = 0x38;
							break;
						case DSK_FILECNT:
							mapperFDS_blocklen = 0x02;
							break;
						case DSK_FILEHDR:
							mapperFDS_blocklen = 0x10;
							break;
						case DSK_FILEDATA:		 // [blockid]<filedata>
							mapperFDS_blocklen = 0x01 + mapperFDS_filesize;
							break;
					}
				}

				if (data & 0x02) { // transfer reset
					mapperFDS_blockid = DSK_INIT;
					mapperFDS_blockstart = 0;
					mapperFDS_blocklen = 0;
					mapperFDS_diskaddr = 0;
					mapperFDS_arm_timer();
				}
				if (data & 0x40 && ~data & 2) { // turn on motor
					mapperFDS_arm_timer();
					BurnLEDSetStatus(0, 1);
					BurnLEDSetColor((mapperFDS_control & 0x04) ? LED_COLOR_GREEN : LED_COLOR_RED);
				} else {
					BurnLEDSetStatus(0, 0);
				}
			}
			mapperFDS_control = data;

			mapper_map(); // set mirror

			break;
	}
}

#undef mapperFDS_ioenable
#undef mapperFDS_control
#undef mapperFDS_eighth_bit
#undef mapperFDS_in_irq
#undef mapperFDS_irqenable
#undef mapperFDS_irqrepeat
#undef mapperFDS_irqcount
#undef mapperFDS_irqlatch
#undef mapperFDS_diskside
#undef mapperFDS_diskinsert
#undef mapperFDS_diskaccessed
#undef mapperFDS_diskaddr
#undef mapperFDS_diskirqcount
#undef mapperFDS_arm_timer
#undef mapperFDS_filesize
#undef mapperFDS_blockid
#undef mapperFDS_blockstart

// ---[ mapper 01 (MMC1)
#define mapper01_serialbyte	(mapper_regs[0x1f - 0])
#define mapper01_bitcount	(mapper_regs[0x1f - 1])
#define mapper01_lastwrite  (mapper_regs[0x1f - 2])
#define mapper01_exbits		(mapper_regs[0x1f - 3])
#define mapper01_prg2x		(mapper_regs[0x1f - 4])
static INT32 *mapper01_last_cyc = (INT32*)&mapper_regs16[0];

static void mapper01_write(UINT16 address, UINT8 data)
{
	if (address & 0x8000) {
		if (mega_cyc_counter - mapper01_last_cyc[0] < 2) {
			// https://wiki.nesdev.com/w/index.php/MMC1
			// Bill & Ted's Excellent Adventure resets the MMC1 by doing INC
			// on a ROM location containing $FF; the MMC1 sees the $FF
			// written back and ignores the $00 written on the next cycle.
			mapper01_last_cyc[0] = mega_cyc_counter;
			return;
		}
        if (data & 0x80) { // bit 7, mapper reset
			mapper01_bitcount = 0;
			mapper01_serialbyte = 0;
			mapper_regs[0] |= 0x0c;
			if (mapper_map) mapper_map();
		} else {
			mapper01_serialbyte |= (data & 1) << mapper01_bitcount;
			mapper01_bitcount++;
			if (mapper01_bitcount == 5) {
				UINT8 reg = (address >> 13) & 0x3;
				mapper_regs[reg] = mapper01_serialbyte;
				//bprintf(0, _T("mmc1_reg[%x]  =  %x\n"), reg, mapper01_serialbyte);
				switch (reg) {
					case 1: mapper01_lastwrite = 0; break;
					case 2: mapper01_lastwrite = 1; break;
				}
                mapper01_bitcount = 0;
                mapper01_serialbyte = 0;
                if (mapper_map) mapper_map();
			}
		}
		mapper01_last_cyc[0] = mega_cyc_counter;
    }
}

static void mapper01_exp_write(UINT16 address, UINT8 data) // 6000 - 7fff
{
	if (~mapper_regs[3] & 0x10) {
		Cart.WorkRAM[PRGExpMap + (address & 0x1fff)] = data;
	}
	cart_exp_write_abort = 1; // don't fall-through after callback!
}

static UINT8 mapper01_exp_read(UINT16 address)             // 6000 - 7fff
{
	return (~mapper_regs[3] & 0x10) ? Cart.WorkRAM[PRGExpMap + (address & 0x1fff)] : cpu_open_bus;
}

static void mapper01_map()
{
	mapper01_exbits = ((mapper01_lastwrite == 1) && (mapper_regs[0] & 0x10)) ? mapper_regs[2] : mapper_regs[1];

	if (Cart.WorkRAMSize > 0x2000) {
		// MMC1 Bankable WRAM/SRAM
		UINT8 page = 0;
		switch (Cart.WorkRAMSize) {
			case 0x8000: // 32k (Final Fantasy 1 & 2)
				page = (mapper_regs[1] >> 2) & 3;
				break;
			default:
				page = (mapper_regs[1] >> 3) & 1;
				break;
		}
		mapper_map_exp_prg(page);
	}

	INT32 bigcart = 0;

	if (Cart.PRGRomSize >= 0x80000) {
		bigcart = 1;
		// SUROM (512K/1M rom), use extra mapping bit
		mapper01_prg2x = mapper01_exbits & 0x10;
	}

	if (mapper_regs[0] & 0x8) {
		if (mapper_regs[0] & 0x4) {
            mapper_map_prg(16, 0, (mapper_regs[3] & 0xf) | mapper01_prg2x);
			if (bigcart) {
				mapper_map_prg(16, 1, 0xf | mapper01_prg2x);
			} else {
				mapper_map_prg(16, 1, -1);
			}
        } else {
            mapper_map_prg(16, 0, 0 | mapper01_prg2x);
            mapper_map_prg(16, 1, (mapper_regs[3] & 0xf) | mapper01_prg2x);
        }
	} else {
		mapper_map_prg(32, 0, ((mapper_regs[3] & 0xf) | mapper01_prg2x) >> 1);
	}

	if (mapper_regs[0] & 0x10) {
        mapper_map_chr( 4, 0, mapper_regs[1]);
        mapper_map_chr( 4, 1, mapper_regs[2]);
	} else {
		mapper_map_chr( 8, 0, mapper_regs[1] >> 1);
	}

	switch (mapper_regs[0] & 3) {
        case 0: set_mirroring(SINGLE_LOW); break;
        case 1: set_mirroring(SINGLE_HIGH); break;
        case 2: set_mirroring(VERTICAL); break;
        case 3: set_mirroring(HORIZONTAL); break;
	}
}
#undef mapper01_serialbyte
#undef mapper01_bitcount

// ---[ mapper 02 (UxROM)
static void mapper02_write(UINT16 address, UINT8 data)
{
	if (address & 0x8000) {
		mapper_regs[0] = data;
		mapper_map();
	}
}

static void mapper02_map()
{
    mapper_map_prg(16, 0, mapper_regs[0] & 0xff);
    mapper_map_prg(16, 1, -1);
    mapper_map_chr( 8, 0, 0);
}

// ---[ mapper 41 Caltron 6-in-1
#define mapper41_prg	(mapper_regs[0])
#define mapper41_chr	(mapper_regs[1])
#define mapper41_mirror	(mapper_regs[2])

static void mapper41_write(UINT16 address, UINT8 data)
{
	if (address >= 0x6000 && address <= 0x67ff) {
		mapper41_prg = address & 0x07;
		mapper41_chr = (mapper41_chr & 0x03) | ((address & 0x18) >> 1);
		mapper41_mirror = (address & 0x20) >> 5;
	}
	if (address >= 0x8000 && address <= 0xffff) {
		if (mapper41_prg & 4) {
			mapper41_chr = (mapper41_chr & 0x0c) | (data & 0x03);
		}
	}

	mapper_map();
}

static void mapper41_map()
{
	mapper_map_prg(32, 0, mapper41_prg);
	mapper_map_chr( 8, 0, mapper41_chr);

	set_mirroring((mapper41_mirror & 0x01) ? HORIZONTAL : VERTICAL);
}
#undef mapper41_prg
#undef mapper41_chr
#undef mapper41_mirror

// ---[ mapper 53 SuperVision 16-in-1
#define mapper53_reg(x)	(mapper_regs[0 + (x)])

static void mapper53_write(UINT16 address, UINT8 data)
{
	mapper53_reg((address & 0x8000) >> 15) = data;

	mapper_map();
}

static UINT8 mapper53_exp_read(UINT16 address)
{
	return Cart.PRGRom[PRGExpMap + (address & 0x1fff)];
}

static void mapper53_map()
{
	UINT8 bank = (mapper53_reg(0) & 0xf) << 3;
	mapper_map_exp_prg((0xf | (bank << 1)) + 4);
	if (mapper53_reg(0) & 0x10) {
		mapper_map_prg(16, 0, ((bank | (mapper53_reg(1) & 7)) + 2));
		mapper_map_prg(16, 1, ((bank | 7) + 2));
	} else {
		mapper_map_prg(32, 0, 0);
	}

	mapper_map_chr( 8, 0, 0);

	set_mirroring((mapper53_reg(0) & 0x20) ? HORIZONTAL : VERTICAL);
}
#undef mapper53_reg

// ---[ mapper 104 Golden Five, Pegasus 5-in-1
#define mapper104_prg(x)	(mapper_regs[0 + (x)])

static void mapper104_write(UINT16 address, UINT8 data)
{
	if (address >= 0x8000 && address <= 0xbfff) {
		if (data & 0x08) {
			mapper104_prg(0) = (mapper104_prg(0) & 0x0f) | (data & 0x07) << 4;
			mapper104_prg(1) = (data & 0x07) << 4;
		}
	}
	if (address >= 0xc000 && address <= 0xffff) {
		mapper104_prg(0) = (mapper104_prg(0) & 0x70) | (data & 0x0f);
	}

	mapper_map();
}

static void mapper104_map()
{
	mapper_map_prg(16, 0, mapper104_prg(0));
	mapper_map_prg(16, 1, mapper104_prg(1) | 0x0f);
	mapper_map_chr( 8, 0, 0);
}
#undef mapper104_prg

// ---[ mapper 190 Magic Kid Googoo
#define mapper190_prg		(mapper_regs[0])
#define mapper190_chr(x)	(mapper_regs[1 + (x)])
static void mapper190_write(UINT16 address, UINT8 data)
{
	switch (address & ~0x1fff) {
		case 0x8000:
			mapper190_prg = data & 0x07;
			break;
		case 0xa000:
			mapper190_chr(address & 0x03) = data & 0x3f;
			break;
		case 0xc000:
			mapper190_prg = (data & 0x07) | 0x08;
			break;
	}

	mapper_map();
}

static void mapper190_map()
{
    mapper_map_prg(16, 0, mapper190_prg);
    mapper_map_prg(16, 1, 0); // second 16k bank mapped to first prg bank

	mapper_map_chr( 2, 0, mapper190_chr(0));
	mapper_map_chr( 2, 1, mapper190_chr(1));
	mapper_map_chr( 2, 2, mapper190_chr(2));
	mapper_map_chr( 2, 3, mapper190_chr(3));

	set_mirroring(VERTICAL);
}
#undef mapper190_prg
#undef mapper190_chr

// ---[ mapper 193 NTDEC TC-112 (War in the Gulf, Fighting Hero, ...)
#define mapper193_prg		(mapper_regs[0])
#define mapper193_chr(x)	(mapper_regs[1 + (x)])
#define mapper193_mirror	(mapper_regs[4])

static void mapper193_write(UINT16 address, UINT8 data)
{
	switch (address & 0xe007) {
		case 0x6000:
		case 0x6001:
		case 0x6002:
			mapper193_chr(address & 3) = data;
			break;
		case 0x6003:
			mapper193_prg = data;
			break;
		case 0x6004:
			mapper193_mirror = data;
			break;
	}

	mapper_map();
}

static void mapper193_map()
{
	mapper_map_prg( 8, 0, mapper193_prg);
	mapper_map_prg( 8, 1, -3);
	mapper_map_prg( 8, 2, -2);
	mapper_map_prg( 8, 3, -1);

	mapper_map_chr( 4, 0, mapper193_chr(0) >> 2);

	mapper_map_chr( 2, 2, mapper193_chr(1) >> 1);
	mapper_map_chr( 2, 3, mapper193_chr(2) >> 1);

	set_mirroring((mapper193_mirror & 0x01) ? HORIZONTAL : VERTICAL);
}
#undef mapper193_prg
#undef mapper193_chr
#undef mapper193_mirror

// ---[ mapper 15 Contra 168-in-1 Multicart
#define mapper15_prg		(mapper_regs[0])
#define mapper15_prgbit		(mapper_regs[1])
#define mapper15_prgmode	(mapper_regs[2])
#define mapper15_mirror		(mapper_regs[3])

static void mapper15_write(UINT16 address, UINT8 data)
{
	mapper15_mirror = data & 0x40;
	mapper15_prg = (data & 0x7f) << 1;
	mapper15_prgbit = (data & 0x80) >> 7;
	mapper15_prgmode = address & 0xff; // must ignore weird writes.

	mapper_map();
}

static void mapper15_map()
{
	switch (mapper15_prgmode) {
		case 0x00:
			mapper_map_prg( 8, 0, (mapper15_prg + 0) ^ mapper15_prgbit);
			mapper_map_prg( 8, 1, (mapper15_prg + 1) ^ mapper15_prgbit);
			mapper_map_prg( 8, 2, (mapper15_prg + 2) ^ mapper15_prgbit);
			mapper_map_prg( 8, 3, (mapper15_prg + 3) ^ mapper15_prgbit);
			break;
		case 0x01:
			mapper_map_prg( 8, 0, (mapper15_prg + 0) | mapper15_prgbit);
			mapper_map_prg( 8, 1, (mapper15_prg + 1) | mapper15_prgbit);
			mapper_map_prg( 8, 2, (mapper15_prg + 0) | 0x0e | mapper15_prgbit);
			mapper_map_prg( 8, 3, (mapper15_prg + 1) | 0x0e | mapper15_prgbit);
			break;
		case 0x02:
			mapper_map_prg( 8, 0, (mapper15_prg + 0) | mapper15_prgbit);
			mapper_map_prg( 8, 1, (mapper15_prg + 0) | mapper15_prgbit);
			mapper_map_prg( 8, 2, (mapper15_prg + 0) | mapper15_prgbit);
			mapper_map_prg( 8, 3, (mapper15_prg + 0) | mapper15_prgbit);
			break;
		case 0x03:
			mapper_map_prg( 8, 0, (mapper15_prg + 0) | mapper15_prgbit);
			mapper_map_prg( 8, 1, (mapper15_prg + 1) | mapper15_prgbit);
			mapper_map_prg( 8, 2, (mapper15_prg + 0) | mapper15_prgbit);
			mapper_map_prg( 8, 3, (mapper15_prg + 1) | mapper15_prgbit);
			break;
	}

	mapper_map_chr_ramrom( 8, 0, 0, (mapper15_prgmode == 3) ? MEM_RAM_RO : MEM_RAM);

	set_mirroring((mapper15_mirror & 0x40) ? HORIZONTAL : VERTICAL);
}

#undef mapper15_prg
#undef mapper15_prgbit
#undef mapper15_prgmode
#undef mapper15_mirror

// ---[ mapper 389 Caltron 9-in-1
#define mapper389_reg8  (mapper_regs[0])
#define mapper389_reg9  (mapper_regs[1])
#define mapper389_rega  (mapper_regs[2])

static void mapper389_write(UINT16 address, UINT8 data)
{
	switch (address & 0xf000) {
		case 0x8000: mapper389_reg8 = address & 0xff; break;
		case 0x9000: mapper389_reg9 = address & 0xff; break;
		default: mapper389_rega = address & 0xff; break;
	}

	mapper_map();
}

static void mapper389_map()
{
	if (mapper389_reg9 & 0x02) { // UNROM-064 mode
		mapper_map_prg(16, 0, (mapper389_reg8 >> 2) | ((mapper389_rega >> 2) & 0x03));
		mapper_map_prg(16, 1, (mapper389_reg8 >> 2) | 0x03);
	} else { // NROM-256 mode
		mapper_map_prg(32, 0, mapper389_reg8 >> 3);
	}
	mapper_map_chr( 8, 0, ((mapper389_reg9 & 0x38) >> 1) | (mapper389_rega & 0x03));

	set_mirroring((mapper389_reg8 & 0x01) ? HORIZONTAL : VERTICAL);
}

#undef mapper389_reg8
#undef mapper389_reg9
#undef mapper389_rega

// ---[ mapper 216 (??) Magic Jewelry 2
#define mapper216_prg   (mapper_regs[0])
#define mapper216_chr   (mapper_regs[1])
static void mapper216_write(UINT16 address, UINT8 data)
{
	if (address >= 0x8000) {
		mapper216_prg = address & 1;
		mapper216_chr = (address & 0x000e) >> 1;
		mapper_map();
	}
}

static UINT8 mapper216_read(UINT16 address)
{
	return 0; // must be 0 @ 0x5000
}

static void mapper216_map()
{
    mapper_map_prg(32, 0, mapper216_prg);
	mapper_map_chr( 8, 0, mapper216_chr);
}
#undef mapper216_prg
#undef mapper216_chr

// ---[ mapper 132 (TXC Micro Genius) Qi Wang
#define mapper132_reg(x)   (mapper_regs[0 + (x)])
#define mapper132_reghi    (mapper_regs[8])
static void mapper132_write(UINT16 address, UINT8 data)
{
	if (address >= 0x4100 && address <= 0x4103) {
		mapper132_reg(address & 3) = data;
		//mapper_map(); // only 8000+!
	}

	if (address >= 0x8000) {
		mapper132_reghi = data;
		mapper_map();
	}
}

static UINT8 mapper132_read(UINT16 address)
{
	if (address == 0x4100) {
		return (mapper132_reg(1) ^ mapper132_reg(2)) | 0x40;
	}
	return cpu_open_bus;
}

static void mapper132_map()
{
    mapper_map_prg(32, 0, (mapper132_reg(2) >> 2) & 1);
	mapper_map_chr( 8, 0, mapper132_reg(2) & 3);
}
#undef mapper132_reg
#undef mapper132_reghi


// flashrom simulator (flash eeprom)
#define flashrom_cmd            (mapper_regs[0x1f - 0x9]) // must not conflict with mmc3 for 406 (Haradius Zero)
#define flashrom_busy           (mapper_regs16[0x00])
#define flashrom_chiptype       (mapper_regs[0x1f - 0xa])
enum { AMIC = 0, MXIC = 1, MC_SST = 2 };

static UINT8 flashrom_read(UINT16 address)
{
	if (flashrom_cmd == 0x90) { // flash chip identification
		//bprintf(0, _T("flashrom chip ID\n"));
		if (flashrom_chiptype == AMIC) {
			switch (address & 0x03) {
				case 0x00: return 0x37; // manufacturer ID
				case 0x01: return 0x86; // device ID
				case 0x03: return 0x7f; // Continuation ID
			}
		} else if (flashrom_chiptype == MXIC) {
			switch (address & 0x03) {
				case 0x00: return 0xc2; // manufacturer ID
				case 0x01: return 0xa4; // device ID
			}
		} else if (flashrom_chiptype == MC_SST) {
			switch (address & 0x03) {
				case 0x00: return 0xbf; // manufacturer ID
				case 0x01: return 0xb7; // device ID
			}
		}
	}

	if (flashrom_busy > 0) { // flash chip program or "erasing sector or chip" mode (it takes time..)
		flashrom_busy--;

		UINT8 status = (flashrom_busy & 0x01) << 6; // toggle bit I
		switch (flashrom_cmd) {
			case 0x82: // embedded erase sector/chip
				status |= (flashrom_busy & 0x01) << 2; // toggle bit II
				status |= 1 << 3; // "erasing" status bit
				if (flashrom_busy < 2) {
					//MXIC MX29F040.pdf, bottom pg. 7
					//"SET-UP AUTOMATIC CHIP/SECTOR ERASE" (last paragraph)
					//...and terminates when the data on Q7 is "1" and
					//the data on Q6 stops toggling for two consecutive read
					//cycles, at which time the device returns to the Read mode
					status = (1 << 7); // Courier doesn't like when the other status bits are set.
				}
				break;
			case 0xa0: // embedded program
				status |= ~mapper_prg_read_int(address) & 0x80;
				break;
		}
		//bprintf(0, _T("erase/pgm status  %x\n"), status);
		if (flashrom_busy == 0) {
			flashrom_cmd = 0; // done! (req: Courier doesn't write 0xf0 (return to read array))
		}
		return status;
	}

	return mapper_prg_read_int(address);
}

static void flashrom_prg_write(UINT16 address, UINT8 data)
{
	//bprintf(0, _T("write byte %x (map/addr: %x  %x)  ->  %x\n"), PRGMap[(address & ~0x8000) / 0x2000] + (address & 0x1fff), PRGMap[(address & ~0x8000) / 0x2000], address & 0x1fff, data);
	Cart.PRGRom[PRGMap[(address & ~0x8000) / 0x2000] + (address & 0x1fff)] = data;
}

static void flashrom_write(UINT16 address, UINT8 data)
{
	if (data == 0xf0) {
		// read array / reset
		flashrom_cmd = 0;
		flashrom_busy = 0;
		return;
	}

	switch (flashrom_cmd) {
		case 0x00:
		case 0x80:
			if ((address & 0xfff) == 0x555 && data == 0xaa)
				flashrom_cmd++;
			break;
		case 0x01:
		case 0x81:
			if (((address & 0xfff) == 0x2aa ||
				 (address & 0xfff) == 0xaaa) && data == 0x55)
				flashrom_cmd++;

			break;
		case 0x02:
			if ((address & 0xfff) == 0x555) {
				flashrom_cmd = data;
			}
			break;
		case 0x82: {
			switch (data) {
				case 0x10:
					bprintf(0, _T("mapper %d: flashrom - full flash erase not impl. (will break game!)\n"), Cart.Mapper);
					flashrom_busy = Cart.PRGRomSize / 0x100; // fake it
					break;
				case 0x30:
					bprintf(0, _T("mapper %d: flashrom - sector erase.  addr %x [%x]\n"), Cart.Mapper, address, (PRGMap[(address & ~0x8000) / 0x2000] & 0x7ff000));

					if (flashrom_chiptype == MC_SST) {
						for (INT32 i = 0; i < 0x1000; i++) {
							Cart.PRGRom[PRGMap[(address & ~0x8000) / 0x2000] + (address & 0x1000) + i] = data;
						}
						flashrom_busy = 0xfff;
					} else {
						for (INT32 i = 0; i < 0x10000; i++) {
							Cart.PRGRom[(PRGMap[(address & ~0x8000) / 0x2000] & 0x7f0000) + i] = 0xff;
						}
						flashrom_busy = 0xffff;
					}
					break;
			}
			break;
		}
		case 0xa0:
			//bprintf(0, _T("write byte %x  ->  %x\n"), address, data);
			flashrom_prg_write(address, data);
			flashrom_busy = 8;
			flashrom_cmd = 0;
			break;
	}
}



// ---[ mapper 30 (UNROM-512)
#define mapper30_mirroring_en   (mapper_regs[1])
static void mapper30_write(UINT16 address, UINT8 data)
{
	if (address >= 0xc000) {
		mapper_regs[0] = data;
		mapper_map();
	} else {
		flashrom_write(address, data);
	}
}

static void mapper30_map()
{
    mapper_map_prg(16, 0, mapper_regs[0] & 0x1f);
    mapper_map_prg(16, 1, -1);
	mapper_map_chr( 8, 0, (mapper_regs[0] >> 5) & 0x03);
	if (mapper30_mirroring_en) {
		set_mirroring((mapper_regs[0] & 0x80) ? SINGLE_HIGH : SINGLE_LOW);
	}
}

// ---[ mapper 03 (CNROM)
#define mapper03_need_update   (mapper_regs[1])
static void mapper03_write(UINT16 address, UINT8 data)
{
	if (address & 0x8000) {
		if (NESMode & BUS_CONFLICTS) {
			data &= mapper_prg_read(address);
		}
		mapper_regs[0] = data;
		mapper03_need_update = 1;

		if (Cart.Crc != 0xab29ab28) // dropzone gets delayed a bit.
			mapper_map();
	}
}

static void mapper03_map()
{
    mapper_map_chr( 8, 0, mapper_regs[0]);
}

// dropzone likes to change the chr bank too soon sometimes, this causes a line
// through the player when he is near the bottom of the screen.
// Solution: delay chr bank switches until after sprites load
static void mapper03_cycle()
{
	if (pixel > 321 && mapper03_need_update) {
		mapper03_need_update = 0;
		mapper_map();
	}

}
#undef mapper03_need_update

// ---[ mapper 04 (mmc3) & mmc3-based: 12, 76, 95, 108, 115, 118, 119, 189, 262
#define mapper4_banksel         (mapper_regs[0x1f - 0])
#define mapper4_mirror			(mapper_regs[0x1f - 1])
#define mapper4_irqlatch 		(mapper_regs[0x1f - 2])
#define mapper4_irqcount		(mapper_regs[0x1f - 3])
#define mapper4_irqenable		(mapper_regs[0x1f - 4])
#define mapper4_irqreload		(mapper_regs[0x1f - 5])
#define mapper4_writeprotect    (mapper_regs[0x1f - 6])
#define mapper12_lowchr			(mapper_regs16[0x1f - 0])
#define mapper12_highchr		(mapper_regs16[0x1f - 1])
#define mapper04_vs_prottype    (mapper_regs16[0x1f - 2])
#define mapper04_vs_protidx	    (mapper_regs16[0x1f - 3])
#define mapper115_prg           (mapper_regs[0x1f - 7])
#define mapper115_chr           (mapper_regs[0x1f - 8])
#define mapper115_prot          (mapper_regs[0x1f - 9])
#define mapper258_reg           (mapper_regs[0x1f - 0xa])
#define mapper262_reg           (mapper_regs[0x1f - 0xa])
#define mapper189_reg           (mapper_regs[0x1f - 0xa]) // same as 262
#define mapper268_reg(x)        (mapper_regs[(0x1f - 0xa) + (x)])
// mapper 165 mmc3 w/mmc4-like 4k chr banking latch
#define mapper165_chrlatch(x)   (mapper_regs[(0x1f - 0x0a) + (x)])
#define mapper165_update        (mapper_regs[0x1f - 0xb])

static UINT8 mapper04_vs_rbi_tko_prot(UINT16 address)
{
	static const UINT8 protdata[2][0x20] = {
		{
			0xff, 0xff, 0xff, 0xff, 0xb4, 0xff, 0xff, 0xff,
			0xff, 0x6f, 0xff, 0xff, 0xff, 0xff, 0x94, 0xff,
			0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
			0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
		},
		{
			0xff, 0xbf, 0xb7, 0x97, 0x97, 0x17, 0x57, 0x4f,
			0x6f, 0x6b, 0xeb, 0xa9, 0xb1, 0x90, 0x94, 0x14,
			0x56, 0x4e, 0x6f, 0x6b, 0xeb, 0xa9, 0xb1, 0x90,
			0xd4, 0x5c, 0x3e, 0x26, 0x87, 0x83, 0x13, 0x00
		}

	};
	switch (address) {
		case 0x54ff:
			return 0x05;
		case 0x5678:
			return mapper04_vs_protidx ^ 1;
		case 0x578f:
			return 0x81 | ((mapper04_vs_protidx) ? 0x50 : 0x08);
		case 0x5567:
			mapper04_vs_protidx ^= 1;
			return 0x3e ^ ((mapper04_vs_protidx) ? 0x09 : 0x00);
		case 0x5e00:
			mapper04_vs_protidx = 0;
			break;
		case 0x5e01:
			return protdata[mapper04_vs_prottype][mapper04_vs_protidx++ & 0x1f];
	}
	return cpu_open_bus;
}

static void mapper04_write(UINT16 address, UINT8 data)
{
	if (address & 0x8000) {
        switch (address & 0xE001) {
            case 0x8000: mapper4_banksel = data; break;
            case 0x8001: mapper_regs[(mapper4_banksel & 0x7)] = data; break;
			case 0xA000: mapper4_mirror = ~data & 1; break;
			case 0xA001: mapper4_writeprotect = ~data & 1; break;
            case 0xC000: mapper4_irqlatch = data; break;
            case 0xC001: mapper4_irqreload = 1; break;
            case 0xE000: mapper4_irqenable = 0; M6502SetIRQLine(0, CPU_IRQSTATUS_NONE); break;
            case 0xE001: mapper4_irqenable = 1; break;
        }
		mapper_map();
    }
}

static void mapper04_map()
{
    mapper_map_prg(8, 1, mapper_regs[7]);

    if (~mapper4_banksel & 0x40) {
        mapper_map_prg(8, 0, mapper_regs[6]);
        mapper_map_prg(8, 2, -2);
    } else {
        mapper_map_prg(8, 0, -2);
        mapper_map_prg(8, 2, mapper_regs[6]);
    }

    if (~mapper4_banksel & 0x80) {
		mapper_map_chr(2, 0, (mapper_regs[0] + mapper12_lowchr) >> 1);
        mapper_map_chr(2, 1, (mapper_regs[1] + mapper12_lowchr) >> 1);

		mapper_map_chr(1, 4, mapper_regs[2] + mapper12_highchr);
		mapper_map_chr(1, 5, mapper_regs[3] + mapper12_highchr);
		mapper_map_chr(1, 6, mapper_regs[4] + mapper12_highchr);
		mapper_map_chr(1, 7, mapper_regs[5] + mapper12_highchr);
	} else {
		mapper_map_chr(1, 0, mapper_regs[2] + mapper12_lowchr);
		mapper_map_chr(1, 1, mapper_regs[3] + mapper12_lowchr);
		mapper_map_chr(1, 2, mapper_regs[4] + mapper12_lowchr);
		mapper_map_chr(1, 3, mapper_regs[5] + mapper12_lowchr);

		mapper_map_chr(2, 2, (mapper_regs[0] + mapper12_highchr) >> 1);
		mapper_map_chr(2, 3, (mapper_regs[1] + mapper12_highchr) >> 1);
	}

	if (Cart.Mirroring != 4)
		set_mirroring(mapper4_mirror ? VERTICAL : HORIZONTAL);
}

static void mapper258_map()
{
	if (mapper258_reg & 0x80) {
		// mmc3 prg-override (similar to mapper 115)
		if (mapper258_reg & 0x20) {
			mapper_map_prg(32, 0, (mapper258_reg & 0x7) >> 1);
		} else {
			mapper_map_prg(16, 0, mapper258_reg & 0x7);
			mapper_map_prg(16, 1, mapper258_reg & 0x7);
		}
	} else {
		mapper_map_prg(8, 1, mapper_regs[7] & 0xf);

		if (~mapper4_banksel & 0x40) {
			mapper_map_prg(8, 0, mapper_regs[6] & 0xf);
			mapper_map_prg(8, 2, -2);
		} else {
			mapper_map_prg(8, 0, -2);
			mapper_map_prg(8, 2, mapper_regs[6] & 0xf);
		}
		mapper_map_prg(8, 3, -1);
	}

    if (~mapper4_banksel & 0x80) {
		mapper_map_chr(2, 0, (mapper_regs[0] + mapper12_lowchr) >> 1);
        mapper_map_chr(2, 1, (mapper_regs[1] + mapper12_lowchr) >> 1);

		mapper_map_chr(1, 4, mapper_regs[2] + mapper12_highchr);
		mapper_map_chr(1, 5, mapper_regs[3] + mapper12_highchr);
		mapper_map_chr(1, 6, mapper_regs[4] + mapper12_highchr);
		mapper_map_chr(1, 7, mapper_regs[5] + mapper12_highchr);
	} else {
		mapper_map_chr(1, 0, mapper_regs[2] + mapper12_lowchr);
		mapper_map_chr(1, 1, mapper_regs[3] + mapper12_lowchr);
		mapper_map_chr(1, 2, mapper_regs[4] + mapper12_lowchr);
		mapper_map_chr(1, 3, mapper_regs[5] + mapper12_lowchr);

		mapper_map_chr(2, 2, (mapper_regs[0] + mapper12_highchr) >> 1);
		mapper_map_chr(2, 3, (mapper_regs[1] + mapper12_highchr) >> 1);
	}

	if (Cart.Mirroring != 4)
		set_mirroring(mapper4_mirror ? VERTICAL : HORIZONTAL);
}

static UINT8 mapper258_read(UINT16 address)
{
	const UINT8 lut[8] = { 0, 0, 0, 1, 2, 4, 0xf, 0 };

	return cpu_open_bus | lut[address & 7];
}

static void mapper258_write(UINT16 address, UINT8 data)
{
	if ((address & 0x7) == 0x0) {
		mapper258_reg = data;

		mapper_map();
	}
}

static void mapper76_map()
{
	mapper_map_prg(8, 0, mapper_regs[6]);
    mapper_map_prg(8, 1, mapper_regs[7]);
	mapper_map_prg(8, 2, -2);

	mapper_map_chr(2, 0, mapper_regs[2]);
	mapper_map_chr(2, 1, mapper_regs[3]);
	mapper_map_chr(2, 2, mapper_regs[4]);
	mapper_map_chr(2, 3, mapper_regs[5]);

	if (Cart.Mirroring != 4)
		set_mirroring(mapper4_mirror ? VERTICAL : HORIZONTAL);
}

static void mapper95_map()
{
    mapper_map_prg(8, 1, mapper_regs[7]);

	mapper_map_prg(8, 0, mapper_regs[6]);
	mapper_map_prg(8, 2, -2);

	mapper_map_chr(2, 0, mapper_regs[0] >> 1);
	mapper_map_chr(2, 1, mapper_regs[1] >> 1);

	nametable_mapall((mapper_regs[0] >> 5) & 1, (mapper_regs[0] >> 5) & 1, (mapper_regs[1] >> 5) & 1, (mapper_regs[1] >> 5) & 1);

	mapper_map_chr(1, 4, mapper_regs[2]);
	mapper_map_chr(1, 5, mapper_regs[3]);
	mapper_map_chr(1, 6, mapper_regs[4]);
	mapper_map_chr(1, 7, mapper_regs[5]);
}

static void mapper268_prg(INT32 slot, INT32 bank)
{
	UINT32 prgmask = ((~mapper268_reg(3) & 0x10) >> 4) * 0x0f; // prg a13, a14, a15, a16 (GNROM)
		   prgmask |= (~mapper268_reg(0) & 0x40) >> 2; // prg a17~
		   prgmask |= (~mapper268_reg(1) & 0x80) >> 2; // prg a18~
		   prgmask |=   mapper268_reg(1) & 0x40;       // prg a19
		   prgmask |= ( mapper268_reg(1) & 0x20) << 2; // prg a20

	UINT32 prgbase  = (mapper268_reg(3) & 0x0e);       // prg a16, a15, a14 (GNROM)
		   prgbase |= (mapper268_reg(0) & 0x07) << 4;  // prg a19, a18, a17
		   prgbase |= (mapper268_reg(1) & 0x10) << 3;  // prg a20
		   prgbase |= (mapper268_reg(1) & 0x0c) << 6;  // prg a22, a21
		   prgbase |= (mapper268_reg(0) & 0x30) << 6;  // prg a24, a23
		   prgbase &= ~prgmask;

	UINT32 gnprgmask = (mapper268_reg(3) & 0x10) ? ((mapper268_reg(1) & 0x02) | 0x01) : 0x00;

	mapper_map_prg(8, slot, prgbase | (bank & prgmask) | (slot & gnprgmask));
}

// mapper 268: coolboy / mindkids
static void mapper268_map()
{
	if (mapper268_reg(3) & (0x40)) {
		bprintf(0, _T(" **  Mapper 268: 'weird' modes not supported yet.\n"));
	}

	mapper268_prg(1, mapper_regs[7]);

    if (~mapper4_banksel & 0x40) {
		mapper268_prg(0, mapper_regs[6]);
		mapper268_prg(2, -2);
    } else {
		mapper268_prg(0, -2);
		mapper268_prg(2, mapper_regs[6]);
    }
	mapper268_prg(3, -1);

	// chr - only mmc3 for now! -dink feb3. 2022
	INT32 chrmask = (mapper268_reg(0) & 0x80) ? 0x7f : 0xff;
	INT32 chrbase = ((mapper268_reg(0) & 0x08) << 4) & ~chrmask;

	if (~mapper4_banksel & 0x80) {
		mapper_map_chr(2, 0, ((mapper_regs[0] & chrmask) + chrbase) >> 1);
        mapper_map_chr(2, 1, ((mapper_regs[1] & chrmask) + chrbase) >> 1);

		mapper_map_chr(1, 4, (mapper_regs[2] & chrmask) + chrbase);
		mapper_map_chr(1, 5, (mapper_regs[3] & chrmask) + chrbase);
		mapper_map_chr(1, 6, (mapper_regs[4] & chrmask) + chrbase);
		mapper_map_chr(1, 7, (mapper_regs[5] & chrmask) + chrbase);
	} else {
		mapper_map_chr(1, 0, (mapper_regs[2] & chrmask) + chrbase);
		mapper_map_chr(1, 1, (mapper_regs[3] & chrmask) + chrbase);
		mapper_map_chr(1, 2, (mapper_regs[4] & chrmask) + chrbase);
		mapper_map_chr(1, 3, (mapper_regs[5] & chrmask) + chrbase);

		mapper_map_chr(2, 2, ((mapper_regs[0] & chrmask) + chrbase) >> 1);
		mapper_map_chr(2, 3, ((mapper_regs[1] & chrmask) + chrbase) >> 1);
	}

	if (Cart.Mirroring != 4)
		set_mirroring(mapper4_mirror ? VERTICAL : HORIZONTAL);
}

static void mapper268_write(UINT16 address, UINT8 data)
{
	if (address < 0x8000) {
		cart_exp_write_abort = (mapper4_writeprotect & 0xc0) == 0x80;

		if ((Cart.SubMapper == 1 && address >= 0x5000 && address <= 0x5fff) ||
		   (Cart.SubMapper == 0 && address >= 0x6000 && address <= 0x6fff))
		{
			if ((mapper268_reg(3) & 0x90) != 0x80) {
				mapper268_reg(address & 3) = data;

				mapper_map();
			}
		}
	} else {
		mapper04_write(address, data);
	}
}

static void mapper12_write(UINT16 address, UINT8 data)
{
	if (address & 0x4000) {
		mapper12_lowchr  = (data & 0x01) << 8;
		mapper12_highchr = (data & 0x10) << 4;

		mapper_map();
	}
}

static UINT8 mapper12_read(UINT16 address)
{
	UINT8 ret = cpu_open_bus;

	if (address & 0x4000) {
		ret = mapper12_lowchr >> 8;
		ret |= mapper12_highchr >> 4;
	}
	return ret;
}

static void mapper95_write(UINT16 address, UINT8 data)
{
	if ((address & 0x8001) == 0x8000)
		data &= 0x3f;

	mapper04_write(address & 0x8001, data);

	mapper_map();
}

static void mapper115_map()
{
	if (mapper115_prg & 0x80) {
		// mmc3 prg-override
		if (mapper115_prg & 0x20) {
			mapper_map_prg(32, 0, (mapper115_prg & 0xf) >> 1);
		} else {
			mapper_map_prg(16, 0, mapper115_prg & 0xf);
			mapper_map_prg(16, 1, mapper115_prg & 0xf);
		}
	} else {
		mapper_map_prg(8, 1, mapper_regs[7]);

		if (~mapper4_banksel & 0x40) {
			mapper_map_prg(8, 0, mapper_regs[6]);
			mapper_map_prg(8, 2, -2);
		} else {
			mapper_map_prg(8, 0, -2);
			mapper_map_prg(8, 2, mapper_regs[6]);
		}
		mapper_map_prg( 8, 3, -1);
	}

    if (~mapper4_banksel & 0x80) {
		mapper_map_chr(2, 0, (mapper_regs[0] + mapper12_lowchr) >> 1);
        mapper_map_chr(2, 1, (mapper_regs[1] + mapper12_lowchr) >> 1);

		mapper_map_chr(1, 4, mapper_regs[2] + mapper12_highchr);
		mapper_map_chr(1, 5, mapper_regs[3] + mapper12_highchr);
		mapper_map_chr(1, 6, mapper_regs[4] + mapper12_highchr);
		mapper_map_chr(1, 7, mapper_regs[5] + mapper12_highchr);
	} else {
		mapper_map_chr(1, 0, mapper_regs[2] + mapper12_lowchr);
		mapper_map_chr(1, 1, mapper_regs[3] + mapper12_lowchr);
		mapper_map_chr(1, 2, mapper_regs[4] + mapper12_lowchr);
		mapper_map_chr(1, 3, mapper_regs[5] + mapper12_lowchr);

		mapper_map_chr(2, 2, (mapper_regs[0] + mapper12_highchr) >> 1);
		mapper_map_chr(2, 3, (mapper_regs[1] + mapper12_highchr) >> 1);
	}

	if (Cart.Mirroring != 4)
		set_mirroring(mapper4_mirror ? VERTICAL : HORIZONTAL);
}

static UINT8 mapper115_read(UINT16 address)
{
	UINT8 ret = cpu_open_bus;

	switch (address) {
		case 0x5080:
			ret = mapper115_prot;
			break;
		case 0x6000:
			ret = mapper115_prg;
			break;
		case 0x6001:
			ret = mapper115_chr;
			break;
	}
	return ret;
}

static void mapper115_write(UINT16 address, UINT8 data)
{
	switch (address) {
		case 0x5080:
			mapper115_prot = data;
			break;
		case 0x6000:
			mapper115_prg = data;
			break;
		case 0x6001:
			mapper115_chr = data;
			mapper12_highchr = (data & 1) << 8;
			mapper12_lowchr = (data & 1) << 8;
			break;
	}

	mapper_map();
}

static void mapper118_map()
{
    mapper_map_prg(8, 1, mapper_regs[7]);

    if (~mapper4_banksel & 0x40) {
        mapper_map_prg(8, 0, mapper_regs[6]);
        mapper_map_prg(8, 2, -2);
    } else {
        mapper_map_prg(8, 0, -2);
        mapper_map_prg(8, 2, mapper_regs[6]);
    }

    if (~mapper4_banksel & 0x80) {
		mapper_map_chr(2, 0, mapper_regs[0] >> 1);
        mapper_map_chr(2, 1, mapper_regs[1] >> 1);
		nametable_map(0, (mapper_regs[0] >> 7) & 1);
		nametable_map(1, (mapper_regs[0] >> 7) & 1);
		nametable_map(2, (mapper_regs[1] >> 7) & 1);
		nametable_map(3, (mapper_regs[1] >> 7) & 1);

		mapper_map_chr(1, 4, mapper_regs[2]);
		mapper_map_chr(1, 5, mapper_regs[3]);
		mapper_map_chr(1, 6, mapper_regs[4]);
		mapper_map_chr(1, 7, mapper_regs[5]);
	} else {
		mapper_map_chr(1, 0, mapper_regs[2]);
		mapper_map_chr(1, 1, mapper_regs[3]);
		mapper_map_chr(1, 2, mapper_regs[4]);
		mapper_map_chr(1, 3, mapper_regs[5]);
		nametable_map(0, (mapper_regs[2] >> 7) & 1);
		nametable_map(1, (mapper_regs[3] >> 7) & 1);
		nametable_map(2, (mapper_regs[4] >> 7) & 1);
		nametable_map(3, (mapper_regs[5] >> 7) & 1);

		mapper_map_chr(2, 2, mapper_regs[0] >> 1);
		mapper_map_chr(2, 3, mapper_regs[1] >> 1);
	}
}

static void mapper189_write(UINT16 address, UINT8 data)
{
	mapper189_reg = data | (data >> 4);
	mapper_map();
}

static void mapper189_map()
{
	mapper_map_prg(32, 0, mapper189_reg & 0x07);

    if (~mapper4_banksel & 0x80) {
		mapper_map_chr(2, 0, mapper_regs[0] >> 1);
        mapper_map_chr(2, 1, mapper_regs[1] >> 1);

		mapper_map_chr(1, 4, mapper_regs[2]);
		mapper_map_chr(1, 5, mapper_regs[3]);
		mapper_map_chr(1, 6, mapper_regs[4]);
		mapper_map_chr(1, 7, mapper_regs[5]);
	} else {
		mapper_map_chr(1, 0, mapper_regs[2]);
		mapper_map_chr(1, 1, mapper_regs[3]);
		mapper_map_chr(1, 2, mapper_regs[4]);
		mapper_map_chr(1, 3, mapper_regs[5]);

		mapper_map_chr(2, 2, mapper_regs[0] >> 1);
		mapper_map_chr(2, 3, mapper_regs[1] >> 1);
	}

	if (Cart.Mirroring != 4)
		set_mirroring(mapper4_mirror ? VERTICAL : HORIZONTAL);
}

static void mapper119_map()
{
    mapper_map_prg(8, 1, mapper_regs[7]);

    if (~mapper4_banksel & 0x40) {
        mapper_map_prg(8, 0, mapper_regs[6]);
        mapper_map_prg(8, 2, -2);
    } else {
        mapper_map_prg(8, 0, -2);
        mapper_map_prg(8, 2, mapper_regs[6]);
    }

    if (~mapper4_banksel & 0x80) {
		mapper_map_chr_ramrom(2, 0, (mapper_regs[0] >> 1) & 0x1f, ((mapper_regs[0]) & 0x40) ? MEM_RAM : MEM_ROM);
		mapper_map_chr_ramrom(2, 1, (mapper_regs[1] >> 1) & 0x1f, ((mapper_regs[1]) & 0x40) ? MEM_RAM : MEM_ROM);

		mapper_map_chr_ramrom(1, 4, mapper_regs[2] & 0x3f, (mapper_regs[2] & 0x40) ? MEM_RAM : MEM_ROM);
		mapper_map_chr_ramrom(1, 5, mapper_regs[3] & 0x3f, (mapper_regs[3] & 0x40) ? MEM_RAM : MEM_ROM);
		mapper_map_chr_ramrom(1, 6, mapper_regs[4] & 0x3f, (mapper_regs[4] & 0x40) ? MEM_RAM : MEM_ROM);
		mapper_map_chr_ramrom(1, 7, mapper_regs[5] & 0x3f, (mapper_regs[5] & 0x40) ? MEM_RAM : MEM_ROM);
	} else {
		mapper_map_chr_ramrom(1, 0, mapper_regs[2] & 0x3f, (mapper_regs[2] & 0x40) ? MEM_RAM : MEM_ROM);
		mapper_map_chr_ramrom(1, 1, mapper_regs[3] & 0x3f, (mapper_regs[3] & 0x40) ? MEM_RAM : MEM_ROM);
		mapper_map_chr_ramrom(1, 2, mapper_regs[4] & 0x3f, (mapper_regs[4] & 0x40) ? MEM_RAM : MEM_ROM);
		mapper_map_chr_ramrom(1, 3, mapper_regs[5] & 0x3f, (mapper_regs[5] & 0x40) ? MEM_RAM : MEM_ROM);

		mapper_map_chr_ramrom(2, 2, (mapper_regs[0] >> 1) & 0x1f, ((mapper_regs[0]) & 0x40) ? MEM_RAM : MEM_ROM);
		mapper_map_chr_ramrom(2, 3, (mapper_regs[1] >> 1) & 0x1f, ((mapper_regs[1]) & 0x40) ? MEM_RAM : MEM_ROM);
	}

	if (Cart.Mirroring != 4)
		set_mirroring((mapper4_mirror) ? VERTICAL : HORIZONTAL);
}

static void mapper165_ppu_clock(UINT16 address)
{
	if (mapper165_update) {
		mapper_map();
		mapper165_update = 0;
	}

	switch (address & 0x3ff8) {
		case 0x0fd0:
			mapper165_chrlatch(0) = 0;
			mapper165_update = 1;
			break;
		case 0x0fe8:
			mapper165_chrlatch(0) = 1;
			mapper165_update = 1;
			break;
		case 0x1fd0:
			mapper165_chrlatch(1) = 2;
			mapper165_update = 1;
			break;
		case 0x1fe8:
			mapper165_chrlatch(1) = 4;
			mapper165_update = 1;
			break;
	}
}

static void mapper165_chrmap(INT32 slot, INT32 bank)
{
	mapper_map_chr_ramrom(4, slot, bank >> 2, (bank == 0x00) ? MEM_RAM : MEM_ROM);
}

static void mapper165_map()
{
    mapper_map_prg(8, 1, mapper_regs[7]);

    if (~mapper4_banksel & 0x40) {
        mapper_map_prg(8, 0, mapper_regs[6]);
        mapper_map_prg(8, 2, -2);
    } else {
        mapper_map_prg(8, 0, -2);
        mapper_map_prg(8, 2, mapper_regs[6]);
    }

	mapper165_chrmap(0, mapper_regs[mapper165_chrlatch(0)]);
	mapper165_chrmap(1, mapper_regs[mapper165_chrlatch(1)]);

	if (Cart.Mirroring != 4)
		set_mirroring(mapper4_mirror ? VERTICAL : HORIZONTAL);
}

// mapper 194: mmc3 + chrram banks 0-1
static void mapper194_chrmap(INT32 slot, INT32 bank)
{
	mapper_map_chr_ramrom(1, slot, bank, (bank >= 0x0 && bank <= 0x1) ? MEM_RAM : MEM_ROM);
}

static void mapper194_map()
{
    mapper_map_prg(8, 1, mapper_regs[7]);

    if (~mapper4_banksel & 0x40) {
        mapper_map_prg(8, 0, mapper_regs[6]);
        mapper_map_prg(8, 2, -2);
    } else {
        mapper_map_prg(8, 0, -2);
        mapper_map_prg(8, 2, mapper_regs[6]);
    }

    if (~mapper4_banksel & 0x80) {
		mapper194_chrmap(0, mapper_regs[0] & 0xfe);
		mapper194_chrmap(1, mapper_regs[0] | 0x01);
        mapper194_chrmap(2, mapper_regs[1] & 0xfe);
        mapper194_chrmap(3, mapper_regs[1] | 0x01);

		mapper194_chrmap(4, mapper_regs[2]);
		mapper194_chrmap(5, mapper_regs[3]);
		mapper194_chrmap(6, mapper_regs[4]);
		mapper194_chrmap(7, mapper_regs[5]);
	} else {
		mapper194_chrmap(0, mapper_regs[2]);
		mapper194_chrmap(1, mapper_regs[3]);
		mapper194_chrmap(2, mapper_regs[4]);
		mapper194_chrmap(3, mapper_regs[5]);

		mapper194_chrmap(4, mapper_regs[0] & 0xfe);
		mapper194_chrmap(5, mapper_regs[0] | 0x01);
		mapper194_chrmap(6, mapper_regs[1] & 0xfe);
		mapper194_chrmap(7, mapper_regs[1] | 0x01);
	}

	if (Cart.Mirroring != 4)
		set_mirroring(mapper4_mirror ? VERTICAL : HORIZONTAL);
}

static void mapper192_chrmap(INT32 slot, INT32 bank)
{
	mapper_map_chr_ramrom(1, slot, bank, (bank >= 0x8 && bank <= 0xb) ? MEM_RAM : MEM_ROM);
}

static void mapper192_map()
{
    mapper_map_prg(8, 1, mapper_regs[7]);

    if (~mapper4_banksel & 0x40) {
        mapper_map_prg(8, 0, mapper_regs[6]);
        mapper_map_prg(8, 2, -2);
    } else {
        mapper_map_prg(8, 0, -2);
        mapper_map_prg(8, 2, mapper_regs[6]);
    }

    if (~mapper4_banksel & 0x80) {
		mapper192_chrmap(0, mapper_regs[0] & 0xfe);
		mapper192_chrmap(1, mapper_regs[0] | 0x01);
        mapper192_chrmap(2, mapper_regs[1] & 0xfe);
        mapper192_chrmap(3, mapper_regs[1] | 0x01);

		mapper192_chrmap(4, mapper_regs[2]);
		mapper192_chrmap(5, mapper_regs[3]);
		mapper192_chrmap(6, mapper_regs[4]);
		mapper192_chrmap(7, mapper_regs[5]);
	} else {
		mapper192_chrmap(0, mapper_regs[2]);
		mapper192_chrmap(1, mapper_regs[3]);
		mapper192_chrmap(2, mapper_regs[4]);
		mapper192_chrmap(3, mapper_regs[5]);

		mapper192_chrmap(4, mapper_regs[0] & 0xfe);
		mapper192_chrmap(5, mapper_regs[0] | 0x01);
		mapper192_chrmap(6, mapper_regs[1] & 0xfe);
		mapper192_chrmap(7, mapper_regs[1] | 0x01);
	}

	if (Cart.Mirroring != 4)
		set_mirroring(mapper4_mirror ? VERTICAL : HORIZONTAL);
}

// mapper 195: mmc3 + chrram banks 0-3, cpu r/w @ 5000-5fff)

static void mapper195_chrmap(INT32 slot, INT32 bank)
{
	mapper_map_chr_ramrom(1, slot, bank, (bank >= 0x0 && bank <= 0x3) ? MEM_RAM : MEM_ROM);
}

static void mapper195_map()
{
    mapper_map_prg(8, 1, mapper_regs[7]);

    if (~mapper4_banksel & 0x40) {
        mapper_map_prg(8, 0, mapper_regs[6]);
        mapper_map_prg(8, 2, -2);
    } else {
        mapper_map_prg(8, 0, -2);
        mapper_map_prg(8, 2, mapper_regs[6]);
    }

    if (~mapper4_banksel & 0x80) {
		mapper195_chrmap(0, mapper_regs[0] & 0xfe);
		mapper195_chrmap(1, mapper_regs[0] | 0x01);
        mapper195_chrmap(2, mapper_regs[1] & 0xfe);
        mapper195_chrmap(3, mapper_regs[1] | 0x01);

		mapper195_chrmap(4, mapper_regs[2]);
		mapper195_chrmap(5, mapper_regs[3]);
		mapper195_chrmap(6, mapper_regs[4]);
		mapper195_chrmap(7, mapper_regs[5]);
	} else {
		mapper195_chrmap(0, mapper_regs[2]);
		mapper195_chrmap(1, mapper_regs[3]);
		mapper195_chrmap(2, mapper_regs[4]);
		mapper195_chrmap(3, mapper_regs[5]);

		mapper195_chrmap(4, mapper_regs[0] & 0xfe);
		mapper195_chrmap(5, mapper_regs[0] | 0x01);
		mapper195_chrmap(6, mapper_regs[1] & 0xfe);
		mapper195_chrmap(7, mapper_regs[1] | 0x01);
	}

	if (Cart.Mirroring != 4)
		set_mirroring(mapper4_mirror ? VERTICAL : HORIZONTAL);
}

static void mapper195_write(UINT16 address, UINT8 data)
{
	if (address >= 0x5000 && address <= 0x5fff) {
		Cart.CHRRam[address&0xfff] = data;
	}
}

static UINT8 mapper195_read(UINT16 address)
{
	if (address >= 0x5000 && address <= 0x5fff) {
		return Cart.CHRRam[address&0xfff];
	}
	return cpu_open_bus;
}

static void mapper262_map()
{
    mapper_map_prg(8, 1, mapper_regs[7]);

    if (~mapper4_banksel & 0x40) {
        mapper_map_prg(8, 0, mapper_regs[6]);
        mapper_map_prg(8, 2, -2);
    } else {
        mapper_map_prg(8, 0, -2);
        mapper_map_prg(8, 2, mapper_regs[6]);
    }

	if (mapper262_reg & 0x40) {
	   mapper_map_chr_ramrom(8, 0, 0, MEM_RAM);
	} else {
		mapper_set_chrtype(MEM_ROM);

		if (~mapper4_banksel & 0x80) {
			mapper_map_chr(1, 0, (mapper_regs[0] & 0xfe) + ((mapper262_reg & 8) << 5));
			mapper_map_chr(1, 1, (mapper_regs[0] | 0x01) + ((mapper262_reg & 8) << 5));

			mapper_map_chr(1, 2, (mapper_regs[1] & 0xfe) + ((mapper262_reg & 4) << 6));
			mapper_map_chr(1, 3, (mapper_regs[1] | 0x01) + ((mapper262_reg & 4) << 6));

			mapper_map_chr(1, 4, mapper_regs[2] + ((mapper262_reg & 1) << 8));
			mapper_map_chr(1, 5, mapper_regs[3] + ((mapper262_reg & 1) << 8));
			mapper_map_chr(1, 6, mapper_regs[4] + ((mapper262_reg & 2) << 7));
			mapper_map_chr(1, 7, mapper_regs[5] + ((mapper262_reg & 2) << 7));
		} else {
			mapper_map_chr(1, 0, mapper_regs[2] + ((mapper262_reg & 8) << 5));
			mapper_map_chr(1, 1, mapper_regs[3] + ((mapper262_reg & 8) << 5));
			mapper_map_chr(1, 2, mapper_regs[4] + ((mapper262_reg & 4) << 6));
			mapper_map_chr(1, 3, mapper_regs[5] + ((mapper262_reg & 4) << 6));

			mapper_map_chr(1, 4, (mapper_regs[0] & 0xfe) + ((mapper262_reg & 1) << 8));
			mapper_map_chr(1, 5, (mapper_regs[0] | 0x01) + ((mapper262_reg & 1) << 8));

			mapper_map_chr(1, 6, (mapper_regs[1] & 0xfe) + ((mapper262_reg & 2) << 7));
			mapper_map_chr(1, 7, (mapper_regs[1] | 0x01) + ((mapper262_reg & 2) << 7));
		}
	}

	if (Cart.Mirroring != 4)
		set_mirroring(mapper4_mirror ? VERTICAL : HORIZONTAL);
}

static UINT8 mapper262_read(UINT16 address)
{
	if (address == 0x4100) {
		// 0 = Street heroes, 0xff = Shihun
		return 0;
	}

	return 0;
}

static void mapper262_write(UINT16 address, UINT8 data)
{
	if (address == 0x4100) {
		mapper262_reg = data;
		mapper_map();
	}
}

// ---[ mapper 451: Haratyler HG (AMIC flashrom)
#define mapper451_bank          (mapper_regs[0])

static void mapper451_write(UINT16 address, UINT8 data)
{
	flashrom_write(address, data);

	if (address & 0x8000) {
        switch (address & 0xe000) {
			case 0xa000: {
				mapper4_mirror = ~address & 1;
				mapper_map();
				break;
			}
			case 0xc000: {
				mapper4_irqlatch = (address & 0xff) - 1;
				mapper4_irqreload = 0;
				if ((address & 0xff) == 0xff) {
					mapper4_irqlatch = 0;
					mapper4_irqenable = 0;
					M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
				} else {
					mapper4_irqenable = 1;
				}
				break;
			}
			case 0xe000: {
				mapper451_bank = address & 3;
				mapper_map();
				break;
			}
        }
    }
}

static void mapper451_map()
{
	mapper_map_prg(8, 0, (0x00) );
	mapper_map_prg(8, 1, (0x10 + (mapper451_bank & 1) + ((mapper451_bank & 2) << 2)) );
	mapper_map_prg(8, 2, (0x20 + (mapper451_bank & 1) + ((mapper451_bank & 2) << 2)) );
    mapper_map_prg(8, 3, (0x30) );

	mapper_map_chr(8, 0, mapper451_bank & 1);

	set_mirroring(mapper4_mirror ? VERTICAL : HORIZONTAL);
}

// mapper 406 - haradius zero (mmc3 + MXIC flash chip(prg,rw) + MXIC flash chip(chr,r)
// dev notes: https://pastebin.com/9UH8yGg6
static void mapper406_write(UINT16 address, UINT8 data)
{
	flashrom_write(address, data);
	mapper04_write((address & 0xfffe) | ((address >> 1) & 1), data);
}

#undef flashrom_cmd
#undef flashrom_busy

static UINT8 *mmc5_mask; // mmc3/mmc5 ppumask-sniffer // 0x18 = rendering
static UINT8 *mmc5_ctrl; // mmc3/mmc5 ppuctrl-sniffer // 0x20 = 8x16 spr

static void mapper04_scanline()
{
	if (NESMode & ALT_MMC3 && (mmc5_mask[0] & 0x18) == 0x00) {
		return;
	}

	{ // a12 counter stop
		const INT32 spr = (mmc5_ctrl[0] & 0x08) >> 3;
		const INT32 bg = (mmc5_ctrl[0] & 0x10) >> 4;
		const INT32 _16 = (mmc5_ctrl[0] & 0x20) >> 5;

		// if spr table == bg table data, a12 will never clock
		// in 16x8 sprite mode, a12 will "most likely" clock

		if (spr == bg && _16 == 0) return;
	}

	INT32 cnt = mapper4_irqcount;
	if (mapper4_irqcount == 0 || mapper4_irqreload) {
		mapper4_irqcount = mapper4_irqlatch;
	} else {
		mapper4_irqcount--;
	}

	if ((cnt || mapper4_irqreload) && mapper4_irqenable && mapper4_irqcount == 0) {
		if ((~NESMode & ALT_MMC3 && mmc5_mask[0] & 0x18) || NESMode & ALT_MMC3) { // aka if (RENDERING)
			M6502SetIRQLine(0, CPU_IRQSTATUS_ACK);
		}
	}
	mapper4_irqreload = 0;
}

//#undef mapper4_mirror // used in mapper_init()
#undef mapper4_irqlatch
#undef mapper4_irqcount
#undef mapper4_irqenable
#undef mapper4_irqreload
#undef mapper4_banksel

// ---[ mapper 05 (MMC5) Castlevania III, Uchuu Keibitai SDF
// PPU Hooks
static UINT8 *mmc5_nt_ram; // pointer to our ppu's nt ram
#define MMC5RENDERING (mmc5_mask[0] & 0x18)
#define MMC58x16 (mmc5_ctrl[0] & 0x20)

// Mapper registers & ram
static UINT8 mmc5_expram[1024];

#define mmc5_prgmode		(mapper_regs[0x0])
#define mmc5_chrmode		(mapper_regs[0x1])
#define mmc5_prgprot1		(mapper_regs[0x2])
#define mmc5_prgprot2		(mapper_regs[0x3])
#define mmc5_expram_mode	(mapper_regs[0x4])
#define mmc5_mirror(x)		(mapper_regs[0x1b + (x)])
#define mmc5_filltile		(mapper_regs[0x5])
#define mmc5_fillcolor		(mapper_regs[0x6])
#define mmc5_prgexp			(mapper_regs[0x7])

#define mmc5_prg(x)			(mapper_regs16[0x4 + (x)])
#define mmc5_chr(x)			(mapper_regs16[0x10 + (x)])
#define mmc5_upperchr		(mapper_regs[0x8])

#define mmc5_split			(mapper_regs[0x9])
#define mmc5_splitside		(mapper_regs[0xa])
#define mmc5_splittile		(mapper_regs[0xb])
#define mmc5_splitscroll	(mapper_regs[0xc])
#define mmc5_splitscrollmod (mapper_regs[0xd])
#define mmc5_splitchr		(mapper_regs[0xe])

#define mmc5_irqenable		(mapper_regs[0xf])
#define mmc5_irqcompare		(mapper_regs[0x10])
#define mmc5_irqpend		(mapper_regs[0x11])

#define mmc5_mult0			(mapper_regs[0x12])
#define mmc5_mult1			(mapper_regs[0x13])

#define mmc5_irqcount		(mapper_regs[0x14])
#define mmc5_inframe		(mapper_regs[0x15])

#define mmc5_lastchr		(mapper_regs[0x16])
#define mmc5_expramattr		(mapper_regs[0x17])

#define mmc5_pcmwrmode		(mapper_regs[0x18])
#define mmc5_pcmirq			(mapper_regs[0x19])
#define mmc5_pcmdata		(mapper_regs[0x1a])

enum { CHR_GUESS = 0, CHR_TILE, CHR_SPRITE, CHR_LASTREG };

static void mapper5_reset()
{
	memset(&mmc5_expram, 0xff, sizeof(mmc5_expram));

	mmc5_prgmode = 3;
	mmc5_chrmode = 3;
	mmc5_prgexp = 7;

	mmc5_prg(0) = 0x7f;
	mmc5_prg(1) = 0x7f;
	mmc5_prg(2) = 0x7f;
	mmc5_prg(3) = 0x7f;

	mmc5_filltile = 0xff;
	mmc5_fillcolor = 0xff;
	mmc5_mult0 = 0xff;
	mmc5_mult1 = 0xff; // default

	mmc5_pcmwrmode = 0x00;
	mmc5_pcmirq = 0x00;
	mmc5_pcmdata = 0x00;
}

static void mapper5_scan()
{
	SCAN_VAR(mmc5_expram);
}

static INT16 mapper5_mixer()
{
	return (INT16)(mmc5_pcmdata << 4);
}

static void mmc5_mapchr(UINT8 type)
{
	// https://wiki.nesdev.com/w/index.php/MMC5#CHR_mode_.28.245101.29
	// When using 8x8 sprites, only registers $5120-$5127 are used. Registers $5128-$512B are completely ignored.
	// When using 8x16 sprites, registers $5120-$5127 specify banks for sprites, registers $5128-$512B apply to background tiles, and the last set of registers written to (either $5120-$5127 or $5128-$512B) will be used for I/O via PPUDATA ($2007).

	if (~MMC58x16) mmc5_lastchr = 0;

	UINT8 bank = (MMC58x16 == 0) || (MMC58x16 && type == CHR_SPRITE);

	if (MMC58x16 && type == CHR_LASTREG)
		bank = mmc5_lastchr < 8;

	UINT8 banks[0x2][0xf] = {
/*bg*/  { 0xb, 0xb, 0xb, 0x9, 0xb, 0x9, 0xb, 0x8, 0x9, 0xa, 0xb, 0x8, 0x9, 0xa, 0xb },
/*spr*/ { 0x7, 0x3, 0x7, 0x1, 0x3, 0x5, 0x7, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7 } };

	switch (mmc5_chrmode) {
		case 0:
			mapper_map_chr(8, 0, mmc5_chr(banks[bank][0x0]));
			break;

		case 1:
			mapper_map_chr(4, 0, mmc5_chr(banks[bank][0x1]));
			mapper_map_chr(4, 1, mmc5_chr(banks[bank][0x2]));
			break;

		case 2:
			mapper_map_chr(2, 0, mmc5_chr(banks[bank][0x3]));
			mapper_map_chr(2, 1, mmc5_chr(banks[bank][0x4]));
			mapper_map_chr(2, 2, mmc5_chr(banks[bank][0x5]));
			mapper_map_chr(2, 3, mmc5_chr(banks[bank][0x6]));
			break;

		case 3:
			mapper_map_chr(1, 0, mmc5_chr(banks[bank][0x7]));
			mapper_map_chr(1, 1, mmc5_chr(banks[bank][0x8]));
			mapper_map_chr(1, 2, mmc5_chr(banks[bank][0x9]));
			mapper_map_chr(1, 3, mmc5_chr(banks[bank][0xa]));
			mapper_map_chr(1, 4, mmc5_chr(banks[bank][0xb]));
			mapper_map_chr(1, 5, mmc5_chr(banks[bank][0xc]));
			mapper_map_chr(1, 6, mmc5_chr(banks[bank][0xd]));
			mapper_map_chr(1, 7, mmc5_chr(banks[bank][0xe]));
			break;
	}
}

static void mapper5_map()
{
	switch (mmc5_prgmode) {
		case 0:
			mapper_map_prg(32, 0, (mmc5_prg(3) & 0x7c) >> 2);
			break;

		case 1:
			mapper_map_prg(16, 0, (mmc5_prg(1) & 0x7e) >> 1, (mmc5_prg(1) & 0x80) ? MEM_ROM : MEM_RAM);
			mapper_map_prg(16, 1, (mmc5_prg(3) & 0x7e) >> 1);
			break;

		case 2:
			mapper_map_prg(16, 0, (mmc5_prg(1) & 0x7e) >> 1, (mmc5_prg(1) & 0x80) ? MEM_ROM : MEM_RAM);
			mapper_map_prg(8, 2, mmc5_prg(2) & 0x7f, (mmc5_prg(2) & 0x80) ? MEM_ROM : MEM_RAM);
			mapper_map_prg(8, 3, mmc5_prg(3) & 0x7f);
			break;

		case 3:
			mapper_map_prg(8, 0, mmc5_prg(0) & 0x7f, (mmc5_prg(0) & 0x80) ? MEM_ROM : MEM_RAM);
			mapper_map_prg(8, 1, mmc5_prg(1) & 0x7f, (mmc5_prg(1) & 0x80) ? MEM_ROM : MEM_RAM);
			mapper_map_prg(8, 2, mmc5_prg(2) & 0x7f, (mmc5_prg(2) & 0x80) ? MEM_ROM : MEM_RAM);
			mapper_map_prg(8, 3, mmc5_prg(3) & 0x7f);
			break;
	}

	mapper_map_exp_prg(mmc5_prgexp);

	// Note: mapper5_ppu_clk() takes care of chr banking
}

static UINT8 mapper5_read(UINT16 address)
{
	if (address >= 0x5000 && address <= 0x5015) {
		switch (address) {
			case 0x5010: {
				bprintf(0, _T("mmc5 irq ack\n"));
				UINT8 ret = ((mmc5_pcmirq & 1) << 7) | (~mmc5_pcmwrmode & 1);
				mmc5_pcmirq &= ~1; // clear flag
				M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
				return ret;
			}
			default:
				return nesapuRead(0, (address & 0x1f) | 0x80);
		}
	}

	if (address >= 0x5c00 && address <= 0x5fff) {
		return (mmc5_expram_mode & 2) ? mmc5_expram[address & 0x3ff] : cpu_open_bus;
	}

	switch (address) {
		case 0x5204: {
			UINT8 ret =	(mmc5_irqpend << 7) | (mmc5_inframe << 6) | (cpu_open_bus & 0x3f);
			mmc5_irqpend = 0;
			M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
			return ret;
		}

		case 0x5205:
		case 0x5206: return ((mmc5_mult0 * mmc5_mult1) >> ((address & 0x2) << 2)) & 0xff;
	}

	return cpu_open_bus;
}


static void mapper5_exp_write(UINT16 address, UINT8 data) // 6000 - 7fff
{
	cart_exp_write_abort = 1;
	if (!Cart.WorkRAMSize) return;
	Cart.WorkRAM[PRGExpMap + (address & 0x1fff)] = data;
}

static UINT8 mapper5_exp_read(UINT16 address)             // 6000 - 7fff
{
	if (!Cart.WorkRAMSize) return 0;
	return Cart.WorkRAM[PRGExpMap + (address & 0x1fff)];
}

static void mapper5_prg_write(UINT16 address, UINT8 data)
{
	if (mmc5_prgprot1 == 0x02 && mmc5_prgprot2 == 0x01) {
		mapper_prg_write(address, data);
	}
}

static void mapper5_write(UINT16 address, UINT8 data)
{
	if (address >= 0x5000 && address <= 0x5015) {
		// Audio section
		switch (address) {
			case 0x5010:
				mmc5_pcmwrmode = ~data & 1;
				mmc5_pcmirq = data & 0x80;
				break;
			case 0x5011:
				if (mmc5_pcmwrmode) {
					if (data == 0x00 && mmc5_pcmirq) {
						mapper_irq(0);
						mmc5_pcmirq |= 0x01;
					}
					mmc5_pcmdata = data;
				}
				break;
			default:
				nesapuWrite(0, (address & 0x1f) | 0x80, data);
				break;
		}
		return;
	}

	if (address >= 0x5c00 && address <= 0x5fff) {
		switch (mmc5_expram_mode) {
			case 0:
			case 1:
				mmc5_expram[address & 0x3ff] = (MMC5RENDERING) ? data : 0x00;
				break;
			case 2:
				mmc5_expram[address & 0x3ff] = data;
				break;
        }
	}

	switch (address) {
		case 0x5100: mmc5_prgmode = data & 3; break;
		case 0x5101: mmc5_chrmode = data & 3; break;
		case 0x5102: mmc5_prgprot1 = data; break;
		case 0x5103: mmc5_prgprot2 = data; break;
		case 0x5104: mmc5_expram_mode = data & 3; break;
		case 0x5105:
			mmc5_mirror(0) = (data >> 0) & 3;
			mmc5_mirror(1) = (data >> 2) & 3;
			mmc5_mirror(2) = (data >> 4) & 3;
			mmc5_mirror(3) = (data >> 6) & 3;
			break;

		case 0x5106: mmc5_filltile = data; break;
		case 0x5107: mmc5_fillcolor = ((data & 3) << 6) | ((data & 3) << 4) | ((data & 3) << 2) | (data & 3); break;

		case 0x5113: mmc5_prgexp = data & 7; break;
		case 0x5114:
		case 0x5115:
		case 0x5116:
		case 0x5117: mmc5_prg(address & 3) = data; break;

		case 0x5120:
		case 0x5121:
		case 0x5122:
		case 0x5123:
		case 0x5124:
		case 0x5125:
		case 0x5126:
		case 0x5127:
		case 0x5128:
		case 0x5129:
		case 0x512a:
		case 0x512b:
			mmc5_chr(address & 0xf) = (mmc5_upperchr << 8) | data;
			mmc5_lastchr = (MMC58x16) ? (address & 0xf) : 0;
			break;

		case 0x5130: mmc5_upperchr = data & 3; break;

		case 0x5200:
			mmc5_splittile = data & 0x1f;
			mmc5_splitside = data & 0x40;
			mmc5_split = (data & 0x80) >> 7;
			break;
		case 0x5201:
			mmc5_splitscroll = data >> 3;
			mmc5_splitscrollmod = (mmc5_splitscroll < 30 ? 30 : 32);
			break;
		case 0x5202: mmc5_splitchr = data; break;

		case 0x5203:
			mmc5_irqcompare = data;
			break;
		case 0x5204:
			mmc5_irqenable = (data & 0x80) >> 7;
			M6502SetIRQLine(0, (mmc5_irqenable && mmc5_irqpend) ? CPU_IRQSTATUS_ACK : CPU_IRQSTATUS_NONE);
			break;

		case 0x5205: mmc5_mult0 = data; break;
		case 0x5206: mmc5_mult1 = data; break;
	}

    mapper_map();
}

static UINT8 mapper5_ntread(UINT16 address)
{
	if (mmc5_expram_mode == 1) {
		if ((address & 0x3c0) < 0x3c0) {
			UINT8 temp = mmc5_expram[(32 * ((address >> 5) & 0x1f)) + (address & 0x1f)];
			mmc5_expramattr = (temp & 0xc0) >> 6;
            mapper_map_chr(4, 0, (mmc5_upperchr << 6) | (temp & 0x3f));
            mapper_map_chr(4, 1, (mmc5_upperchr << 6) | (temp & 0x3f));
        } else {
			return (mmc5_expramattr << 6) | (mmc5_expramattr << 4) | (mmc5_expramattr << 2) | mmc5_expramattr;
        }
    }

	if (mmc5_split && mmc5_expram_mode <= 1) {
        UINT8 cur_tile = ((pixel >> 3) + 2) % 32;

		if ((mmc5_splitside && cur_tile >= mmc5_splittile) || (!mmc5_splitside && cur_tile < mmc5_splittile)) {
                mapper_map_chr(4, 0, mmc5_splitchr);
                mapper_map_chr(4, 1, mmc5_splitchr);
                UINT8 y = ((scanline >> 3) + mmc5_splitscroll) % mmc5_splitscrollmod;
				address = (pixel & 2) ? ((y * 32) & 0x3e0) | cur_tile : 0x3c0 | ((y << 1) & 0x38) | (cur_tile >> 2);
                return mmc5_expram[address & 0x3ff];
		} else {
			mmc5_mapchr(CHR_GUESS);
		}
    }

	switch (mmc5_mirror((address & 0x1fff) >> 10)) {
		case 0: return mmc5_nt_ram[(address & 0x3ff)];
		case 1: return mmc5_nt_ram[(address & 0x3ff) + 0x400];
		case 2: return (mmc5_expram_mode <= 1) ? mmc5_expram[address & 0x3ff] : 0;
		case 3: return ((address & 0x3c0) == 0x3c0) ? mmc5_fillcolor : mmc5_filltile;
	}

	return 0x00;
}

static void mapper5_ntwrite(UINT16 address, UINT8 data)
{
	switch (mmc5_mirror((address & 0x1fff) >> 10)) {
		case 0: mmc5_nt_ram[(address & 0x3ff)] = data; break;
		case 1: mmc5_nt_ram[(address & 0x3ff) + 0x400] = data; break;
		case 2: if (mmc5_expram_mode <= 1) mmc5_expram[address & 0x3ff] = data; break;
		case 3: /* invalid */ break;
	}
}

static void mmc5_lineadvance()
{
	if (scanline <= 240) {
		if (mmc5_inframe == 0 && MMC5RENDERING) {
			mmc5_inframe = 1;
			mmc5_irqcount = 0;
			mmc5_irqpend = 0;
			M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
		} else if (mmc5_inframe) {
			mmc5_irqcount++;
			if (mmc5_irqcount == mmc5_irqcompare) {
				mmc5_irqpend = 1;
				if (mmc5_irqenable) {
					M6502SetIRQLine(0, CPU_IRQSTATUS_ACK);
				}
			}
		}
	}
}

static void mapper5_ppu_clk(UINT16 address)
{
	if (MMC5RENDERING == 0 || scanline >= 240) {
		mmc5_inframe = 0;
		mmc5_mapchr(CHR_LASTREG);
		return;
	}

	switch (pixel) {
		case   1: if (~NESMode & ALT_TIMING2) mmc5_lineadvance(); break; // castelvania iii
		case  16: if (NESMode & ALT_TIMING2) mmc5_lineadvance(); break; // laser invasion prefers cycle 16 (grr..)
		case 257: mmc5_mapchr(CHR_SPRITE); break; // sprite bank switch
		case 321: mmc5_mapchr(CHR_TILE); break; // bg bank switch
	}
}
#undef mmc5_prgmode
#undef mmc5_chrmode
#undef mmc5_prgprot1
#undef mmc5_prgprot2
#undef mmc5_expram_mode
#undef mmc5_mirror
#undef mmc5_filltile
#undef mmc5_fillcolor
#undef mmc5_prgexp
#undef mmc5_prg
#undef mmc5_chr
#undef mmc5_upperchr
#undef mmc5_split
#undef mmc5_splitside
#undef mmc5_splittile
#undef mmc5_splitscroll
#undef mmc5_splitscrollmod
#undef mmc5_splitchr
#undef mmc5_irqenable
#undef mmc5_irqcompare
#undef mmc5_irqpend
#undef mmc5_mult0
#undef mmc5_mult1
#undef mmc5_irqcount
#undef mmc5_inframe
#undef mmc5_lastchr
#undef mmc5_expramattr

// ---[ mapper 07 (AxROM) Battle Toads, Marble Madness, RC Pro-Am
static void mapper07_write(UINT16 address, UINT8 data)
{
	if (address & 0x8000) {
		mapper_regs[0] = data;
		mapper_map();
	}
}

static void mapper07_map()
{
	set_mirroring((mapper_regs[0] & 0x10) ? SINGLE_HIGH : SINGLE_LOW);
    mapper_map_prg(32, 0, mapper_regs[0] & 0x7);
}

// ---[ mapper 09 (mmc2) / 10 (mmc4) Mike Tyson's Punch-Out!!, Fire Emblem
#define mapper9_prg				(mapper_regs[0xf - 0])
#define mapper9_chr_lo(x)		(mapper_regs[0xf - 1 - x])
#define mapper9_chr_hi(x)		(mapper_regs[0xf - 3 - x])
#define mapper9_chr_lo_C000		(mapper_regs[0xf - 5])
#define mapper9_chr_hi_E000		(mapper_regs[0xf - 6])
#define mapper9_mirror			(mapper_regs[0xf - 7])
#define mapper9_update          (mapper_regs[0xf - 8])

static void mapper09_write(UINT16 address, UINT8 data)
{
	if (address & 0x8000) {
		switch (address & 0xf000) {
			case 0xa000: mapper9_prg       = data & 0xf; break;
			case 0xb000: mapper9_chr_lo(0) = data & 0x1f; break;
			case 0xc000: mapper9_chr_lo(1) = data & 0x1f; break;
			case 0xd000: mapper9_chr_hi(0) = data & 0x1f; break;
			case 0xe000: mapper9_chr_hi(1) = data & 0x1f; break;
			case 0xf000: mapper9_mirror    = data & 0x1; break;
		}
		mapper_map();
	}
}

static void mapper09_map()
{
	set_mirroring((mapper9_mirror) ? HORIZONTAL : VERTICAL);
	mapper_map_prg( 8, 0, mapper9_prg);
	mapper_map_chr( 4, 0, mapper9_chr_lo(mapper9_chr_lo_C000));
	mapper_map_chr( 4, 1, mapper9_chr_hi(mapper9_chr_hi_E000));
}

static void mapper10_map()
{
	set_mirroring((mapper9_mirror) ? HORIZONTAL : VERTICAL);
	mapper_map_prg(16, 0, mapper9_prg);
	mapper_map_prg(16, 1, -1);
	mapper_map_chr( 4, 0, mapper9_chr_lo(mapper9_chr_lo_C000));
	mapper_map_chr( 4, 1, mapper9_chr_hi(mapper9_chr_hi_E000));
}

static void mapper09_ppu_clk(UINT16 busaddr)
{
	switch (busaddr & 0x3fff) {
		case 0x0fd8:
			mapper9_chr_lo_C000 = 0;
			mapper9_update = 1;
			break;
		case 0x0fe8:
			mapper9_chr_lo_C000 = 1;
			mapper9_update = 1;
			break;
	}

	switch (busaddr & 0x3ff8) {
		case 0x1fd8:
			mapper9_chr_hi_E000 = 0;
			mapper9_update = 1;
			break;
		case 0x1fe8:
			mapper9_chr_hi_E000 = 1;
			mapper9_update = 1;
			break;
	}

	if (mapper9_update) {
		// mmc2 needs update immediately on latch
		mapper9_update = 0;
		mapper_map();
	}
}

static void mapper10_ppu_clk(UINT16 busaddr)
{
	if (mapper9_update) {
		// mmc4 needs delayed update.  right window borders break in fire emblem
		// without
		mapper9_update = 0;
		mapper_map();
	}

	switch (busaddr & 0x3ff8) {
		case 0x0fd8:
			mapper9_chr_lo_C000 = 0;
			mapper9_update = 1;
			break;
		case 0x0fe8:
			mapper9_chr_lo_C000 = 1;
			mapper9_update = 1;
			break;
		case 0x1fd8:
			mapper9_chr_hi_E000 = 0;
			mapper9_update = 1;
			break;
		case 0x1fe8:
			mapper9_chr_hi_E000 = 1;
			mapper9_update = 1;
			break;
	}
}

#undef mapper9_prg
#undef mapper9_chr_lo
#undef mapper9_chr_hi
#undef mapper9_chr_lo_C000
#undef mapper9_chr_hi_E000
#undef mapper9_mirror
#undef mapper9_update

// ---[ mapper 99 (VS NES)
static void mapper99_write(UINT16 address, UINT8 data)
{
	mapper_regs[0] = data;

	mapper_map();
}

static void mapper99_map()
{
	mapper_map_chr(8, 0, (mapper_regs[0] >> 2) & 1);
	mapper_map_prg(32, 0, 0);
	if (Cart.PRGRomSize > 0x8000) {
		mapper_map_prg(8, 0, mapper_regs[0] & 4); // gumshoe
	}
}

// ---[ mapper 13 (CPROM) Videomation
static void mapper13_write(UINT16 address, UINT8 data)
{
	if (address & 0x8000) {
		mapper_regs[0] = data;
	}

	mapper_map();
}

static void mapper13_map()
{
	mapper_map_chr(4, 0, 0);
	mapper_map_chr(4, 1, mapper_regs[0] & 0x03);
}

// ---[ mapper 133 (Sachen ??) Jovial Race
static void mapper133_write(UINT16 address, UINT8 data)
{
	if ((address & 0x4100) == 0x4100) {
		mapper_regs[0] = data;
	}

	mapper_map();
}

static void mapper133_map()
{
	mapper_map_chr(8, 0, mapper_regs[0] & 0x03);
	mapper_map_prg(32, 0, (mapper_regs[0] >> 2) & 0x01);
}

// --[ mapper 16, 153, 159 - Bandai FCG
#define mapper16_mirror		(mapper_regs[0x1f - 0])
#define mapper16_irqenable	(mapper_regs[0x1f - 1])
#define mapper16_irqcount	(mapper_regs16[0x1f - 0])
#define mapper16_irqlatch	(mapper_regs16[0x1f - 1])

static void mapper16_write(UINT16 address, UINT8 data)
{
	switch (address & 0x000f) {
		case 0x00: case 0x01: case 0x02:
		case 0x03: case 0x04: case 0x05:
		case 0x06: case 0x07: case 0x08:
			mapper_regs[address & 0xf] = data;
			break; // mixed prg, chr

		case 0x09:
			mapper16_mirror = data & 0x3;
			break;

		case 0x0a:
			M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
			mapper16_irqenable = data & 1;
			mapper16_irqcount = mapper16_irqlatch;
			break;

		case 0x0b:
			mapper16_irqlatch = (mapper16_irqlatch & 0xff00) | data;
			break;

		case 0x0c:
			mapper16_irqlatch = (mapper16_irqlatch & 0x00ff) | (data << 8);
			break;

		case 0x0d: // x24 i2c write
			return; // don't bother mapper_map(); below..
			break;
	}

	mapper_map();
}

static void mapper16_map()
{
	mapper_map_prg(16, 0, mapper_regs[8]);
	mapper_map_prg(16, 1, -1);

	mapper_map_chr( 1, 0, mapper_regs[0]);
	mapper_map_chr( 1, 1, mapper_regs[1]);
	mapper_map_chr( 1, 2, mapper_regs[2]);
	mapper_map_chr( 1, 3, mapper_regs[3]);
	mapper_map_chr( 1, 4, mapper_regs[4]);
	mapper_map_chr( 1, 5, mapper_regs[5]);
	mapper_map_chr( 1, 6, mapper_regs[6]);
	mapper_map_chr( 1, 7, mapper_regs[7]);

	switch (mapper16_mirror) {
		case 0: set_mirroring(VERTICAL); break;
		case 1: set_mirroring(HORIZONTAL); break;
		case 2: set_mirroring(SINGLE_LOW); break;
		case 3: set_mirroring(SINGLE_HIGH); break;
	}
}

static void mapper153_map()
{
	mapper_map_prg(16, 0, (mapper_regs[8] & 0xf) | ((mapper_regs[0] & 0x1) << 4));
	mapper_map_prg(16, 1, 0xf | ((mapper_regs[0] & 0x1) << 4));

	mapper_map_chr( 8, 0, 0);

	switch (mapper16_mirror) {
		case 0: set_mirroring(VERTICAL); break;
		case 1: set_mirroring(HORIZONTAL); break;
		case 2: set_mirroring(SINGLE_LOW); break;
		case 3: set_mirroring(SINGLE_HIGH); break;
	}
}

static void mapper16_cycle()
{
	if (mapper16_irqenable) {
		mapper16_irqcount--;

		if (mapper16_irqcount == 0xffff) {
			M6502SetIRQLine(0, CPU_IRQSTATUS_ACK);
			mapper16_irqenable = 0;
		}
	}
}
#undef mapper16_mirror
#undef mapper16_irqenable
#undef mapper16_irqcount

// --[ mapper 18 - Jaleco (Magical John, Pizza Pop etc)
#define mapper18_irqenable	(mapper_regs[0x1f - 0])
#define mapper18_mirror     (mapper_regs[0x1f - 1])
#define mapper18_prg(x)     (mapper_regs[0 + (x)])
#define mapper18_chr(x)     (mapper_regs[4 + (x)])
#define mapper18_irqcount	(mapper_regs16[0x1f - 0])
#define mapper18_irqlatch	(mapper_regs16[0x1f - 1])
#define mapper18_irqmask	(mapper_regs16[0x1f - 2])

static void nib2byte(UINT8 &byte, UINT8 nib, INT32 high)
{
	if (high == 0) {
		byte = (byte & 0xf0) | (nib & 0xf);
	} else {
		byte = (byte & 0x0f) | (nib & 0xf) << 4;
	}
}

static void mapper18_write(UINT16 address, UINT8 data)
{
	INT32 highbits = address & 1;

	switch (address & 0xf003) {
		case 0x8000: case 0x8001:
			nib2byte(mapper18_prg(0), data, highbits);
			break;
		case 0x8002: case 0x8003:
			nib2byte(mapper18_prg(1), data, highbits);
			break;
		case 0x9000: case 0x9001:
			nib2byte(mapper18_prg(2), data, highbits);
			break;

		case 0xa000: case 0xa001:
			nib2byte(mapper18_chr(0), data, highbits);
			break;
		case 0xa002: case 0xa003:
			nib2byte(mapper18_chr(1), data, highbits);
			break;

		case 0xb000: case 0xb001:
			nib2byte(mapper18_chr(2), data, highbits);
			break;
		case 0xb002: case 0xb003:
			nib2byte(mapper18_chr(3), data, highbits);
			break;

		case 0xc000: case 0xc001:
			nib2byte(mapper18_chr(4), data, highbits);
			break;
		case 0xc002: case 0xc003:
			nib2byte(mapper18_chr(5), data, highbits);
			break;

		case 0xd000: case 0xd001:
			nib2byte(mapper18_chr(6), data, highbits);
			break;
		case 0xd002: case 0xd003:
			nib2byte(mapper18_chr(7), data, highbits);
			break;

		case 0xe000: mapper18_irqlatch = (mapper18_irqlatch & 0xfff0) | (data & 0xf); break;
		case 0xe001: mapper18_irqlatch = (mapper18_irqlatch & 0xff0f) | ((data & 0xf) << 4); break;
		case 0xe002: mapper18_irqlatch = (mapper18_irqlatch & 0xf0ff) | ((data & 0xf) << 8); break;
		case 0xe003: mapper18_irqlatch = (mapper18_irqlatch & 0x0fff) | ((data & 0xf) << 12); break;
		case 0xf000:
			mapper18_irqcount = mapper18_irqlatch;
			M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
			break;
		case 0xf001: {
			const UINT16 masks[4] = { (1<<16) - 1, (1<<12) - 1, (1<<8) - 1, (1<<4) - 1 };
			UINT8 maskpos = 0;
			mapper18_irqenable = data & 1;
			switch (data & (2|4|8)) {
				case 8: maskpos = 3; break;
				case 4: maskpos = 2; break;
				case 2: maskpos = 1; break;
				default: maskpos = 0; break;
			}
			mapper18_irqmask = masks[maskpos];

			M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
			break;
		}
		case 0xf002: mapper18_mirror = data & 3; break;
	}

	mapper_map();
}

static void mapper18_map()
{
	mapper_map_prg( 8, 0, mapper18_prg(0));
	mapper_map_prg( 8, 1, mapper18_prg(1));
	mapper_map_prg( 8, 2, mapper18_prg(2));
	mapper_map_prg( 8, 3, -1);

	for (INT32 i = 0; i < 8; i++) {
		mapper_map_chr( 1, i, mapper18_chr(i));
	}

	switch (mapper18_mirror) {
		case 0: set_mirroring(HORIZONTAL); break;
		case 1: set_mirroring(VERTICAL); break;
		case 2: set_mirroring(SINGLE_LOW); break;
		case 3: set_mirroring(SINGLE_HIGH); break;
	}
}

static void mapper18_cycle()
{
	if (mapper18_irqenable) {
		UINT16 count = mapper18_irqcount & mapper18_irqmask;
		count--;
		if (count == 0) {
			mapper_irq(2); // 2 cyc delay fixes jeebies in pizza-pop (mid-hud) and magic john (intro)
		}
		mapper18_irqcount = (mapper18_irqcount & ~mapper18_irqmask) | (count & mapper18_irqmask);
	}
}
#undef mapper18_irqenable
#undef mapper18_mirror
#undef mapper18_prg
#undef mapper18_chr
#undef mapper18_irqcount
#undef mapper18_irqlatch
#undef mapper18_irqmask

// ---[ mapper 19 Namco 163 + WSG (wave sound gen)
#define mapper19_irqcount		(mapper_regs16[0x1f - 0])
#define mapper19_irqenable  	(mapper_regs[0x1f - 0])
#define mapper19_soundaddr		(mapper_regs[0x1f - 1])
#define mapper19_soundaddrinc	(mapper_regs[0x1f - 2])
#define mapper19_soundenable	(mapper_regs[0x1f - 3])
#define mapper19_chrram_lo		(mapper_regs[0x1f - 4])
#define mapper19_chrram_mid		(mapper_regs[0x1f - 5])
#define mapper19_prg(x)     	(mapper_regs[0 + (x)]) // 0 - 2
#define mapper19_mapper210      (mapper_regs[0x1f - 6])
#define namco340_mirror			(mapper_regs[0x1f - 7])

// since chr mapping is a bit "advanced", we use a little struct
// instead of the usual mapper registers. mapper19_scan() takes care
// of the state-stuff (as well as the WSG channel regs, etc)

struct namco163_chrstuff {
	UINT8 ram;
	UINT8 data;
};

static namco163_chrstuff n163_chr[12]; // chr mapping: 8 chr banks, 4 nt banks

static UINT8 mapper19_soundram[0x80];

struct namco163_channel {
	UINT32 enabled;
	UINT32 freq;
	UINT32 phase;
	UINT32 vol;
	UINT32 len;
	UINT32 address;
	UINT32 accum;
};

static namco163_channel n163_ch[8];
static INT32 n163_channels = 0;

static void namco163_process_channel(INT16 address, UINT8 data) {
	namco163_channel *c = &n163_ch[(address >> 3) & 7];

	switch (address & 7) {
		case 0x1:
			c->phase = (c->phase & ~0x0000ff) | data;
			break;
		case 0x3:
			c->phase = (c->phase & ~0x00ff00) | (data << 8);
			break;
		case 0x5:
			c->phase = (c->phase & ~0xff0000) | (data << 16);
			break;
		case 0x0:
			c->freq = (c->freq & ~0x0000ff) | data;
			break;
		case 0x2:
			c->freq = (c->freq & ~0x00ff00) | (data << 8);
			break;
		case 0x4:
			c->freq = (c->freq & ~0xff0000) | ((data & 3) << 16);
			c->len = 0x100 - (data & 0xfc);
			c->enabled = data >> 5;
#if 0
			bprintf(0, _T("ch %d enabled%X?\n"), (address / 8) & 7, c->enabled);
			bprintf(0, _T("len: %X\n"), c->len);
			bprintf(0, _T("phase: %X\n"), c->phase);
#endif
			break;
		case 0x6:
			c->address = data;
			break;
		case 0x7:
			c->vol = (data & 0xf) * 8;
			if (address == 0x7f) {
				n163_channels = (data >> 4) & 7;
			}
#if 0
			bprintf(0, _T("ch %d vol %X data %x.     channels %d    (cycle: %d)\n"), (address / 8) & 7, c->vol, data, n163_channels, M6502TotalCycles());
#endif
			break;
	}
}

static void namco163_update_phase(namco163_channel *c, INT32 ch)
{
	ch = 0x40 + ch * 8;
	mapper19_soundram[ch + 5] = (c->phase >> 16) & 0xff;
	mapper19_soundram[ch + 3] = (c->phase >>  8) & 0xff;
	mapper19_soundram[ch + 1] = (c->phase >>  0) & 0xff;
}

static UINT32 namco163_fetch_sample(namco163_channel *c)
{
	UINT32 wave_addr = c->address + (c->phase >> 16);
	UINT32 wave_sam = mapper19_soundram[(wave_addr & 0xff) >> 1];
	wave_sam >>= (wave_addr & 1) << 2; // LE-ordered nibble

	return ((wave_sam & 0xf) - 8) * c->vol;
}

static INT16 namco163_wavesynth()
{
	if (!mapper19_soundenable) return 0;

	INT32 sample = 0;

	for (INT32 ch = 7; ch >= (7 - n163_channels); ch--) {
		namco163_channel *c = &n163_ch[ch];

		if (c->enabled && c->vol) {
			sample += namco163_fetch_sample(c);

			if (c->accum == 0) {
				c->accum = (n163_channels + 1) * 0xf;
				c->phase = (c->phase + c->freq) % (c->len << 16);
				namco163_update_phase(c, ch);
			}

			c->accum--;
		}
	}

	return sample;
}

static void mapper19_reset()
{
	memset(&n163_chr, 0, sizeof(n163_chr));
	memset(&n163_ch, 0, sizeof(n163_ch));
	memset(&mapper19_soundram, 0, sizeof(mapper19_soundram));
}

static void mapper19_scan()
{
	SCAN_VAR(n163_chr); // chr/nt mapping regs

	SCAN_VAR(mapper19_soundram); // WSG soundram

	for (INT32 i = 0x40; i < 0x80; i++) { // rebuild n163_ch from soundram
		namco163_process_channel(i, mapper19_soundram[i]);
	}
}

static INT16 mapper19_mixer()
{
	INT32 sum = namco163_wavesynth();
	return (INT16)(sum * 1.75);
}

static void mapper19_write(UINT16 address, UINT8 data)
{
	switch (address & 0xf800) {
		case 0x4800:
			if (mapper19_soundaddr >= 0x40) {
				namco163_process_channel(mapper19_soundaddr, data);
			}
			mapper19_soundram[mapper19_soundaddr] = data;
			mapper19_soundaddr = (mapper19_soundaddr + mapper19_soundaddrinc) & 0x7f;
			return; // [sound core] avoid calling mapper_map() below
		case 0x5000:
			mapper19_irqcount = (mapper19_irqcount & 0xff00) | data;
			M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
			break;
		case 0x5800:
			mapper19_irqcount = (mapper19_irqcount & 0x00ff) | ((data & 0x7f) << 8);
			mapper19_irqenable = data & 0x80;
			M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
			break;
		case 0xe000:
			mapper19_prg(0) = data & 0x3f;
			mapper19_soundenable = !(data & 0x40);
			namco340_mirror = (data & 0xc0) >> 6;
			break;
		case 0xe800:
			mapper19_prg(1) = data & 0x3f;
			mapper19_chrram_lo = !(data & 0x40);
			mapper19_chrram_mid = !(data & 0x80);
			break;
		case 0xf000:
			mapper19_prg(2) = data & 0x3f;
			break;
		case 0xf800:
			mapper19_soundaddr = data & 0x7f;
			mapper19_soundaddrinc = (data >> 7) & 1;
			return; // [sound core] avoid calling mapper_map() below

		case 0x8000: case 0x8800:
		case 0x9000: case 0x9800: {
			INT32 bank = (address - 0x8000) >> 11;
			n163_chr[bank].ram = mapper19_chrram_lo;
			n163_chr[bank].data = data;
			break;
		}
		case 0xa000: case 0xa800:
		case 0xb000: case 0xb800: {
			INT32 bank = (address - 0x8000) >> 11;
			n163_chr[bank].ram = mapper19_chrram_mid;
			n163_chr[bank].data = data;
			break;
		}
		case 0xc000: case 0xc800:
		case 0xd000: case 0xd800: {
			INT32 nt = (address - 0xc000) >> 11;
			n163_chr[8 + nt].data = data;
			break;
		}
	}

	mapper_map();
}

static UINT8 mapper19_read(UINT16 address)
{
	UINT8 ret = 0;

	switch (address & 0xf800) {
		case 0x4800:
			ret = mapper19_soundram[mapper19_soundaddr];
			mapper19_soundaddr = (mapper19_soundaddr + mapper19_soundaddrinc) & 0x7f;
			break;

		case 0x5000:
			ret = mapper19_irqcount & 0xff;
			break;

		case 0x5800:
			ret = (mapper19_irqcount >> 8) & 0xff;
			break;
	}

	return ret;
}

static void mapper19_map()
{
	mapper_map_prg(8, 0, mapper19_prg(0));
	mapper_map_prg(8, 1, mapper19_prg(1));
	mapper_map_prg(8, 2, mapper19_prg(2));
	mapper_map_prg(8, 3, -1);

	for (INT32 i = 0; i < 8; i++) {
		if (mapper19_mapper210 == 0 && n163_chr[i].ram && n163_chr[i].data >= 0xe0) {
			mapper_set_chrtype(MEM_RAM);
			mapper_map_chr(1, i, n163_chr[i].data & 0x1f);
		} else {
			mapper_set_chrtype(MEM_ROM);
			mapper_map_chr(1, i, n163_chr[i].data);
		}
	}

	switch (mapper19_mapper210) {
		case 0:	// mapper 19 (namco163) only!
			for (INT32 i = 8; i < 12; i++) {
				if (n163_chr[i].data >= 0xe0) {
					nametable_map(i & 3, n163_chr[i].data & 1);
				} else {
					nametable_mapraw(i & 3, Cart.CHRRom + (n163_chr[i].data << 10), MEM_ROM);
				}
			}
			break;
		case 1: // mapper 210 submapper 1 (namco 175): hardwired h/v mirroring
			break;
		case 2: // mapper 210 submapper 2 (namco 340): selectable
			switch (namco340_mirror) {
				case 0: set_mirroring(SINGLE_LOW); break;
				case 1: set_mirroring(VERTICAL); break;
				case 2: set_mirroring(HORIZONTAL); break;
				case 3: set_mirroring(SINGLE_HIGH); break;
			}
			break;
	}
}

static void mapper19_cycle()
{
	if (mapper19_irqenable) {
		mapper19_irqcount++;

		if (mapper19_irqcount == 0x7fff) {
			M6502SetIRQLine(0, CPU_IRQSTATUS_ACK);
			mapper19_irqenable = 0;
		}
	}
}
#undef mapper19_irqcount
#undef mapper19_irqenable
#undef mapper19_soundaddr
#undef mapper19_soundaddrinc
#undef mapper19_soundenable
#undef mapper19_chrram_lo
#undef mapper19_chrram_mid
#undef mapper19_prg
//#undef mapper19_mapper210 -- used in mapper_init!
#undef namco340_mirror

// --[ mapper 21, 22, 23, 25 - Konami VRC2/VRC4
#define mapper23_prg(x)		(mapper_regs[0x00 + x])
#define mapper23_chr(x)		(mapper_regs[0x02 + x])
#define mapper23_chrhigh(x) (mapper_regs[0x0a + x])
#define mapper23_prgswap	(mapper_regs[0x12])
#define mapper23_irqrepeat	(mapper_regs[0x13])
#define mapper23_mirror		(mapper_regs[0x14])
#define vrc2and4_ines22		(mapper_regs[0x17])

#define mapper23_irqenable	(mapper_regs[0x18])
#define mapper23_irqlatch	(mapper_regs[0x19])
#define mapper23_irqmode	(mapper_regs[0x1a])
#define mapper23_irqcycle	(mapper_regs16[0x1f - 0])
#define mapper23_irqcount	(mapper_regs16[0x1f - 1])

static void vrc2vrc4_map()
{
	if (mapper23_prgswap & 2) {
		mapper_map_prg( 8, 0, -2);
		mapper_map_prg( 8, 1, mapper23_prg(1));
		mapper_map_prg( 8, 2, mapper23_prg(0));
		mapper_map_prg( 8, 3, -1);
	} else {
		mapper_map_prg( 8, 0, mapper23_prg(0));
		mapper_map_prg( 8, 1, mapper23_prg(1));
		mapper_map_prg( 8, 2, -2);
		mapper_map_prg( 8, 3, -1);
	}

	for (INT32 i = 0; i < 8; i++) {
		mapper_map_chr( 1, i, ((mapper23_chrhigh(i) << 4) | mapper23_chr(i)) >> vrc2and4_ines22);
	}

	switch (mapper23_mirror) {
		case 0: set_mirroring(VERTICAL); break;
		case 1: set_mirroring(HORIZONTAL); break;
		case 2: set_mirroring(SINGLE_LOW); break;
		case 3: set_mirroring(SINGLE_HIGH); break;
	}
}

static void vrc2vrc4_write(UINT16 address, UINT8 data)
{
	address &= 0xf003;
	if (address >= 0xb000 && address <= 0xe003) {
		UINT8 reg = ((address >> 1) & 1) | ((address - 0xb000) >> 11);
		if (address & 1) { // high 5-bits
			mapper23_chrhigh(reg) = data & 0x1f;
		} else { // low 4-bits
			mapper23_chr(reg) = data & 0xf;
		}
		mapper_map();
	} else {
		switch (address & 0xf003) {
			case 0x8000:
			case 0x8001:
			case 0x8002:
			case 0x8003:
				mapper23_prg(0) = data; // usually a 0x1f mask, some pirate carts/hacks want this unmasked to address larger prg than usual
				mapper_map();
				break;
			case 0xA000:
			case 0xA001:
			case 0xA002:
			case 0xA003:
				mapper23_prg(1) = data; // comment: same as above
				mapper_map();
				break;
			case 0x9000:
			case 0x9001:
				if (data != 0xff) { // Wai Wai World, what are you doing?
					mapper23_mirror = data & 3;
				}
				mapper_map();
				break;
			case 0x9002:
			case 0x9003:
				mapper23_prgswap = data;
				mapper_map();
				break;
			case 0xf000:
				mapper23_irqlatch = (mapper23_irqlatch & 0xf0) | (data & 0xf);
				M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
				break;
			case 0xf001:
				mapper23_irqlatch = (mapper23_irqlatch & 0x0f) | ((data & 0xf) << 4);
				M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
				break;
			case 0xf002:
				mapper23_irqrepeat = data & 1;
				mapper23_irqenable = data & 2;
				mapper23_irqmode = data & 4; // 1 cycle, 0 scanline
				if (data & 2) {
					mapper23_irqcycle = 0;
					mapper23_irqcount = mapper23_irqlatch;
				}
				M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
				break;
			case 0xf003:
				mapper23_irqenable = mapper23_irqrepeat;
				M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
				break;
		}
	}
}

static void vrc2vrc4_cycle()
{
	if (mapper23_irqenable) {
		if (mapper23_irqmode) { // cycle mode
			mapper23_irqcount++;
			if (mapper23_irqcount >= 0x100) {
				mapper_irq(5);
				mapper23_irqcount = mapper23_irqlatch;
			}
		} else {
			mapper23_irqcycle += 3; // scanline mode
			if (mapper23_irqcycle >= 341) {
				mapper23_irqcycle -= 341;
				mapper23_irqcount++;
				if (mapper23_irqcount == 0x100) {
					mapper_irq(5);
					mapper23_irqcount = mapper23_irqlatch;
				}
			}
		}
	}
}

static void mapper21_write(UINT16 address, UINT8 data)
{
	address = (address & 0xf000) | ((address >> 1) & 0x3);

	vrc2vrc4_write(address, data);
}

static void mapper22_write(UINT16 address, UINT8 data)
{
	address |= ((address >> 2) & 0x3);

	vrc2vrc4_write((address & 0xf000) | ((address >> 1) & 1) | ((address << 1) & 2), data);
}

static void mapper23_write(UINT16 address, UINT8 data)
{
	address |= ((address >> 2) & 0x3) | ((address >> 4) & 0x3) | ((address >> 6) & 0x3);

	vrc2vrc4_write(address, data);
}

#define mapper25_write		mapper22_write   // same address line hookup/swapping

// --[ mapper 24, 26 (Konami VRC6)
#define mapper24_prg(x)		(mapper_regs[0x00 + x])
#define mapper24_chr(x)		(mapper_regs[0x02 + x])
#define mapper24_mirror		(mapper_regs[0x10])
#define mapper24_irqenable	(mapper_regs[0x11])
#define mapper24_irqrepeat	(mapper_regs[0x12])
#define mapper24_irqlatch	(mapper_regs[0x13])
#define mapper24_irqmode	(mapper_regs[0x14])
#define mapper24_irqcount	(mapper_regs16[0x1f - 0])
#define mapper24_irqcycle	(mapper_regs16[0x1f - 1])
#define mapper26			(mapper_regs[0x15])

struct vrc6_channel {
	INT32 dutyacc;
	INT32 phaseacc;
	INT32 volacc;
	INT16 sample;
	UINT8 regs[4];
};

struct vrc6_master {
	UINT8 reg;
	INT32 disable;
	INT32 octave_shift;
};

static vrc6_channel vrc6_ch[3];
static vrc6_master vrc6_cntrl;

static void vrc6_reset()
{
	memset(&vrc6_ch, 0, sizeof(vrc6_ch));
	memset(&vrc6_cntrl, 0, sizeof(vrc6_cntrl));
}

static void vrc6_scan()
{
	SCAN_VAR(vrc6_ch);
	SCAN_VAR(vrc6_cntrl);
}

static INT16 vrc6_pulse(INT32 num)
{
	struct vrc6_channel *ch = &vrc6_ch[num];

	if (ch->regs[2] & 0x80 && vrc6_cntrl.disable == 0) { // channel enabled?
		ch->sample = 0;
		if (ch->regs[0] & 0x80) { // ignore duty
			ch->sample = (ch->regs[0] & 0xf) << 8;
		} else {
			if (ch->dutyacc > ((ch->regs[0] >> 4) & 7))
				ch->sample = (ch->regs[0] & 0xf) << 8;
			ch->phaseacc--;
			if (ch->phaseacc <= 0) {
				ch->phaseacc = ((((ch->regs[2] & 0xf) << 8) | ch->regs[1]) + 1) >> vrc6_cntrl.octave_shift;
				ch->dutyacc = (ch->dutyacc + 1) & 0xf;
			}
		}
	}
	return ch->sample;
}

static INT16 vrc6_saw()
{
	struct vrc6_channel *ch = &vrc6_ch[2];

	if (ch->regs[2] & 0x80 && vrc6_cntrl.disable == 0) { // channel enabled?
		ch->sample = ((ch->volacc >> 3) & 0x1f) << 8;
		ch->phaseacc--;
		if (ch->phaseacc <= 0) {
			ch->phaseacc = ( ((((ch->regs[2] & 0xf) << 8) | ch->regs[1]) + 1)
							 >> vrc6_cntrl.octave_shift ) * 2; // each phase takes 2 cycles (* 2)
			ch->volacc += ch->regs[0] & 0x3f;
			ch->dutyacc++;
			if (ch->dutyacc == 7) {
				ch->dutyacc = 0;
				ch->volacc = 0;
			}
		}
	}
	return ch->sample;
}

static INT16 vrc6_mixer()
{
	INT32 sum = vrc6_saw();
    sum += vrc6_pulse(0);
    sum += vrc6_pulse(1);
	return (INT16)(sum * 0.75);
}

static void vrc6_sound_write(UINT16 address, UINT8 data)
{
	switch (address) {
		case 0x9003:                           // master control reg
			vrc6_cntrl.reg = data;
			vrc6_cntrl.disable = data & 1;
			vrc6_cntrl.octave_shift = (data & 4) ? 8 : 0;
			if (vrc6_cntrl.octave_shift == 0)
				vrc6_cntrl.octave_shift = (data & 2) ? 4 : 0;
			break;
		case 0x9000: case 0x9001: case 0x9002: // pulse
		case 0xa000: case 0xa001: case 0xa002: // pulse 2
		case 0xb000: case 0xb001: case 0xb002: // saw
			vrc6_ch[((address >> 12) - 9) & 3].regs[address & 3] = data;
			break;
	}
}

static void vrc6_map()
{
	mapper_map_prg(16, 0, mapper24_prg(0));
	mapper_map_prg( 8, 2, mapper24_prg(1));
	mapper_map_prg( 8, 3, -1);

	for (INT32 i = 0; i < 8; i++)
		mapper_map_chr( 1, i, mapper24_chr(i));

	switch (mapper24_mirror) {
		case 0: set_mirroring(VERTICAL); break;
		case 1: set_mirroring(HORIZONTAL); break;
		case 2: set_mirroring(SINGLE_LOW); break;
		case 3: set_mirroring(SINGLE_HIGH); break;
	}
}

static void vrc6_write(UINT16 address, UINT8 data)
{
	if (mapper26) {
		// VRC6b has bits 0 & 1 swapped
		address = (address & 0xfffc) | ((address >> 1) & 1) | ((address << 1) & 2);
	}

	if (address >= 0x9000 && address <= 0xb002) {
		vrc6_sound_write(address & 0xf003, data);
		return;
	}

	switch (address & 0xf003) {
		case 0x8000: mapper24_prg(0) = data; break;
		case 0xb003: mapper24_mirror = (data & 0xc) >> 2; break;
		case 0xc000: mapper24_prg(1) = data; break;
		case 0xd000: mapper24_chr(0) = data; break;
		case 0xd001: mapper24_chr(1) = data; break;
		case 0xd002: mapper24_chr(2) = data; break;
		case 0xd003: mapper24_chr(3) = data; break;
		case 0xe000: mapper24_chr(4) = data; break;
		case 0xe001: mapper24_chr(5) = data; break;
		case 0xe002: mapper24_chr(6) = data; break;
		case 0xe003: mapper24_chr(7) = data; break;
		case 0xf000:
			mapper24_irqlatch = data;
			M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
			break;
		case 0xf001:
			mapper24_irqrepeat = data & 1;
			mapper24_irqenable = data & 2;
			mapper24_irqmode = data & 4;
			if (mapper24_irqenable) {
				mapper24_irqcycle = 0;
				mapper24_irqcount = mapper24_irqlatch;
			}
			M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
			break;
		case 0xf002:
			mapper24_irqenable = mapper24_irqrepeat;
			M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
			break;
	}

	mapper_map();
}

static void vrc6_cycle()
{
	if (mapper24_irqenable) {
		if (mapper24_irqmode) { // cycle mode
			mapper24_irqcount++;
			if (mapper24_irqcount >= 0x100) {
				mapper_irq(0);
				mapper24_irqcount = mapper24_irqlatch;
			}
		} else {
			mapper24_irqcycle += 3; // scanline mode
			if (mapper24_irqcycle >= 341) {
				mapper24_irqcycle -= 341;
				mapper24_irqcount++;
				if (mapper24_irqcount == 0x100) {
					mapper_irq(0);
					mapper24_irqcount = mapper24_irqlatch;
				}
			}
		}
	}
}
#undef mapper24_prg
#undef mapper24_chr
#undef mapper24_mirror
#undef mapper24_irqenable
#undef mapper24_irqrepeat
#undef mapper24_irqlatch
#undef mapper24_irqmode
#undef mapper24_irqcount
#undef mapper24_irqcycle

// ---[ mapper 227 xxx-in-1, Waixing Bio Hazard
#define mapper227_mirror	(mapper_regs[0])
#define mapper227_S         (mapper_regs[1])
#define mapper227_L         (mapper_regs[2])
#define mapper227_P         (mapper_regs[3])
#define mapper227_O         (mapper_regs[4])

static void mapper227_write(UINT16 address, UINT8 data)
{
	mapper227_P = ((address >> 2) & 0x1f) | ((address & 0x100) >> 3);
	mapper227_S = address & 0x01;
	mapper227_L = address & (1 << 9);
	mapper227_O = address & (1 << 7);

	mapper227_mirror = address & 0x02;

	mapper_map();
}

static void mapper227_map()
{
	if (mapper227_O) {
		if (mapper227_S) {
			mapper_map_prg(32, 0, mapper227_P >> 1);
		} else {
			mapper_map_prg(16, 0, mapper227_P);
			mapper_map_prg(16, 1, mapper227_P);
		}
	} else {
		if (mapper227_S) {
			if (mapper227_L) {
				mapper_map_prg(16, 0, mapper227_P & 0x3e);
				mapper_map_prg(16, 1, mapper227_P | 0x07);
			} else {
				mapper_map_prg(16, 0, mapper227_P & 0x3e);
				mapper_map_prg(16, 1, mapper227_P & 0x38);
			}
		} else {
			if (mapper227_L) {
				mapper_map_prg(16, 0, mapper227_P);
				mapper_map_prg(16, 1, mapper227_P | 0x07);
			} else {
				mapper_map_prg(16, 0, mapper227_P);
				mapper_map_prg(16, 1, mapper227_P & 0x38);
			}
		}
	}

	mapper_map_chr( 8, 0, 0);

	set_mirroring((mapper227_mirror & 0x02) ? HORIZONTAL : VERTICAL);
}

// ---[ mapper 172: 1991 Du Ma Racing
#define jv001_register			(mapper_regs[0x1f - 0])
#define jv001_invert			(mapper_regs[0x1f - 1])
#define jv001_mode				(mapper_regs[0x1f - 2])
#define jv001_input				(mapper_regs[0x1f - 3])
#define jv001_output			(mapper_regs[0x1f - 4])

#define jv001_d0d3_mask		(0x0f)
#define jv001_d4d5_mask		(0x30)

static UINT8 jv001_read()
{
	UINT8 ret;
	ret =  (jv001_register & jv001_d0d3_mask);
	// if (invert), bits d4 and d5 are inverted
	ret |= (jv001_register & jv001_d4d5_mask) ^ (jv001_invert * jv001_d4d5_mask);

	bprintf(0, _T("jv001_read:  %x\n"), ret);

	return ret;
}

static void jv001_write(UINT16 address, UINT8 data)
{
	if (address & 0x8000) {
		bprintf(0, _T("jv001_latch address (%x) - output: %x\n"), address, jv001_register);
		jv001_output = jv001_register;
	} else {
		switch (address & 0xe103) {
			case 0x4100:
				if (jv001_mode) {
					// increment d0-d3, leaving d4-d5 unchanged
					UINT8 before = jv001_register;
					jv001_register = ((jv001_register + 1) & jv001_d0d3_mask) | (jv001_register & jv001_d4d5_mask);
					bprintf(0, _T("jv001_inc: mode %x  before  %x  after  %x\n"), jv001_mode, before, jv001_register);
				} else {
					// load register.  if inverted invert d0-d3, leaving d4-d5 unchanged
					UINT8 before = jv001_register;
					jv001_register = (jv001_invert) ? ((~jv001_input & jv001_d0d3_mask) | (jv001_input & jv001_d4d5_mask)) : jv001_input;
					bprintf(0, _T("jv001_load(inc): mode %x  before  %x  after  %x   input  %x\n"), jv001_mode, before, jv001_register, jv001_input);
				}
				break;
			case 0x4101:
				bprintf(0, _T("invert  %x\n"), data);
				jv001_invert = (data & 0x10) >> 4;
				break;
			case 0x4102:
				bprintf(0, _T("input  %x\n"), data);
				jv001_input = data;
				break;
			case 0x4103:
				bprintf(0, _T("mode  %x\n"), data);
				jv001_mode = (data & 0x10) >> 4;
				break;
		}
	}
}

// mapper 172: jv001 chip is mounted upside-down thus flipping d0 - d5
static UINT8 mapper172_jv001_swap(UINT8 data)
{
	return ((data & 0x01) << 5) | ((data & 0x02) << 3) | ((data & 0x04) << 1) | ((data & 0x08) >> 1) | ((data & 0x10) >> 3) | ((data & 0x20) >> 5);
}

static UINT8 mapper172_read(UINT16 address)
{
	if ((address & 0xe100) == 0x4100) {
		return mapper172_jv001_swap(jv001_read()) | (cpu_open_bus & 0xc0);
	}

	return cpu_open_bus;
}

static void mapper172_write(UINT16 address, UINT8 data)
{
	jv001_write(address, mapper172_jv001_swap(data));

	if (address & 0x8000) mapper_map();
}

static void mapper172_map()
{
	mapper_map_prg(32, 0, 0);
	mapper_map_chr( 8, 0, jv001_output & 0x03);

	set_mirroring((jv001_invert) ? VERTICAL : HORIZONTAL);
}


// --[ mapper 228: Action52
#define mapper228_mirror	(mapper_regs[0x1f - 0])
#define mapper228_prg		(mapper_regs[0x1f - 1])
#define mapper228_prgtype	(mapper_regs[0x1f - 2])
#define mapper228_chr		(mapper_regs[0x1f - 3])
#define mapper228_weird(x)	(mapper_regs[0 + (x)])

static void mapper228_write(UINT16 address, UINT8 data)
{
	if (address & 0x8000) {
		UINT8 csel = (address >> 11) & 0x03;
		if (csel == 3) csel = 2;

		mapper228_prg = ((address >> 6) & 0x1f) | (csel << 5);
		mapper228_prgtype = address & 0x20;
		mapper228_chr = ((address & 0x0f) << 2) | (data & 0x03);
		mapper228_mirror = (~address & 0x2000) >> 13;

		mapper_map();
	}
}

static void mapper228_psg_write(UINT16 address, UINT8 data)
{
	if (address >= 0x5ff0) {
		mapper228_weird(address & 3) = data;
	}
}

static UINT8 mapper228_psg_read(UINT16 address)
{
	if (address >= 0x5ff0) {
		return mapper228_weird(address & 3);
	}

	return cpu_open_bus;
}

static void mapper228_map()
{
	if (mapper228_prgtype) {
		mapper_map_prg(16, 0, mapper228_prg);
		mapper_map_prg(16, 1, mapper228_prg);
	} else {
		mapper_map_prg(16, 0, (mapper228_prg & ~1));
		mapper_map_prg(16, 1, mapper228_prg | 1);
	}

	mapper_map_chr( 8, 0, mapper228_chr);
	set_mirroring((mapper228_mirror) ? VERTICAL : HORIZONTAL);
}
#undef mapper228_mirror
#undef mapper228_prg
#undef mapper228_prgtype
#undef mapper228_chr

// --[ mapper 90: jy company
#define mapper90_209                (mapper_regs[0x1f - 0x0])
#define mapper90_211                (mapper_regs[0x1f - 0x1])

// 5800&3: multiplier / accumulator
#define mapper90_mul0   			(mapper_regs[0x1f - 0x2])
#define mapper90_mul1   			(mapper_regs[0x1f - 0x3])
#define mapper90_accu   			(mapper_regs[0x1f - 0x4])
#define mapper90_testreg			(mapper_regs[0x1f - 0x5])

// c000 - cfff&7: IRQ
#define mapper90_irqenable			(mapper_regs[0x1f - 0x6])
#define mapper90_irqmode			(mapper_regs[0x1f - 0x7])
#define mapper90_irqcounter  		(mapper_regs[0x1f - 0x8])
#define mapper90_irqprescaler	  	(mapper_regs[0x1f - 0x9])
#define mapper90_irqxor  			(mapper_regs[0x1f - 0xa])
#define mapper90_irqprescalermask	(mapper_regs[0x1f - 0xb])
#define mapper90_irqunknown  		(mapper_regs[0x1f - 0xc])

// d000 - d7ff&3: mode
#define mapper90_mode				(mapper_regs[0x1f - 0xd])
#define mapper90_mirror				(mapper_regs[0x1f - 0xe])
#define mapper90_ppu				(mapper_regs[0x1f - 0xf])
#define mapper90_obank				(mapper_regs[0x1f - 0x10])

// 8000 - 87ff&3: PRG
#define mapper90_prg(x)				(mapper_regs[0x00 + (x)])

// 9000 - 97ff&7: CHRlo
#define mapper90_chrlo(x)			(mapper_regs[0x04 + (x)])

// a000 - a7ff&7: CHRhi (actually 8bit, ran out of 8bit regs)
#define mapper90_chrhi(x)			(mapper_regs16[0x00 + (x)])

// mmc4-like 4k chr banking latch
#define mapper90_chrlatch(x)        (mapper_regs16[0x08 + (x)])

// b000 - b7ff&3: nametable config (&4 = MSB)
#define mapper90_nt(x)              (mapper_regs16[0x0a + (x)])

// forward --
static void mapper90_ppu_clockmmc4(UINT16 address);

static void mapper90_write(UINT16 address, UINT8 data)
{
	if (address >= 0x8000 && address <= 0x87ff) {
		mapper90_prg(address & 3) = data & 0x3f;
	}

	if (address >= 0x9000 && address <= 0x97ff) {
		mapper90_chrlo(address & 7) = data;
	}

	if (address >= 0xa000 && address <= 0xa7ff) {
		mapper90_chrhi(address & 7) = data;
	}

	if (address >= 0xb000 && address <= 0xb7ff) {
		if (~address & 4) { // LSB
			mapper90_nt(address & 3) = (mapper90_nt(address & 3) & 0xff00) | (data << 0);
		} else { // MSB
			mapper90_nt(address & 3) = (mapper90_nt(address & 3) & 0x00ff) | (data << 8);
		}
	}

	if (address >= 0xc000 && address <= 0xcfff) {
		switch (address & 0x7) {
			case 0:
				mapper90_irqenable = data & 1;
				if (!mapper90_irqenable) {
					M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
				}
				break;
			case 1:
				mapper90_irqmode = data;
				mapper90_irqprescalermask = (data & 4) ? 0x7 : 0xff;
				break;
			case 2:
				mapper90_irqenable = 0;
				M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
				break;
			case 3:
				mapper90_irqenable = 1;
				break;
			case 4:
				mapper90_irqprescaler = data ^ mapper90_irqxor;
				break;
			case 5:
				mapper90_irqcounter = data ^ mapper90_irqxor;
				break;
			case 6:
				mapper90_irqxor = data;
				break;
			case 7:
				mapper90_irqunknown = data;
				break;
		}
		return;
	}

	if (address >= 0xd000 && address <= 0xd7ff) {
		switch (address & 0x0003) {
			case 0:
				mapper90_mode = data | ((mapper90_211) ? 0x20 : 0x00);
				break;
			case 1: mapper90_mirror = data; break;
			case 2: mapper90_ppu = data; break;
			case 3:
				mapper90_obank = data;

				if (mapper90_209 && mapper90_obank & 0x80) {
					mapper_ppu_clock = mapper90_ppu_clockmmc4; // chr latching. enabled dynamically
				} else {
					mapper_ppu_clock = NULL;
				}
				break;
		}
	}

	mapper_map();
}

static void mapper90_psg_write(UINT16 address, UINT8 data)
{
	switch (address & 0xfc03) {
		case 0x5800: mapper90_mul0 = data; break;
		case 0x5801: mapper90_mul1 = data; break;
		case 0x5802: mapper90_accu += data; break;
		case 0x5803: mapper90_testreg = data; mapper90_accu = 0; break;
	}
}

static UINT8 mapper90_psg_read(UINT16 address)
{
	switch (address & 0xfc03) {
		case 0x5800: return ((mapper90_mul0 * mapper90_mul1) >> 0) & 0xff;
		case 0x5801: return ((mapper90_mul0 * mapper90_mul1) >> 8) & 0xff;
		case 0x5802: return mapper90_accu;
		case 0x5803: return mapper90_testreg;
	}

	switch (address & 0xffff) {
		case 0x5000: // jumper/DIP register
		case 0x5400:
		case 0x5c00:
			return 0x00;
	}

	return cpu_open_bus;
}

static void mapper90_clockirq()
{
	switch (mapper90_irqmode & 0xc0) {
		case 0x40:
			mapper90_irqcounter++;
			if ((mapper90_irqcounter == 0) && mapper90_irqenable) {
				//bprintf(0, _T("irq+ (mode %x) @ SL %d\n"), mapper90_irqmode, scanline);
				mapper_irq(2);
			}
			break;
		case 0x80:
			mapper90_irqcounter--;
			if ((mapper90_irqcounter == 0xff) && mapper90_irqenable) {
				//bprintf(0, _T("irq- (mode %x) @ SL %d\n"), mapper90_irqmode, scanline);
				mapper_irq(2); // 2 - "super mario world (unl)" HUD shaking
			}
			break;
	}
}

static void mapper90_clockpre()
{
	switch (mapper90_irqmode & 0xc0) {
		case 0x40:
			mapper90_irqprescaler++;
			if ((mapper90_irqprescaler & mapper90_irqprescalermask) == 0) {
				mapper90_clockirq();
			}
			break;
		case 0x80:
			mapper90_irqprescaler--;
			if ((mapper90_irqprescaler & mapper90_irqprescalermask) == mapper90_irqprescalermask) {
				mapper90_clockirq();
			}
			break;
	}
}

static void mapper90_ppu_clock(UINT16 address)
{
	// ppu clock mode
	if ((mapper90_irqmode & 3) == 2) {
		mapper90_clockpre();
		mapper90_clockpre();
	}
}

static void mapper90_ppu_clockmmc4(UINT16 address)
{
	switch (address & 0x3ff8) {
		case 0x0fd8:
			mapper90_chrlatch(0) = 0;
			mapper_map();
			break;
		case 0x0fe8:
			mapper90_chrlatch(0) = 2;
			mapper_map();
			break;
		case 0x1fd8:
			mapper90_chrlatch(1) = 4;
			mapper_map();
			break;
		case 0x1fe8:
			mapper90_chrlatch(1) = 6;
			mapper_map();
			break;
	}
}

static void mapper90_scanline()
{
	if ((mapper90_irqmode & 3) == 1 && (mmc5_mask[0] & 0x18) /* rendering? */) {
		for (INT32 i = 0; i < 8; i++)
			mapper90_clockpre();
	}
}

static void mapper90_cycle()
{
	if ((mapper90_irqmode & 3) == 0)
		mapper90_clockpre();
}

static UINT8 mapper90_exp_read(UINT16 address)
{
	return (mapper90_mode & 0x80) ? Cart.PRGRom[PRGExpMap + (address & 0x1fff)] : Cart.WorkRAM[address & 0x1fff];
}

static void mapper90_exp_write(UINT16 address, UINT8 data) // 6000 - 7fff
{
	if (mapper90_mode & 0x80) {
		// prg-rom mode, abort write to wram
		cart_exp_write_abort = 1; // don't fall-through after callback!
	}
}

static UINT8 mapper90_ntread(UINT16 address) // this only gets mapped for 209, 211!
{
	if (mapper90_mode & 0x20) {
		INT32 nt = (address & 0xfff) / 0x400;
		if (mapper90_mode & 0x40 || ((mapper90_ppu & 0x80) ^ (mapper90_nt(nt) & 0x80))) {
			return Cart.CHRRom[(mapper90_nt(nt)) * 0x400 + (address & 0x3ff)];
		}
	}

	return read_nt_int(address); // fall back to internal
}

static UINT16 mapper90_getchr(INT32 num)
{
	UINT16 bank = 0;
	UINT16 mask = 0xffff;

	if (~mapper90_obank & 0x20) { // outer-bank mode
		bank = (mapper90_obank & 1) | ((mapper90_obank >> 2) & 6);

		switch (mapper90_mode & 0x18) {
			case 0x00: bank <<= 5; mask = 0x1f; break;
			case 0x08: bank <<= 6; mask = 0x3f; break;
			case 0x10: bank <<= 7; mask = 0x7f; break;
			case 0x18: bank <<= 8; mask = 0xff; break;
		}
	}

	return ((mapper90_chrlo(num) | (mapper90_chrhi(num) << 8)) & mask) | bank;
}

static UINT8 mapper90_bitswap06(UINT8 data)
{
	return (data & 0x40) >> 6 | (data & 0x20) >> 4 | (data & 0x10) >> 2 | (data & 0x08) | (data & 0x04) << 2 | (data & 0x02) << 4 | (data & 0x01) << 6;
}

static void mapper90_map()
{
	// prg
	INT32 prg8_obank  = (mapper90_obank & 6) << 5;
	INT32 prg16_obank = (mapper90_obank & 6) << 4;
	INT32 prg32_obank = (mapper90_obank & 6) << 3;
	switch (mapper90_mode & 3) {
		case 0x00:
			mapper_map_prg(32, 0, prg32_obank | ((mapper90_mode & 0x04) ? (mapper90_prg(3) & 0xf) : 0xf));
			if (mapper90_mode & 0x80) {
				mapper_map_exp_prg(prg8_obank | (((mapper90_prg(3) << 2) + 3) & 0x3f));
			}
			break;
		case 0x01:
			//bprintf(0, _T("Mapper: JyCompany - 16k prg mode. *untested*\n"));
			mapper_map_prg(16, 0, prg16_obank | (mapper90_prg(1) & 0x1f));
			mapper_map_prg(16, 1, prg16_obank | ((mapper90_mode & 0x04) ? (mapper90_prg(3) & 0x1f) : 0x1f));
			if (mapper90_mode & 0x80) {
				mapper_map_exp_prg(prg8_obank | (((mapper90_prg(3) << 1) + 1) & 0x3f));
			}
			break;
		case 0x02:
			mapper_map_prg(8, 0, prg8_obank | (mapper90_prg(0) & 0x3f));
			mapper_map_prg(8, 1, prg8_obank | (mapper90_prg(1) & 0x3f));
			mapper_map_prg(8, 2, prg8_obank | (mapper90_prg(2) & 0x3f));
			mapper_map_prg(8, 3, prg8_obank | ((mapper90_mode & 0x04) ? (mapper90_prg(3) & 0x3f) : 0x3f));
			if (mapper90_mode & 0x80) {
				mapper_map_exp_prg(prg8_obank | (mapper90_prg(3) & 0x3f));
			}
			break;
		case 0x03: // same as 0x02, but with inverted bits
			//bprintf(0, _T("Mapper: JyCompany - inverted bits. *untested*\n"));
			mapper_map_prg(8, 0, prg8_obank | (mapper90_bitswap06(mapper90_prg(0)) & 0x3f));
			mapper_map_prg(8, 1, prg8_obank | (mapper90_bitswap06(mapper90_prg(1)) & 0x3f));
			mapper_map_prg(8, 2, prg8_obank | (mapper90_bitswap06(mapper90_prg(2)) & 0x3f));
			mapper_map_prg(8, 3, prg8_obank | ((mapper90_mode & 0x04) ? (mapper90_bitswap06(mapper90_prg(3)) & 0x3f) : 0x3f));
			if (mapper90_mode & 0x80) {
				mapper_map_exp_prg(prg8_obank | (mapper90_bitswap06(mapper90_prg(3)) & 0x3f));
			}
			break;
	}

	// chr
	switch (mapper90_mode & 0x18) {
		case 0x00:
			mapper_map_chr( 8, 0, mapper90_getchr(0));
			break;
		case 0x08:
			if (~mapper90_obank & 0x80) { // normal 4k banking
				mapper_map_chr( 4, 0, mapper90_getchr(0));
				mapper_map_chr( 4, 1, mapper90_getchr(4));
			} else {                      // mmc4-like latch 4k banking
				mapper_map_chr( 4, 0, mapper90_getchr(mapper90_chrlatch(0)));
				mapper_map_chr( 4, 1, mapper90_getchr(mapper90_chrlatch(1)));
			}
			break;
		case 0x10:
			mapper_map_chr( 2, 0, mapper90_getchr(0));
			mapper_map_chr( 2, 1, mapper90_getchr(2));
			mapper_map_chr( 2, 2, mapper90_getchr(4));
			mapper_map_chr( 2, 3, mapper90_getchr(6));
			break;
		case 0x18:
			mapper_map_chr( 1, 0, mapper90_getchr(0));
			mapper_map_chr( 1, 1, mapper90_getchr(1));
			mapper_map_chr( 1, 2, mapper90_getchr(2));
			mapper_map_chr( 1, 3, mapper90_getchr(3));
			mapper_map_chr( 1, 4, mapper90_getchr(4));
			mapper_map_chr( 1, 5, mapper90_getchr(5));
			mapper_map_chr( 1, 6, mapper90_getchr(6));
			mapper_map_chr( 1, 7, mapper90_getchr(7));
			break;
	}

	// nametable config - if rom nt's are selected, they will be fed via mapper90_ntread()
	// a RAM nt is always selected for writing, though. (re: Tiny Toon Adv. 6 intro)
	if (mapper90_209 && mapper90_mode & 0x20) {
		nametable_map(0, mapper90_nt(0) & 1);
		nametable_map(1, mapper90_nt(1) & 1);
		nametable_map(2, mapper90_nt(2) & 1);
		nametable_map(3, mapper90_nt(3) & 1);
	} else {
		//standard nt config
		switch (mapper90_mirror & 0x3) {
			case 0: set_mirroring(VERTICAL); break;
			case 1: set_mirroring(HORIZONTAL); break;
			case 2: set_mirroring(SINGLE_LOW); break;
			case 3: set_mirroring(SINGLE_HIGH); break;
		}
	}
}
#undef mapper90_irqenable
#undef mapper90_irqmode
#undef mapper90_irqcounter
#undef mapper90_irqprescaler
#undef mapper90_irqxor
#undef mapper90_irqprescalermask
#undef mapper90_irqunknown
#undef mapper90_mode
#undef mapper90_mirror
#undef mapper90_ppu
#undef mapper90_obank
#undef mapper90_prg
#undef mapper90_chrlo
#undef mapper90_chrhi
#undef mapper90_nt

// --[ mapper 91: older JyCompany/Hummer
#define mapper91_prg(x)		(mapper_regs[0x00 + (x)])
#define mapper91_chr(x)		(mapper_regs[0x04 + (x)])
#define mapper91_irqcount   (mapper_regs[0x1f - 0x00])
#define mapper91_irqenable	(mapper_regs[0x1f - 0x01])

static void mapper91_write(UINT16 address, UINT8 data)
{
	switch (address & 0xf000) {
		case 0x6000:
			mapper91_chr(address & 3) = data;
			break;
		case 0x7000:
			switch (address & 3) {
				case 0:
				case 1:
					mapper91_prg(address & 1) = data;
					break;
				case 2:
					mapper91_irqenable = 0;
					mapper91_irqcount = 0;
					M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
					break;
				case 3:
					mapper91_irqenable = 1;
					break;
			}
			break;
	}

	mapper_map();
}

static void mapper91_scanline()
{
	if (mapper91_irqenable && (mmc5_mask[0] & 0x18) /* rendering? */) {
		mapper91_irqcount++;
		if (mapper91_irqcount == 8) {
			mapper_irq(0x14); // 0x14 - gets rid of artefacts in "dragon ball z - super butouden 2"
			mapper91_irqenable = 0;
		}
	}
}

static void mapper91_map()
{
	mapper_map_prg( 8, 0, mapper91_prg(0));
	mapper_map_prg( 8, 1, mapper91_prg(1));
	mapper_map_prg( 8, 2, -2);
	mapper_map_prg( 8, 3, -1);

	mapper_map_chr( 2, 0, mapper91_chr(0));
	mapper_map_chr( 2, 1, mapper91_chr(1));
	mapper_map_chr( 2, 2, mapper91_chr(2));
	mapper_map_chr( 2, 3, mapper91_chr(3));
}
#undef mapper91_prg
#undef mapper91_chr
#undef mapper91_irqcount
#undef mapper91_irqenable

// --[ mapper 17: FFE / Front Far East SMC (type 17)
#define mapper17_prg(x)		(mapper_regs[0x00 + (x)])
#define mapper17_chr(x)		(mapper_regs[0x04 + (x)])
#define mapper17_irqcount   (mapper_regs16[0x00])
#define mapper17_irqenable	(mapper_regs[0x1f - 0x00])
#define mapper17_mirror		(mapper_regs[0x1f - 0x01])

static void mapper17_write(UINT16 address, UINT8 data)
{
	switch (address) {
		case 0x42fe:
			switch (data & 0x10) {
				case 0x00: mapper17_mirror = 2; break;
				case 0x10: mapper17_mirror = 3; break;
			}
			break;
		case 0x42ff:
			switch (data & 0x10) {
				case 0x00: mapper17_mirror = 0; break;
				case 0x10: mapper17_mirror = 1; break;
			}
			break;

		case 0x4501:
			mapper17_irqenable = 0;
			M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
			break;
		case 0x4502:
			mapper17_irqcount = (mapper17_irqcount & 0xff00) | data;
			M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
			break;
		case 0x4503:
			mapper17_irqcount = (mapper17_irqcount & 0x00ff) | (data << 8);
			mapper17_irqenable = 1;
			M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
			break;

		case 0x4504:
		case 0x4505:
		case 0x4506:
		case 0x4507:
			mapper17_prg(address & 3) = data;
			break;

		case 0x4510:
		case 0x4511:
		case 0x4512:
		case 0x4513:
		case 0x4514:
		case 0x4515:
		case 0x4516:
		case 0x4517:
			mapper17_chr(address & 7) = data;
			break;
	}

	mapper_map();
}

static void mapper17_cycle()
{
	if (mapper17_irqenable) {
		mapper17_irqcount++;
		if (mapper17_irqcount == 0x0000) {
			mapper_irq(0);
			mapper17_irqenable = 0;
		}
	}
}

static void mapper17_map()
{
	mapper_map_prg( 8, 0, mapper17_prg(0));
	mapper_map_prg( 8, 1, mapper17_prg(1));
	mapper_map_prg( 8, 2, mapper17_prg(2));
	mapper_map_prg( 8, 3, mapper17_prg(3));

	mapper_map_chr( 1, 0, mapper17_chr(0));
	mapper_map_chr( 1, 1, mapper17_chr(1));
	mapper_map_chr( 1, 2, mapper17_chr(2));
	mapper_map_chr( 1, 3, mapper17_chr(3));
	mapper_map_chr( 1, 4, mapper17_chr(4));
	mapper_map_chr( 1, 5, mapper17_chr(5));
	mapper_map_chr( 1, 6, mapper17_chr(6));
	mapper_map_chr( 1, 7, mapper17_chr(7));

	switch (mapper17_mirror & 0x3) {
		case 0: set_mirroring(VERTICAL); break;
		case 1: set_mirroring(HORIZONTAL); break;
		case 2: set_mirroring(SINGLE_LOW); break;
		case 3: set_mirroring(SINGLE_HIGH); break;
	}
}
#undef mapper17_prg
#undef mapper17_chr
#undef mapper17_irqcount
#undef mapper17_irqenable
#undef mapper17_mirror

// ---[ mapper 400 8-Bit X-Mas 2017
#define mapper400_reg(x)		(mapper_regs[(x)]) // 0 - 3

static void mapper400_write(UINT16 address, UINT8 data)
{
	if (address >= 0x7800 && address <= 0x7fff) {
		mapper400_reg(0) = data;
	}
	if (address >= 0x8000 && address <= 0xbfff) {
		mapper400_reg(1) = data;
	}
	if (address >= 0xc000 && address <= 0xffff) {
		mapper400_reg(2) = data;
	}

	mapper_map();
}

static void mapper400_map()
{
	mapper_map_prg(16, 0, (mapper400_reg(0) & 0x78) | (mapper400_reg(2) & 0x07));
	mapper_map_prg(16, 1, (mapper400_reg(0) & 0x78) | 0x07);

	mapper_map_chr( 8, 0, (mapper400_reg(2) >> 5) & 0x03);

	if (mapper400_reg(0) != 0x80) {
		set_mirroring((mapper400_reg(0) & 0x20) ? HORIZONTAL : VERTICAL);
	}
}

#undef mapper400_reg

// ---[ mapper 413 Super Russian Roulette
#define mapper413_reg(x)		(mapper_regs[(x)]) // 0 - 3
#define mapper413_irq_latch		(mapper_regs[4])
#define mapper413_irq_count		(mapper_regs[5])
#define mapper413_irq_enable	(mapper_regs[6])
#define mapper413_ext_control   (mapper_regs[7])

static UINT32 *mapper413_ext_addr = (UINT32*)&mapper_regs16[0];

static UINT8 mapper413_read_pcm()
{
	UINT8 data = Cart.ExtData[mapper413_ext_addr[0] & (Cart.ExtDataSize - 1)];
	if (mapper413_ext_control & 0x02) mapper413_ext_addr[0]++;
	return data;
}

static UINT8 mapper413_prg_read(UINT16 address)
{
	if ((address & 0xf000) == 0xc000) {
		return mapper413_read_pcm();
	}

	return mapper_prg_read_int(address);
}

static void mapper413_prg_write(UINT16 address, UINT8 data)
{
	switch (address & 0xf000) {
		case 0x8000: mapper413_irq_latch = data; break;
		case 0x9000: mapper413_irq_count = 0; break;
		case 0xa000: mapper413_irq_enable = 0; M6502SetIRQLine(0, CPU_IRQSTATUS_NONE); break;
		case 0xb000: mapper413_irq_enable = 1; break;
		case 0xc000: mapper413_ext_addr[0] = (mapper413_ext_addr[0] << 1) | (data >> 7); break;
		case 0xd000: mapper413_ext_control = data; break;
		case 0xe000:
		case 0xf000: mapper413_reg((data >> 6)) = data & 0x3f; break;
	}

	mapper_map();
}

static UINT8 mapper413_psg_read(UINT16 address)
{
	if ((address & 0xf800) == 0x4800) {
		return mapper413_read_pcm();
	}
	if (address >= 0x5000) {
		return Cart.PRGRom[0x1000 | (address & 0x1fff)];
	}

	return cpu_open_bus;
}
static UINT8 mapper413_exp_read(UINT16 address)
{
	return Cart.PRGRom[PRGExpMap + (address & 0x1fff)];
}

static void mapper413_map()
{
	mapper_map_exp_prg(mapper413_reg(0)); // 6000 - 7fff
	mapper_map_prg( 8, 0, mapper413_reg(1));
	mapper_map_prg( 8, 1, mapper413_reg(2));
	mapper_map_prg( 8, 2, 3);
	mapper_map_prg( 8, 3, 4);

	mapper_map_chr( 4, 0, mapper413_reg(3));
	mapper_map_chr( 4, 1, 0x3d);
}

static void mapper413_scanline()
{
	if (mapper413_irq_count == 0) {
		mapper413_irq_count = mapper413_irq_latch;
	} else {
		mapper413_irq_count--;
	}

	if (mapper413_irq_enable && mapper413_irq_count == 0) {
		if (mmc5_mask[0] & 0x18) { // aka if (RENDERING)
			mapper_irq(0);
		}
	}
}

#undef mapper413_reg
#undef mapper413_irq_latch
#undef mapper413_irq_count
#undef mapper413_irq_enable
#undef mapper413_ext_control

// --[ mapper 28: Action53 Home-brew multicart
#define mapper28_mirror		(mapper_regs[0x1f - 0])
#define mapper28_mirrorbit  (mapper_regs[0x1f - 1])
#define mapper28_cmd		(mapper_regs[0x1f - 2])
#define mapper28_regs(x)	(mapper_regs[(x)])

static void mapper28_write(UINT16 address, UINT8 data)
{
	if (address >= 0x5000 && address <= 0x5fff) {
		mapper28_cmd = ((data >> 6) & 2) | (data & 1);
	} else if (address >= 0x8000) {
		switch (mapper28_cmd) {
			case 0:
			case 1:
				mapper28_mirrorbit = (data >> 4) & 1;
				break;
			case 2:
				mapper28_mirrorbit = data & 1;
				break;
		}
		mapper28_regs(mapper28_cmd & 3) = data;

		mapper_map();
	}
}

static void mapper28_map()
{
	UINT8 slot = (mapper28_regs(2) & 0x04) >> 2;
	UINT8 outerbanksize = (mapper28_regs(2) & 0x30) >> 4;
	UINT8 outerbank = mapper28_regs(3) << 1;
	UINT8 prgbank = (mapper28_regs(1) & 0xf) << ((~mapper28_regs(2) & 0x08) >> 3);
	UINT8 page = (outerbank & ~((1 << (outerbanksize+1))-1)) | (prgbank & ((1 << (outerbanksize+1))-1));

	if (mapper28_regs(2) & 0x08) {
		mapper_map_prg(16, slot ^ 1, page);
		mapper_map_prg(16, slot    , (outerbank & 0x1fe) | slot);
	} else {
		mapper_map_prg(16, 0, page);
		mapper_map_prg(16, 1, page | 1);
	}

	mapper_map_chr( 8, 0, mapper28_regs(0) & 0x03);

	UINT8 mirror = mapper28_regs(2) & 0x03;
	if (~mirror & 0x02) {
		mirror = mapper28_mirrorbit;
	}

	switch (mirror) {
		case 0: set_mirroring(SINGLE_LOW); break;
		case 1: set_mirroring(SINGLE_HIGH); break;
		case 2: set_mirroring(VERTICAL); break;
		case 3: set_mirroring(HORIZONTAL); break;
	}
}
#undef mapper28_mirror
#undef mapper28_mirrorbit
#undef mapper28_cmd
#undef mapper28_regs

// --[ mapper 33, 48: taito
#define mapper33_prg(x)		(mapper_regs[0 + x])
#define mapper33_chr(x)		(mapper_regs[2 + x])
#define mapper33_mirror		(mapper_regs[0x1f - 0])
#define mapper33_irqenable	(mapper_regs[0x1f - 1])
#define mapper48            (mapper_regs[0x1f - 2])
#define mapper33_irqcount	(mapper_regs16[0x1f - 0])
#define mapper33_irqlatch	(mapper_regs16[0x1f - 1])
#define mapper33_irqreload  (mapper_regs16[0x1f - 2])
#define mapper48_flintstones (mapper_regs16[0x1f - 3])

static void mapper33_write(UINT16 address, UINT8 data)
{
	switch (address & 0xf003) {
		case 0x8000:
			mapper33_prg(0) = data & 0x3f;
			if (mapper48 == 0) mapper33_mirror = data & 0x40;
			break;
		case 0x8001: mapper33_prg(1) = data & 0x3f; break;

		case 0x8002: mapper33_chr(0) = data; break;
		case 0x8003: mapper33_chr(1) = data; break;
		case 0xa000: mapper33_chr(2) = data; break;
		case 0xa001: mapper33_chr(3) = data; break;
		case 0xa002: mapper33_chr(4) = data; break;
		case 0xa003: mapper33_chr(5) = data; break;
	}

	if (mapper48) {
		switch (address & 0xf003) {
			case 0xc000: mapper33_irqlatch = (data ^ 0xff) + ((mapper48_flintstones) ? 0 : 1); M6502SetIRQLine(0, CPU_IRQSTATUS_NONE); break;
			case 0xc001: mapper33_irqreload = 1; mapper33_irqcount = 0; M6502SetIRQLine(0, CPU_IRQSTATUS_NONE); break;
			case 0xc002: mapper33_irqenable = 1; break;
			case 0xc003: mapper33_irqenable = 0; M6502SetIRQLine(0, CPU_IRQSTATUS_NONE); break;
			case 0xe000: if (mapper48) mapper33_mirror = data & 0x40; break;
		}
	}

	mapper_map();
}

static void mapper33_map()
{
	mapper_map_prg( 8, 0, mapper33_prg(0));
	mapper_map_prg( 8, 1, mapper33_prg(1));
	mapper_map_prg( 8, 2, -2);
	mapper_map_prg( 8, 3, -1);

	mapper_map_chr( 2, 0, mapper33_chr(0));
	mapper_map_chr( 2, 1, mapper33_chr(1));

	mapper_map_chr( 1, 4, mapper33_chr(2));
	mapper_map_chr( 1, 5, mapper33_chr(3));
	mapper_map_chr( 1, 6, mapper33_chr(4));
	mapper_map_chr( 1, 7, mapper33_chr(5));

	set_mirroring((mapper33_mirror) ? HORIZONTAL : VERTICAL);
}

static void mapper33_scanline()
{
	INT32 cnt = mapper33_irqenable;
	if (mapper33_irqcount == 0 || mapper33_irqreload) {
		mapper33_irqreload = 0;
		mapper33_irqcount = mapper33_irqlatch;
	} else {
		mapper33_irqcount--;
	}

	if (cnt && mapper33_irqenable && mapper33_irqcount == 0) {
		mapper_irq((mapper48_flintstones) ? 0x13 : 0x06);
	}
}
#undef mapper33_mirror
#undef mapper33_irqenable
#undef mapper33_prg
#undef mapper33_chr
#undef mapper33_irqcount
#undef mapper33_irqlatch
#undef mapper33_irqreload

// --[ mapper 36 - TXC (Policeman, Strike Wolf)
#define mapper36_prg		(mapper_regs[0x1f - 0])
#define mapper36_chr		(mapper_regs[0x1f - 1])
#define mapper36_RR			(mapper_regs[0x1f - 2])
#define mapper36_PP			(mapper_regs[0x1f - 3])
#define mapper36_invert		(mapper_regs[0x1f - 4])
#define mapper36_mode		(mapper_regs[0x1f - 5])

static UINT8 mapper36_read(UINT16 address)
{
	if ((address & 0xe100) == 0x4100)
		return (cpu_open_bus & 0xcf) | (mapper36_RR << 4);
	else
		return cpu_open_bus;
}

static void mapper36_write(UINT16 address, UINT8 data)
{
	if (address > 0x7fff) {
		mapper36_prg = mapper36_RR;
	} else {
		switch (address & 0xe103) {
			case 0x4100:
				if (mapper36_mode) {
					mapper36_RR++;
				} else {
					mapper36_RR = mapper36_PP;
				}
				break;
			case 0x4101:
				mapper36_invert = data & 0x10;
				break;
			case 0x4102:
				mapper36_PP = (data >> 4) & 0x3;
				break;
			case 0x4103:
				mapper36_mode = data & 0x10;
				break;
		}
		switch (address & 0xe200) {
			case 0x4200:
				mapper36_chr = data & 0xf;
				break;
		}
	}

	mapper_map();
}

static void mapper36_map()
{
	mapper_map_prg(32, 0, mapper36_prg);

	mapper_map_chr(8, 0, mapper36_chr);
}

#undef mapper36_prg
#undef mapper36_chr
#undef mapper36_RR
#undef mapper36_mode

// --[ mapper 42 Ai Senshi Nicol FDS conversion
#define mapper42_mirror		(mapper_regs[0x1f - 0])
#define mapper42_prg		(mapper_regs[0x1f - 1])
#define mapper42_chr		(mapper_regs[0x1f - 2])
#define mapper42_irqenable	(mapper_regs[0x1f - 3])
#define mapper42_irqcount   (mapper_regs16[0])

static void mapper42_write(UINT16 address, UINT8 data)
{
	switch (address & 0xe003) {
		case 0x8000: mapper42_chr = data; break;
		case 0xe000: mapper42_prg = data & 0xf; break;
		case 0xe001: mapper42_mirror = data; break;
		case 0xe002:
			mapper42_irqenable = data & 2;
			if (!mapper42_irqenable) {
				mapper42_irqcount = 0;
				M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
			}
			break;
	}

	mapper_map();
}

static void mapper42_map()
{
	// set prg-rom @ 6000 - 7fff, fed by mapper42_exp_read()
	mapper_map_exp_prg(mapper42_prg);
	// normal prg-rom @ 8000 - ffff
	mapper_map_prg(32, 0, -1);

	mapper_map_chr(8, 0, mapper42_chr);

	set_mirroring((mapper42_mirror & 0x8) ? HORIZONTAL : VERTICAL);
}

static UINT8 mapper42_exp_read(UINT16 address)
{
	return Cart.PRGRom[PRGExpMap + (address & 0x1fff)];
}

static void mapper42_cycle()
{
	if (mapper42_irqenable) {
		mapper42_irqcount++;
		if (mapper42_irqcount >= 0x8000) {
			mapper42_irqcount -= 0x8000;
		}
		if (mapper42_irqcount >= 0x6000) {
			M6502SetIRQLine(0, CPU_IRQSTATUS_ACK);
		} else {
			M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
		}
	}
}

#undef mapper42_mirror
#undef mapper42_prg
#undef mapper42_chr
#undef mapper42_irqenable
#undef mapper42_irqcount

// --[ mapper 108 Meikyuu Jiin Dababa (Japan) FDS conversion
#define mapper108_prg		(mapper_regs[0x1f - 0])

static void mapper108_write(UINT16 address, UINT8 data)
{
	if ((address >= 0x8000 && address <= 0x8fff) || (address >= 0xf000 && address <= 0xffff)) {
		mapper108_prg = data;

		mapper_map();
	}
}

static void mapper108_map()
{
	// set prg-rom @ 6000 - 7fff, fed by mapper108_exp_read()
	mapper_map_exp_prg(mapper108_prg);
	// normal prg-rom @ 8000 - ffff
	mapper_map_prg(32, 0, -1);

	mapper_map_chr(8, 0, 0);
}

static UINT8 mapper108_exp_read(UINT16 address)
{
	return Cart.PRGRom[PRGExpMap + (address & 0x1fff)];
}

#undef mapper108_prg

// --[ mapper 111 Cheapocabra (GTROM)
#define mapper111_reg		(mapper_regs[0x1f - 0])

static void mapper111_write(UINT16 address, UINT8 data)
{
	if ((address >= 0x5000 && address <= 0x5fff) || (address >= 0x7000 && address <= 0x7fff)) {
		mapper111_reg = data;
		mapper_map();
	}
}

static void mapper111_map()
{
	mapper_map_prg(32, 0, mapper111_reg & 0xf);
	mapper_map_chr(8, 0, (mapper111_reg >> 4) & 0x1);

	INT32 nt = (mapper111_reg & 0x20) ? (0x4000 + 0x2000) : (0x4000 + 0x0000);

	for (INT32 i = 0; i < 4; i++) {
		nametable_mapraw(i & 3, Cart.CHRRam + nt + (i * 0x400), MEM_RAM);
	}
}

#undef mapper111_reg

// --[ mapper 120 Tobidase Daisakusen (Japan) FDS Conv. *game is buggy*
#define mapper120_prg		(mapper_regs[0x1f - 0])

static void mapper120_write(UINT16 address, UINT8 data)
{
	if (address == 0x41ff) {
		mapper120_prg = data & 0x7;
	}

	mapper_map();
}

static void mapper120_map()
{
	// set prg-rom @ 6000 - 7fff, fed by mapper120_exp_read()
	mapper_map_exp_prg(mapper120_prg);
	// normal prg-rom @ 8000 - ffff
	mapper_map_prg(32, 0, 2);

	mapper_map_chr(8, 0, 0);
}

static UINT8 mapper120_exp_read(UINT16 address)
{
	return Cart.PRGRom[PRGExpMap + (address & 0x1fff)];
}

#undef mapper120_prg

// --[ mapper 64 - Tengen (Atari)
#define mapper64_mirror			(mapper_regs[0x1f - 0])
#define mapper64_regnum			(mapper_regs[0x1f - 1])
#define mapper64_reload			(mapper_regs[0x1f - 2])
#define mapper64_irqmode		(mapper_regs[0x1f - 3])
#define mapper64_irqenable		(mapper_regs[0x1f - 4])
#define mapper64_irqlatch		(mapper_regs[0x1f - 5])
#define mapper64_irqcount		(mapper_regs[0x1f - 6])
#define mapper64_irqprescale	(mapper_regs[0x1f - 7])
#define mapper64_cycles         (mapper_regs16[0])

static void mapper64_write(UINT16 address, UINT8 data)
{
	if (address & 0x8000) {
        switch (address & 0xe001) {
			case 0xA000: mapper64_mirror = data & 1; mapper_map(); break;
            case 0x8000: mapper64_regnum = data; break;
			case 0x8001:
				mapper_regs[(mapper64_regnum & 0xf)] = data;
				mapper_map();
				break;

			case 0xC000:
				mapper64_irqlatch = data;
				break;
			case 0xC001:
				mapper64_reload = 1;
				mapper64_irqprescale = 0;
				mapper64_irqmode = data & 1;
				break;
			case 0xE000:
				mapper64_irqenable = 0;
				M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
				break;
			case 0xE001:
				mapper64_irqenable = 1;
				M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
				break;
        }
	}
}

static void mapper64_map()
{
	if (mapper64_regnum & 0x20) {
		mapper_map_chr(1, 0, mapper_regs[0]);
		mapper_map_chr(1, 1, mapper_regs[8]);
		mapper_map_chr(1, 2, mapper_regs[1]);
		mapper_map_chr(1, 3, mapper_regs[9]);
	} else {
		mapper_map_chr(2, 0, mapper_regs[0] >> 1);
		mapper_map_chr(2, 1, mapper_regs[1] >> 1);
	}
	mapper_map_chr(1, 4, mapper_regs[2]);
	mapper_map_chr(1, 5, mapper_regs[3]);
	mapper_map_chr(1, 6, mapper_regs[4]);
	mapper_map_chr(1, 7, mapper_regs[5]);

	mapper_map_prg(8, 0, mapper_regs[6]);
	mapper_map_prg(8, 1, mapper_regs[7]);
	mapper_map_prg(8, 2, mapper_regs[0xf]);
	mapper_map_prg(8, 3, -1);
	set_mirroring(mapper64_mirror ? HORIZONTAL : VERTICAL);
}

static void mapper64_irq_reload_logic()
{
	if (mapper64_reload) {
		mapper64_irqcount = (mapper64_irqlatch) ? mapper64_irqlatch | 1 : 0;
		if (mapper64_irqcount == 0 && mapper64_cycles > 0x10)
			mapper64_irqcount = 1;
		mapper64_reload = 0;
		mapper64_cycles = 0;
	} else if (mapper64_irqcount == 0) {
		mapper64_irqcount = mapper64_irqlatch;
		if (mapper64_cycles > 0x10)
			mapper64_cycles = 0;
	} else mapper64_irqcount --;
}

static void mapper64_scanline()
{
	if (mmc5_mask[0] & 0x18) { // aka if (RENDERING) ...
		if (mapper64_irqmode == 0) {

			mapper64_irq_reload_logic();

			if (mapper64_irqcount == 0 && mapper64_irqenable) {
				mapper_irq(1); // assert irq in 1 m2 cycle
			}
		}
	}
}

static void mapper64_cycle()
{
	if (mapper64_cycles == 0xffff) mapper64_cycles = 0x10;
	mapper64_cycles++;
	if (mapper64_irqmode == 1) {
		mapper64_irqprescale++;
		while (mapper64_irqprescale == 4) {
			mapper64_irqprescale = 0;

			mapper64_irq_reload_logic();

			if (mapper64_irqcount == 0 && mapper64_irqenable) {
				mapper_irq(4); // assert irq in 4 m2 cycles
			}
		}
	}
}

#undef mapper64_mirror
#undef mapper64_regnum
#undef mapper64_reload
#undef mapper64_irqmode
#undef mapper64_irqenable
#undef mapper64_irqlatch
#undef mapper64_irqcount
#undef mapper64_irqprescale

// --[ mapper 65 - irem h3001(?): Spartan X2, Kaiketsu Yanchamaru 3: Taiketsu! Zouringen,
#define mapper65_mirror		(mapper_regs[0x1f - 0])
#define mapper65_irqenable	(mapper_regs[0x1f - 1])
#define mapper65_prg(x)		(mapper_regs[0 + x])
#define mapper65_chr(x)		(mapper_regs[3 + x])
#define mapper65_irqcount	(mapper_regs16[0x1f - 0])
#define mapper65_irqlatch	(mapper_regs16[0x1f - 1])


static void mapper65_write(UINT16 address, UINT8 data)
{
	switch (address) {
		case 0x8000: mapper65_prg(0) = data; break;
		case 0xa000: mapper65_prg(1) = data; break;
		case 0xc000: mapper65_prg(2) = data; break;
		case 0x9001: mapper65_mirror = (~data >> 7) & 1; break;
		case 0x9003: mapper65_irqenable = data & 0x80; M6502SetIRQLine(0, CPU_IRQSTATUS_NONE); break;
		case 0x9004: mapper65_irqcount = mapper65_irqlatch; break;
		case 0x9005: mapper65_irqlatch = (mapper65_irqlatch & 0x00ff) | (data << 8); break;
		case 0x9006: mapper65_irqlatch = (mapper65_irqlatch & 0xff00) | data; break;
		case 0xb000: mapper65_chr(0) = data; break;
		case 0xb001: mapper65_chr(1) = data; break;
		case 0xb002: mapper65_chr(2) = data; break;
		case 0xb003: mapper65_chr(3) = data; break;
		case 0xb004: mapper65_chr(4) = data; break;
		case 0xb005: mapper65_chr(5) = data; break;
		case 0xb006: mapper65_chr(6) = data; break;
		case 0xb007: mapper65_chr(7) = data; break;
	}
	mapper_map();
}

static void mapper65_map()
{
	mapper_map_prg( 8, 0, mapper65_prg(0));
	mapper_map_prg( 8, 1, mapper65_prg(1));
	mapper_map_prg( 8, 2, mapper65_prg(2));
	mapper_map_prg( 8, 3, -1);

	mapper_map_chr( 1, 0, mapper65_chr(0));
	mapper_map_chr( 1, 1, mapper65_chr(1));
	mapper_map_chr( 1, 2, mapper65_chr(2));
	mapper_map_chr( 1, 3, mapper65_chr(3));
	mapper_map_chr( 1, 4, mapper65_chr(4));
	mapper_map_chr( 1, 5, mapper65_chr(5));
	mapper_map_chr( 1, 6, mapper65_chr(6));
	mapper_map_chr( 1, 7, mapper65_chr(7));

	set_mirroring(mapper65_mirror ? VERTICAL : HORIZONTAL);
}

static void mapper65_cycle()
{
	if (mapper65_irqenable) {
		mapper65_irqcount--;

		if (mapper65_irqcount == 0) {
			M6502SetIRQLine(0, CPU_IRQSTATUS_ACK);
			mapper65_irqenable = 0;
		}
	}
}
#undef mapper65_mirror
#undef mapper65_irqenable
#undef mapper65_prg
#undef mapper65_chr
#undef mapper65_irqcount
#undef mapper65_irqlatch


// --[ mapper 67 - Sunsoft-3 (Fantasy Zone II, Mito Koumon II: Sekai Manyuu Ki)
#define mapper67_mirror		(mapper_regs[0x1f - 0])
#define mapper67_irqenable	(mapper_regs[0x1f - 1])
#define mapper67_irqtoggle  (mapper_regs[0x1f - 2])
#define mapper67_prg		(mapper_regs[0])
#define mapper67_chr(x)		(mapper_regs[1 + x])
#define mapper67_irqcount	(mapper_regs16[0x1f - 0])

static void mapper67_write(UINT16 address, UINT8 data)
{
	switch (address & 0xf800) {
		case 0x8800: mapper67_chr(0) = data; break;
		case 0x9800: mapper67_chr(1) = data; break;
		case 0xa800: mapper67_chr(2) = data; break;
		case 0xb800: mapper67_chr(3) = data; break;
		case 0xc000:
		case 0xc800:
			if (mapper67_irqtoggle == 0) {
				mapper67_irqcount = (mapper67_irqcount & 0x00ff) | (data << 8);
			} else {
				mapper67_irqcount = (mapper67_irqcount & 0xff00) | (data << 0);
			}
			mapper67_irqtoggle ^= 1;
			break;
		case 0xd800:
			mapper67_irqtoggle = 0;
			mapper67_irqenable = data & 0x10;
			M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
			break;
		case 0xe800:
			mapper67_mirror = data & 3;
			break;
		case 0xf800:
			mapper67_prg = data;
			break;
	}
	mapper_map();
}

static void mapper67_map()
{
	mapper_map_prg(16, 0, mapper67_prg);
	mapper_map_prg(16, 1, -1);

	mapper_map_chr( 2, 0, mapper67_chr(0));
	mapper_map_chr( 2, 1, mapper67_chr(1));
	mapper_map_chr( 2, 2, mapper67_chr(2));
	mapper_map_chr( 2, 3, mapper67_chr(3));

	switch (mapper67_mirror) {
		case 0: set_mirroring(VERTICAL); break;
		case 1: set_mirroring(HORIZONTAL); break;
		case 2: set_mirroring(SINGLE_LOW); break;
		case 3: set_mirroring(SINGLE_HIGH); break;
	}
}

static void mapper67_cycle()
{
	if (mapper67_irqenable) {
		mapper67_irqcount--;

		if (mapper67_irqcount == 0xffff) {
			M6502SetIRQLine(0, CPU_IRQSTATUS_ACK);
			mapper67_irqenable = 0;
		}
	}
}
#undef mapper67_mirror
#undef mapper67_irqenable
#undef mapper67_irqtoggle
#undef mapper67_prg
#undef mapper67_chr
#undef mapper67_irqcount

// --[ mapper 68 - Sunsoft-4 (After Burner 1 & 2, Nantettatte!! Baseball, Maharaja)
// Notes: Nantettatte!! Baseball ext.roms not supported yet.
#define mapper68_mirror		(mapper_regs[0x1f - 0])
#define mapper68_prg		(mapper_regs[0x1f - 1])
#define mapper68_wram_en    (mapper_regs[0x1f - 2])
#define mapper68_nt0		(mapper_regs[0x1f - 3])
#define mapper68_nt1		(mapper_regs[0x1f - 4])
#define mapper68_chr(x)		(mapper_regs[0 + (x)])

static INT32 *mapper68_timer = (INT32*)&mapper_regs16[0];

static UINT8 mapper68_exp_read(UINT16 address) // 6000-7fff
{
	if (mapper68_wram_en) {
		return Cart.WorkRAM[address & 0x1fff];
	} else {
		return cpu_open_bus;
	}
}

static void mapper68_exp_write(UINT16 address, UINT8 data) // 6000-7fff
{
	if (mapper68_wram_en) {
		mapper68_timer[0] = 107520;
	} else {
		cart_exp_write_abort = 1; // wram/sram area disabled (disable writing on return from this callback)
	}
}

static void mapper68_write(UINT16 address, UINT8 data)
{
	switch (address & 0xf000) {
		case 0x8000: mapper68_chr(0) = data; break;
		case 0x9000: mapper68_chr(1) = data; break;
		case 0xa000: mapper68_chr(2) = data; break;
		case 0xb000: mapper68_chr(3) = data; break;
		case 0xc000: mapper68_nt0 = data | 0x80; break;
		case 0xd000: mapper68_nt1 = data | 0x80; break;
		case 0xe000: mapper68_mirror = data; break;
		case 0xf000:
			mapper68_prg = data & 7;
			mapper68_wram_en = data & 0x10;
			break;
	}
	mapper_map();
}

static void mapper68_map()
{
	mapper_map_prg(16, 0, mapper68_prg & 7);
	mapper_map_prg(16, 1, -1);

	mapper_map_chr( 2, 0, mapper68_chr(0));
	mapper_map_chr( 2, 1, mapper68_chr(1));
	mapper_map_chr( 2, 2, mapper68_chr(2));
	mapper_map_chr( 2, 3, mapper68_chr(3));

	if (mapper68_mirror & 0x10) {
		switch (mapper68_mirror & 3) {
			case 0:
				nametable_mapraw(0, Cart.CHRRom + (mapper68_nt0 << 10), MEM_ROM);
				nametable_mapraw(2, Cart.CHRRom + (mapper68_nt0 << 10), MEM_ROM);
				nametable_mapraw(1, Cart.CHRRom + (mapper68_nt1 << 10), MEM_ROM);
				nametable_mapraw(3, Cart.CHRRom + (mapper68_nt1 << 10), MEM_ROM);
				break;
			case 1:
				nametable_mapraw(0, Cart.CHRRom + (mapper68_nt0 << 10), MEM_ROM);
				nametable_mapraw(1, Cart.CHRRom + (mapper68_nt0 << 10), MEM_ROM);
				nametable_mapraw(2, Cart.CHRRom + (mapper68_nt1 << 10), MEM_ROM);
				nametable_mapraw(3, Cart.CHRRom + (mapper68_nt1 << 10), MEM_ROM);
				break;
			case 2:
				nametable_mapraw(0, Cart.CHRRom + (mapper68_nt0 << 10), MEM_ROM);
				nametable_mapraw(1, Cart.CHRRom + (mapper68_nt0 << 10), MEM_ROM);
				nametable_mapraw(2, Cart.CHRRom + (mapper68_nt0 << 10), MEM_ROM);
				nametable_mapraw(3, Cart.CHRRom + (mapper68_nt0 << 10), MEM_ROM);
				break;
			case 3:
				nametable_mapraw(0, Cart.CHRRom + (mapper68_nt1 << 10), MEM_ROM);
				nametable_mapraw(1, Cart.CHRRom + (mapper68_nt1 << 10), MEM_ROM);
				nametable_mapraw(2, Cart.CHRRom + (mapper68_nt1 << 10), MEM_ROM);
				nametable_mapraw(3, Cart.CHRRom + (mapper68_nt1 << 10), MEM_ROM);
				break;
		}

	} else {
		switch (mapper68_mirror & 3) {
			case 0: set_mirroring(VERTICAL); break;
			case 1: set_mirroring(HORIZONTAL); break;
			case 2: set_mirroring(SINGLE_LOW); break;
			case 3: set_mirroring(SINGLE_HIGH); break;
		}
	}
}

static void mapper68_cycle()
{
	if (mapper68_timer[0] > 0) {
		mapper68_timer[0]--;

		if (mapper68_timer[0] == 0) {
		}
	}
}

#undef mapper68_mirror
#undef mapper68_prg
#undef mapper68_chr
#undef mapper68_wram_en
#undef mapper68_nt0
#undef mapper68_nt1

// --[ mapper 69 (sunsoft fme-7: Gimmick!, Hebereke, Pyokotan)
#define mapper69_mirror		(mapper_regs[0x1f - 0])
#define mapper69_regnum		(mapper_regs[0x1f - 1])
#define mapper69_irqenable	(mapper_regs[0x1f - 2])
#define mapper69_irqcount   (mapper_regs16[0])

static void mapper69_write(UINT16 address, UINT8 data)
{
	switch (address & 0xe000) {
		case 0x8000: mapper69_regnum = data & 0xf; break;
		case 0xa000:
			switch (mapper69_regnum) {
				case 0x0:
				case 0x1:
				case 0x2:
				case 0x3:
				case 0x4:
				case 0x5:
				case 0x6:
				case 0x7: mapper_regs[(mapper69_regnum & 0xf)] = data; break;
				case 0x8: mapper_regs[0x8 + 3] = data; break;
				case 0x9: mapper_regs[0x8 + 0] = data; break;
				case 0xa: mapper_regs[0x8 + 1] = data; break;
				case 0xb: mapper_regs[0x8 + 2] = data; break;
				case 0xc: mapper69_mirror = data & 3; break;
				case 0xd: mapper69_irqenable = data; M6502SetIRQLine(0, CPU_IRQSTATUS_NONE); break;
				case 0xe: mapper69_irqcount = (mapper69_irqcount & 0xff00) | data; break;
				case 0xf: mapper69_irqcount = (mapper69_irqcount & 0x00ff) | (data << 8); break;
			}
			if (mapper69_regnum < 0xd)
				mapper_map();
			break;

		case 0xc000:
			AY8910Write(0, 0, data);
			break;
		case 0xe000:
			AY8910Write(0, 1, data);
			break;
	}
}

static void mapper69_map()
{
	if ((mapper_regs[8 + 3] & 0xc0) == 0xc0) {
		// set prg-ram @ 6000 - 7fff
		// handled in mapper69_exp_write/read
	} else {
		// set prg-rom @ 6000 - 7fff
		mapper_map_exp_prg(mapper_regs[8 + 3] & 0x3f);
	}

	mapper_map_prg( 8, 0, mapper_regs[8 + 0]);
	mapper_map_prg( 8, 1, mapper_regs[8 + 1]);
	mapper_map_prg( 8, 2, mapper_regs[8 + 2]);
	mapper_map_prg( 8, 3, -1);

	mapper_map_chr(1, 0, mapper_regs[0]);
	mapper_map_chr(1, 1, mapper_regs[1]);
	mapper_map_chr(1, 2, mapper_regs[2]);
	mapper_map_chr(1, 3, mapper_regs[3]);
	mapper_map_chr(1, 4, mapper_regs[4]);
	mapper_map_chr(1, 5, mapper_regs[5]);
	mapper_map_chr(1, 6, mapper_regs[6]);
	mapper_map_chr(1, 7, mapper_regs[7]);

	switch (mapper69_mirror) {
        case 0: set_mirroring(VERTICAL); break;
        case 1: set_mirroring(HORIZONTAL); break;
        case 2: set_mirroring(SINGLE_LOW); break;
        case 3: set_mirroring(SINGLE_HIGH); break;
	}
}

static void mapper69_exp_write(UINT16 address, UINT8 data)
{
	if ((mapper_regs[8 + 3] & 0xc0) == 0xc0) {
		Cart.WorkRAM[address & Cart.WorkRAMMask] = data;
	}
	cart_exp_write_abort = 1;
}

static UINT8 mapper69_exp_read(UINT16 address)
{
	if ((mapper_regs[8 + 3] & 0xc0) == 0x40) { // ram selected, but disabled
		return cpu_open_bus;
	} if ((mapper_regs[8 + 3] & 0xc0) == 0xc0) { // ram selected and enabled
		return Cart.WorkRAM[address & Cart.WorkRAMMask];
	} else { // rom selected
		return Cart.PRGRom[PRGExpMap + (address & 0x1fff)];
	}
}

static void mapper69_cycle()
{
	if (mapper69_irqenable) {
		mapper69_irqcount--;
		if (mapper69_irqcount == 0xffff) {
			M6502SetIRQLine(0, CPU_IRQSTATUS_ACK);
			mapper69_irqenable = 0;
		}
	}
}

#undef mapper69_mirror
#undef mapper69_regnum
#undef mapper69_irqenable

// --[ mapper 70: (Kamen Rider Club)
static void mapper70_write(UINT16 address, UINT8 data)
{
	mapper_regs[0] = data;
	mapper_map();
}

static void mapper70_map()
{
	mapper_map_prg(16, 0, mapper_regs[0] >> 4);
	mapper_map_prg(16, 1, -1);
	mapper_map_chr( 8, 0, mapper_regs[0] & 0xf);
}

// --[ mapper 71: Camerica (Bee 52, Big Nose, Fire Hawk, Micro Machines, ...)
static void mapper71_write(UINT16 address, UINT8 data)
{
	if ((address & 0xf000) == 0x9000) {
		mapper_regs[1] = ((data & 0x10) ? SINGLE_HIGH : SINGLE_LOW);
	} else {
		mapper_regs[0] = data;
	}

	mapper_map();
}

static void mapper71_map()
{
	mapper_map_prg(16, 0, mapper_regs[0]);
	mapper_map_prg(16, 1, -1);
	mapper_map_chr( 8, 0, 0);

	if (mapper_regs[1]) {
		// only fire hawk sets this, everything else uses hard-mirroring
		set_mirroring(mapper_regs[1]);
	}
}

// --[ mapper 73 - Konami vrc3 (Salamander)
// note: the flickery pixels on the top-right of HUD also happens on FC HW -dink
#define mapper73_irqenable	(mapper_regs[0x1f - 1])
#define mapper73_irqmode	(mapper_regs[0x1f - 2])
#define mapper73_irqreload  (mapper_regs[0x1f - 3])
#define mapper73_prg		(mapper_regs[0])
#define mapper73_irqcount	(mapper_regs16[0x1f - 0])
#define mapper73_irqlatch	(mapper_regs16[0x1f - 1])

static void mapper73_write(UINT16 address, UINT8 data)
{
	switch (address & 0xf000) {
		case 0x8000: mapper73_irqlatch = (mapper73_irqlatch & 0xfff0) | (data & 0xf); break;
		case 0x9000: mapper73_irqlatch = (mapper73_irqlatch & 0xff0f) | ((data & 0xf) << 4); break;
		case 0xa000: mapper73_irqlatch = (mapper73_irqlatch & 0xf0ff) | ((data & 0xf) << 8); break;
		case 0xb000: mapper73_irqlatch = (mapper73_irqlatch & 0x0fff) | ((data & 0xf) << 12); break;
		case 0xc000:
			mapper73_irqreload = data & 1;
			mapper73_irqenable = data & 2;
			mapper73_irqmode = data & 4;

			if (mapper73_irqenable) {
				if (mapper73_irqmode) {
					// when is this mode used? I can't make it happen -dink
					mapper73_irqcount = mapper73_irqlatch & 0xff;
				} else {
					mapper73_irqcount = mapper73_irqlatch;
				}
			}
			M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
			break;
		case 0xd000:
			mapper73_irqenable = mapper73_irqreload;
			M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
			break;
		case 0xf000:
			mapper73_prg = data;
			break;
	}
	mapper_map();
}

static void mapper73_map()
{
	mapper_map_prg(16, 0, mapper73_prg);
	mapper_map_prg(16, 1, -1);
	mapper_map_chr( 8, 0, 0);
}

static void mapper73_cycle()
{
	if (mapper73_irqenable) {
		if ( (mapper73_irqmode && (mapper73_irqcount & 0xff) == 0xff) ||
			((mapper73_irqmode == 0) && mapper73_irqcount == 0xffff) ) {
			mapper73_irqcount = mapper73_irqlatch;
			M6502SetIRQLine(0, CPU_IRQSTATUS_ACK);
		} else {
			mapper73_irqcount++;
		}
	}
}
#undef mapper73_irqenable
#undef mapper73_irqmode
#undef mapper73_irqreload
#undef mapper73_prg
#undef mapper73_irqcount
#undef mapper73_irqlatch

// --[ mapper 75: Konami VRC1 (King Kong 2, Tetsuwan Atom, ...)
#define mapper75_prg(x)     (mapper_regs[0 + x]) // 0 - 2
#define mapper75_chr(x)     (mapper_regs[3 + x]) // 3 - 4
#define mapper75_ext        (mapper_regs[8])
static void mapper75_write(UINT16 address, UINT8 data)
{
	switch (address & 0xf000) {
		case 0x8000: mapper75_prg(0) = data; break;
		case 0x9000: mapper75_ext = data; break;
		case 0xa000: mapper75_prg(1) = data; break;
		case 0xc000: mapper75_prg(2) = data; break;
		case 0xe000: mapper75_chr(0) = data; break;
		case 0xf000: mapper75_chr(1) = data; break;
	}

	mapper_map();
}

static void mapper75_map()
{
	mapper_map_prg( 8, 0, mapper75_prg(0));
	mapper_map_prg( 8, 1, mapper75_prg(1));
	mapper_map_prg( 8, 2, mapper75_prg(2));
	mapper_map_prg( 8, 3, -1);

	mapper_map_chr( 4, 0, (mapper75_chr(0) & 0xf) | ((mapper75_ext & 2) << 3));
	mapper_map_chr( 4, 1, (mapper75_chr(1) & 0xf) | ((mapper75_ext & 4) << 2));

	if (Cart.Mirroring != 4) {
		set_mirroring((mapper75_ext & 1) ? HORIZONTAL : VERTICAL);
	}
}
#undef mapper75_prg
#undef mapper75_chr
#undef mapper75_ext

// --[ mapper 85 (VRC7) Lagrange Point, Tiny Toon Adventures 2 (Japan)
#define mapper85_prg(x)		(mapper_regs[0x00 + x])
#define mapper85_chr(x)		(mapper_regs[0x03 + x])
#define mapper85_mirror		(mapper_regs[0x10])
#define mapper85_wramen     (mapper_regs[0x11])
#define mapper85_irqenable	(mapper_regs[0x12])
#define mapper85_irqrepeat	(mapper_regs[0x13])
#define mapper85_irqlatch	(mapper_regs[0x14])
#define mapper85_irqmode	(mapper_regs[0x15])
#define mapper85_irqcount	(mapper_regs16[0x1f - 0])
#define mapper85_irqcycle	(mapper_regs16[0x1f - 1])
#define vrc7_mute           (mapper_regs[0x16])

static void vrc7_map()
{
	mapper_map_prg( 8, 0, mapper85_prg(0));
	mapper_map_prg( 8, 1, mapper85_prg(1));
	mapper_map_prg( 8, 2, mapper85_prg(2));
	mapper_map_prg( 8, 3, -1);

	for (INT32 i = 0; i < 8; i++)
		mapper_map_chr( 1, i, mapper85_chr(i));

	switch (mapper85_mirror) {
		case 0: set_mirroring(VERTICAL); break;
		case 1: set_mirroring(HORIZONTAL); break;
		case 2: set_mirroring(SINGLE_LOW); break;
		case 3: set_mirroring(SINGLE_HIGH); break;
	}

	if (mapper85_wramen) {
		NESMode &= ~NO_WORKRAM;
	} else {
		NESMode |= NO_WORKRAM;
	}
}

static void vrc7_write(UINT16 address, UINT8 data)
{
	if (address & 0x18) {
		// VRC7a uses xx10, VRC7b uses xxx8
		address = (address & ~0x0008) | 0x0010;
	}

	switch (address & 0xf030) {
		case 0x8000: mapper85_prg(0) = data & 0x3f; break;
		case 0x8010: mapper85_prg(1) = data & 0x3f; break;
		case 0x9000: mapper85_prg(2) = data & 0x3f; break;

		case 0x9010: BurnYM2413Write(0, data); break;
		case 0x9030: BurnYM2413Write(1, data); break;

		case 0xa000: mapper85_chr(0) = data; break;
		case 0xa010: mapper85_chr(1) = data; break;
		case 0xb000: mapper85_chr(2) = data; break;
		case 0xb010: mapper85_chr(3) = data; break;
		case 0xc000: mapper85_chr(4) = data; break;
		case 0xc010: mapper85_chr(5) = data; break;
		case 0xd000: mapper85_chr(6) = data; break;
		case 0xd010: mapper85_chr(7) = data; break;

		case 0xe000:
			mapper85_mirror = data & 0x3;
			mapper85_wramen = data & 0x80;
			vrc7_mute = data & 0x40;
			break;

		case 0xe010:
			mapper85_irqlatch = data;
			M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
			break;
		case 0xf000:
			mapper85_irqrepeat = data & 1;
			mapper85_irqenable = data & 2;
			mapper85_irqmode = data & 4;
			if (mapper85_irqenable) {
				mapper85_irqcycle = 0;
				mapper85_irqcount = mapper85_irqlatch;
			}
			M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
			break;
		case 0xf010:
			mapper85_irqenable = mapper85_irqrepeat;
			M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);
			break;
	}

	mapper_map();
}

static void vrc7_cycle()
{
	if (mapper85_irqenable) {
		if (mapper85_irqmode) { // cycle mode
			mapper85_irqcount++;
			if (mapper85_irqcount >= 0x100) {
				M6502SetIRQLine(0, CPU_IRQSTATUS_ACK);
				mapper_irq(4);
				mapper85_irqcount = mapper85_irqlatch;
			}
		} else {
			mapper85_irqcycle += 3; // scanline mode
			if (mapper85_irqcycle >= 341) {
				mapper85_irqcycle -= 341;
				mapper85_irqcount++;
				if (mapper85_irqcount == 0x100) {
					M6502SetIRQLine(0, CPU_IRQSTATUS_ACK);
					mapper_irq(4);
					mapper85_irqcount = mapper85_irqlatch;
				}
			}
		}
	}
}
#undef mapper85_prg
#undef mapper85_chr
#undef mapper85_mirror
#undef mapper85_wramen
#undef mapper85_irqenable
#undef mapper85_irqrepeat
#undef mapper85_irqlatch
#undef mapper85_irqmode
#undef mapper85_irqcount
#undef mapper85_irqcycle

// --[ mapper 116: Somari (AV Girl Fighting)
// it's a frankensteinian mess-mapper -dink
#define mapper116_vrc2_prg(x)		(mapper_regs[0x00 + (x)])
#define mapper116_vrc2_chr(x)		(mapper_regs[0x02 + (x)])
#define mapper116_vrc2_mirror		(mapper_regs[0x0a])
#define mapper116_mode				(mapper_regs[0x0b])

#define mapper116_mmc3_banksel      (mapper_regs[0x0c])
#define mapper116_mmc3_mirror		(mapper_regs[0x0d])
#define mapper116_mmc3_irqlatch 	(mapper_regs[0x0e])
#define mapper116_mmc3_irqcount		(mapper_regs[0x0f])
#define mapper116_mmc3_irqenable	(mapper_regs[0x10])
#define mapper116_mmc3_irqreload	(mapper_regs[0x11])
#define mapper116_mmc3_regs(x)		(mapper_regs16[0x12 + (x)]) // must be regs16!

#define mapper116_mmc1_regs(x)		(mapper_regs[0x1b + (x)])
#define mapper116_mmc1_serialbyte	(mapper_regs16[0])
#define mapper116_mmc1_bitcount		(mapper_regs16[1])

static void mapper116_defaults()
{
	mapper116_vrc2_prg(0) = 0;
	mapper116_vrc2_prg(1) = 1;
	mapper116_vrc2_chr(0) = 0xff;
	mapper116_vrc2_chr(1) = 0xff;
	mapper116_vrc2_chr(2) = 0xff;
	mapper116_vrc2_chr(3) = 0xff;
	mapper116_vrc2_chr(4) = 4;
	mapper116_vrc2_chr(5) = 5;
	mapper116_vrc2_chr(6) = 6;
	mapper116_vrc2_chr(7) = 7;

	mapper116_mmc1_regs(0) = 0x0c;

	mapper116_mmc3_regs(0) = 0;
	mapper116_mmc3_regs(1) = 2;
	mapper116_mmc3_regs(2) = 4;
	mapper116_mmc3_regs(3) = 5;
	mapper116_mmc3_regs(4) = 6;
	mapper116_mmc3_regs(5) = 7;
	mapper116_mmc3_regs(6) = -4;
	mapper116_mmc3_regs(7) = -3;
	mapper116_mmc3_regs(8) = -2;
	mapper116_mmc3_regs(9) = -1;
}

static void mapper116_write(UINT16 address, UINT8 data)
{
	if (address < 0x8000) {
		if ((address & 0x4100) == 0x4100) {
			// Someri
			mapper116_mode = data;
			if (address & 1) {
				mapper116_mmc1_bitcount = 0;
				mapper116_mmc1_serialbyte = 0;
				mapper116_mmc1_regs(0) = 0x0c;
				mapper116_mmc1_regs(3) = 0x00;
			}
			mapper_map();
		}
	} else {
		if (address == 0xa131) {
			// Gouder SL-1632, mode & 2 == mmc3, ~mode & 2 == vrc2
			mapper116_mode = (data & ~3) | ((data & 2) >> 1);
		}
		switch (mapper116_mode & 3) {
			case 0:	{
				if (address >= 0xb000 && address <= 0xe003) {
					INT32 reg = ((((address & 2) | (address >> 10)) >> 1) + 2) & 7;

					if (~address & 1) {
						mapper116_vrc2_chr(reg) = (mapper116_vrc2_chr(reg) & 0xf0) | (data & 0x0f);
					} else {
						mapper116_vrc2_chr(reg) = (mapper116_vrc2_chr(reg) & 0x0f) | ((data & 0x0f) << 4);
					}
				} else {
					switch (address & 0xf000) {
						case 0x8000: mapper116_vrc2_prg(0) = data; break;
						case 0x9000: mapper116_vrc2_mirror = data & 1; break;
						case 0xa000: mapper116_vrc2_prg(1) = data; break;
					}
				}
				mapper_map();
			}
			break;
			case 1: {
				switch (address & 0xe001) {
					case 0x8000: mapper116_mmc3_banksel = data; break;
					case 0x8001: mapper116_mmc3_regs(mapper116_mmc3_banksel & 0x7) = data; break;
					case 0xa000: mapper116_mmc3_mirror = data & 1; break;
					case 0xc000: mapper116_mmc3_irqlatch = data; break;
					case 0xc001: mapper116_mmc3_irqreload = 1; break;
					case 0xe000: mapper116_mmc3_irqenable = 0; M6502SetIRQLine(0, CPU_IRQSTATUS_NONE); break;
					case 0xe001: mapper116_mmc3_irqenable = 1; break;
				}
				mapper_map();
			}
			break;
			case 2:
			case 3: {
				if (address & 0x8000) {
					if (data & 0x80) { // bit 7, mapper reset
						mapper116_mmc1_bitcount = 0;
						mapper116_mmc1_serialbyte = 0;
						mapper116_mmc1_regs(0) |= 0x0c;
						if (mapper_map) mapper_map();
					} else {
						mapper116_mmc1_serialbyte |= (data & 1) << mapper116_mmc1_bitcount;
						mapper116_mmc1_bitcount++;
						if (mapper116_mmc1_bitcount == 5) {
							UINT8 reg = (address >> 13) & 0x3;
							mapper116_mmc1_regs(reg) = mapper116_mmc1_serialbyte;
							mapper116_mmc1_bitcount = 0;
							mapper116_mmc1_serialbyte = 0;
							if (mapper_map) mapper_map();
						}
					}
				}
			}
			break;
		}
	}
}

static void mapper116_map()
{
	INT32 bank = (mapper116_mode & 4) << 6;
	switch (mapper116_mode & 3) {
		case 0: {
			mapper_map_chr( 1, 0, mapper116_vrc2_chr(0) | bank);
			mapper_map_chr( 1, 1, mapper116_vrc2_chr(1) | bank);
			mapper_map_chr( 1, 2, mapper116_vrc2_chr(2) | bank);
			mapper_map_chr( 1, 3, mapper116_vrc2_chr(3) | bank);
			mapper_map_chr( 1, 4, mapper116_vrc2_chr(4) | bank);
			mapper_map_chr( 1, 5, mapper116_vrc2_chr(5) | bank);
			mapper_map_chr( 1, 6, mapper116_vrc2_chr(6) | bank);
			mapper_map_chr( 1, 7, mapper116_vrc2_chr(7) | bank);

			mapper_map_prg( 8, 0, mapper116_vrc2_prg(0));
			mapper_map_prg( 8, 1, mapper116_vrc2_prg(1));
			mapper_map_prg( 8, 2, -2);
			mapper_map_prg( 8, 3, -1);

			set_mirroring((mapper116_vrc2_mirror) ? HORIZONTAL : VERTICAL);
		}
		break;
		case 1: {
			mapper_map_prg(8, ((mapper116_mmc3_banksel & 0x40) >> 5), mapper116_mmc3_regs(6));
			mapper_map_prg(8, 1, mapper116_mmc3_regs(7));
			mapper_map_prg(8, 2 ^ ((mapper116_mmc3_banksel & 0x40) >> 5), mapper116_mmc3_regs(8));
			mapper_map_prg(8, 3, mapper116_mmc3_regs(9));

			INT32 swap = (mapper116_mmc3_banksel & 0x80) >> 5;
			mapper_map_chr( 1, 0 ^ swap, (mapper116_mmc3_regs(0) & 0xfe) | bank);
			mapper_map_chr( 1, 1 ^ swap, (mapper116_mmc3_regs(0) | 0x01) | bank);
			mapper_map_chr( 1, 2 ^ swap, (mapper116_mmc3_regs(1) & 0xfe) | bank);
			mapper_map_chr( 1, 3 ^ swap, (mapper116_mmc3_regs(1) | 0x01) | bank);
			mapper_map_chr( 1, 4 ^ swap, mapper116_mmc3_regs(2) | bank);
			mapper_map_chr( 1, 5 ^ swap, mapper116_mmc3_regs(3) | bank);
			mapper_map_chr( 1, 6 ^ swap, mapper116_mmc3_regs(4) | bank);
			mapper_map_chr( 1, 7 ^ swap, mapper116_mmc3_regs(5) | bank);

			set_mirroring((mapper116_mmc3_mirror) ? HORIZONTAL : VERTICAL);
		}
		break;
		case 2:
		case 3: {
			if (mapper116_mmc1_regs(0) & 0x8) {
				if (mapper116_mmc1_regs(0) & 0x4) {
					mapper_map_prg(16, 0, mapper116_mmc1_regs(3) & 0xf);
					mapper_map_prg(16, 1, 0x0f);
				} else {
					mapper_map_prg(16, 0, 0);
					mapper_map_prg(16, 1, mapper116_mmc1_regs(3) & 0xf);
				}
			} else {
				mapper_map_prg(32, 0, (mapper116_mmc1_regs(3) & 0xf) >> 1);
			}

			if (mapper116_mmc1_regs(0) & 0x10) {
				mapper_map_chr( 4, 0, mapper116_mmc1_regs(1));
				mapper_map_chr( 4, 1, mapper116_mmc1_regs(2));
			} else {
				mapper_map_chr( 8, 0, mapper116_mmc1_regs(1) >> 1);
			}

			switch (mapper116_mmc1_regs(0) & 3) {
				case 0: set_mirroring(SINGLE_LOW); break;
				case 1: set_mirroring(SINGLE_HIGH); break;
				case 2: set_mirroring(VERTICAL); break;
				case 3: set_mirroring(HORIZONTAL); break;
			}
		}
		break;
	}
}

static void mapper14_map()
{
	switch (mapper116_mode & 3) {
		case 0: {
			mapper_map_chr( 1, 0, mapper116_vrc2_chr(0));
			mapper_map_chr( 1, 1, mapper116_vrc2_chr(1));
			mapper_map_chr( 1, 2, mapper116_vrc2_chr(2));
			mapper_map_chr( 1, 3, mapper116_vrc2_chr(3));
			mapper_map_chr( 1, 4, mapper116_vrc2_chr(4));
			mapper_map_chr( 1, 5, mapper116_vrc2_chr(5));
			mapper_map_chr( 1, 6, mapper116_vrc2_chr(6));
			mapper_map_chr( 1, 7, mapper116_vrc2_chr(7));

			mapper_map_prg( 8, 0, mapper116_vrc2_prg(0));
			mapper_map_prg( 8, 1, mapper116_vrc2_prg(1));
			mapper_map_prg( 8, 2, -2);
			mapper_map_prg( 8, 3, -1);

			set_mirroring((mapper116_vrc2_mirror) ? HORIZONTAL : VERTICAL);
		}
		break;
		case 1: {
			mapper_map_prg(8, ((mapper116_mmc3_banksel & 0x40) >> 5), mapper116_mmc3_regs(6));
			mapper_map_prg(8, 1, mapper116_mmc3_regs(7));
			mapper_map_prg(8, 2 ^ ((mapper116_mmc3_banksel & 0x40) >> 5), mapper116_mmc3_regs(8));
			mapper_map_prg(8, 3, mapper116_mmc3_regs(9));

			INT32 swap = (mapper116_mmc3_banksel & 0x80) >> 5;
			INT32 bank0 = (mapper116_mode & 0x08) << 5;
			INT32 bank1 = (mapper116_mode & 0x20) << 3;
			INT32 bank2 = (mapper116_mode & 0x80) << 1;
			mapper_map_chr( 1, 0 ^ swap, (mapper116_mmc3_regs(0) & 0xfe) | bank0);
			mapper_map_chr( 1, 1 ^ swap, (mapper116_mmc3_regs(0) | 0x01) | bank0);
			mapper_map_chr( 1, 2 ^ swap, (mapper116_mmc3_regs(1) & 0xfe) | bank0);
			mapper_map_chr( 1, 3 ^ swap, (mapper116_mmc3_regs(1) | 0x01) | bank0);
			mapper_map_chr( 1, 4 ^ swap, mapper116_mmc3_regs(2) | bank1);
			mapper_map_chr( 1, 5 ^ swap, mapper116_mmc3_regs(3) | bank1);
			mapper_map_chr( 1, 6 ^ swap, mapper116_mmc3_regs(4) | bank2);
			mapper_map_chr( 1, 7 ^ swap, mapper116_mmc3_regs(5) | bank2);

			set_mirroring((mapper116_mmc3_mirror) ? HORIZONTAL : VERTICAL);
		}
		break;
	}
}

static void mapper116_mmc3_scanline()
{
	if ((mapper116_mode & 0x03) != 1) return;

	if (mapper116_mmc3_irqcount == 0 || mapper116_mmc3_irqreload) {
		mapper116_mmc3_irqreload = 0;
		mapper116_mmc3_irqcount = mapper116_mmc3_irqlatch;
	} else {
		mapper116_mmc3_irqcount--;
	}

	if (mapper116_mmc3_irqcount == 0 && mapper116_mmc3_irqenable && (mmc5_mask[0] & 0x18)) {
		mapper_irq(0);
	}
}
#undef mapper116_vrc2_prg
#undef mapper116_vrc2_chr
#undef mapper116_vrc2_mirror
#undef mapper116_mode

#undef mapper116_mmc3_banksel
#undef mapper116_mmc3_mirror
#undef mapper116_mmc3_irqlatch
#undef mapper116_mmc3_irqcount
#undef mapper116_mmc3_irqenable
#undef mapper116_mmc3_irqreload
#undef mapper116_mmc3_regs

#undef mapper116_mmc1_regs
#undef mapper116_mmc1_serialbyte
#undef mapper116_mmc1_bitcount

// --[ mapper 80: Taito X1-005
// --[ mapper 207: with advanced mirroring
#define mapper207_prg(x)     (mapper_regs[0 + x]) // 0 - 2
#define mapper207_chr(x)     (mapper_regs[3 + x]) // 3 - 9
#define mapper207_mirror     (mapper_regs[0x1f - 0])
#define mapper207_ram_en     (mapper_regs[0x1f - 1])
#define mapper207_adv_mirror (mapper_regs[0x1f - 2]) // mapper 207 yes, 80 no

static UINT8 mapper80_ram[0x80];

static void mapper207_scan()
{
	SCAN_VAR(mapper80_ram);
}

static UINT8 mapper207_read(UINT16 address)
{
	if (address >= 0x7f00 && address <= 0x7fff) {
		if (mapper207_ram_en == 0xa3) {
			return mapper80_ram[address & 0x7f];
		}
	}
	return 0xff;
}

static void mapper207_write(UINT16 address, UINT8 data)
{
	if (address >= 0x7f00 && address <= 0x7fff) {
		if (mapper207_ram_en == 0xa3) {
			mapper80_ram[address & 0x7f] = data;
		}
	}

	switch (address) {
		case 0x7ef0: mapper207_chr(0) = data; break;
		case 0x7ef1: mapper207_chr(1) = data; break;
		case 0x7ef2: mapper207_chr(2) = data; break;
		case 0x7ef3: mapper207_chr(3) = data; break;
		case 0x7ef4: mapper207_chr(4) = data; break;
		case 0x7ef5: mapper207_chr(5) = data; break;
		case 0x7ef6:
		case 0x7ef7: mapper207_mirror = data & 1; break; // for mapper80
		case 0x7ef8:
		case 0x7ef9: mapper207_ram_en = data; break; // for mapper80
		case 0x7efa:
		case 0x7efb: mapper207_prg(0) = data; break;
		case 0x7efc:
		case 0x7efd: mapper207_prg(1) = data; break;
		case 0x7efe:
		case 0x7eff: mapper207_prg(2) = data; break;
	}

	mapper_map();
}

static void mapper207_map()
{
	mapper_map_prg( 8, 0, mapper207_prg(0));
	mapper_map_prg( 8, 1, mapper207_prg(1));
	mapper_map_prg( 8, 2, mapper207_prg(2));
	mapper_map_prg( 8, 3, -1);

	mapper_map_chr( 2, 0, (mapper207_chr(0) >> 1) & 0x3f);
	mapper_map_chr( 2, 1, (mapper207_chr(1) >> 1) & 0x3f);
	mapper_map_chr( 1, 4, mapper207_chr(2));
	mapper_map_chr( 1, 5, mapper207_chr(3));
	mapper_map_chr( 1, 6, mapper207_chr(4));
	mapper_map_chr( 1, 7, mapper207_chr(5));

	if (mapper207_adv_mirror == 0) {
		set_mirroring((mapper207_mirror & 1) ? VERTICAL : HORIZONTAL);
	} else {
		nametable_mapall((mapper207_chr(0) >> 7) & 1, (mapper207_chr(0) >> 7) & 1, (mapper207_chr(1) >> 7) & 1, (mapper207_chr(1) >> 7) & 1);
	}
}
#undef mapper207_prg
#undef mapper207_chr
#undef mapper207_mirror
#undef mapper207_ram_en

// ---[ mapper 81 NTDEC Super Gun (Caltron)
static void mapper81_write(UINT16 address, UINT8 data)
{
	if (address & 0x8000) {
		mapper_regs[0] = data;
		mapper_map();
	}
}

static void mapper81_map()
{
    mapper_map_prg(16, 0, (mapper_regs[0] >> 2) & 0x03);
    mapper_map_prg(16, 1, -1);
    mapper_map_chr( 8, 0, mapper_regs[0] & 0x03);
}

// --[ mapper 82: Taito X1-017
#define mapper82_prg(x)     (mapper_regs[0 + (x)]) // 0 - 2
#define mapper82_chr(x)     (mapper_regs[3 + (x)]) // 3 - 8
#define mapper82_mirror     (mapper_regs[0x1f - 0])
#define mapper82_a12inv     (mapper_regs[0x1f - 1])
#define mapper82_ram_en(x)  (mapper_regs[9 + (x)])

static UINT8 mapper82_read(UINT16 address)
{
	if ( ((address >= 0x6000 && address <= 0x67ff) && mapper82_ram_en(0)) ||
		 ((address >= 0x6800 && address <= 0x6fff) && mapper82_ram_en(1)) ||
		 ((address >= 0x7000 && address <= 0x73ff) && mapper82_ram_en(2))
	   )
		return Cart.WorkRAM[(address & 0x1fff)];

	return cpu_open_bus;
}


static void mapper82_write(UINT16 address, UINT8 data)
{
	cart_exp_write_abort = 1; // don't fall-through after callback!

	if ( ((address >= 0x6000 && address <= 0x67ff) && mapper82_ram_en(0)) ||
		 ((address >= 0x6800 && address <= 0x6fff) && mapper82_ram_en(1)) ||
		 ((address >= 0x7000 && address <= 0x73ff) && mapper82_ram_en(2))
	   )
		Cart.WorkRAM[(address & 0x1fff)] = data;

	switch (address) {
		case 0x7ef0: mapper82_chr(0) = data; break;
		case 0x7ef1: mapper82_chr(1) = data; break;
		case 0x7ef2: mapper82_chr(2) = data; break;
		case 0x7ef3: mapper82_chr(3) = data; break;
		case 0x7ef4: mapper82_chr(4) = data; break;
		case 0x7ef5: mapper82_chr(5) = data; break;
		case 0x7ef6: mapper82_mirror = data & 1; mapper82_a12inv = data & 2; break;
		case 0x7ef7: mapper82_ram_en(0) = (data == 0xca); break;
		case 0x7ef8: mapper82_ram_en(1) = (data == 0x69); break;
		case 0x7ef9: mapper82_ram_en(2) = (data == 0x84); break;
		case 0x7efa: mapper82_prg(0) = data >> 2; break;
		case 0x7efb: mapper82_prg(1) = data >> 2; break;
		case 0x7efc: mapper82_prg(2) = data >> 2; break;
		case 0x7efd: // unused irq latch
		case 0x7efe: // unused irq control
		case 0x7eff: // unused irq ack
			break;
	}

	mapper_map();
}

static void mapper82_map()
{
	mapper_map_prg( 8, 0, mapper82_prg(0));
	mapper_map_prg( 8, 1, mapper82_prg(1));
	mapper_map_prg( 8, 2, mapper82_prg(2));
	mapper_map_prg( 8, 3, -1);

	if (mapper82_a12inv == 0) {
		mapper_map_chr( 2, 0, (mapper82_chr(0) >> 1) & 0x7f);
		mapper_map_chr( 2, 1, (mapper82_chr(1) >> 1) & 0x7f);
		mapper_map_chr( 1, 4, mapper82_chr(2));
		mapper_map_chr( 1, 5, mapper82_chr(3));
		mapper_map_chr( 1, 6, mapper82_chr(4));
		mapper_map_chr( 1, 7, mapper82_chr(5));
	} else {
		mapper_map_chr( 2, 2, (mapper82_chr(0) >> 1) & 0x7f);
		mapper_map_chr( 2, 3, (mapper82_chr(1) >> 1) & 0x7f);
		mapper_map_chr( 1, 0, mapper82_chr(2));
		mapper_map_chr( 1, 1, mapper82_chr(3));
		mapper_map_chr( 1, 2, mapper82_chr(4));
		mapper_map_chr( 1, 3, mapper82_chr(5));
	}

	set_mirroring((mapper82_mirror) ? VERTICAL : HORIZONTAL);
}
#undef mapper82_prg
#undef mapper82_chr
#undef mapper82_mirror
#undef mapper82_a12inv
#undef mapper82_ram_en


// --[ mapper 232: Camerica (Quattro Adventure, Arcade, Sports)
static void mapper232_write(UINT16 address, UINT8 data)
{
	if (address >= 0x8000 && address <= 0xbfff) {
		mapper_regs[0] = data;
	}

	if (address >= 0xc000 && address <= 0xffff) {
		mapper_regs[1] = data;
	}

	mapper_map();
}

static void mapper232_map()
{
	UINT32 block = (mapper_regs[0] & 0x18) >> 1;
	mapper_map_prg(16, 0, block | (mapper_regs[1] & 3));
	mapper_map_prg(16, 1, block | 3);
	mapper_map_chr( 8, 0, 0);
}

// --[ mapper 77: Irem? Napoleon Senki
static void mapper77_write(UINT16 address, UINT8 data)
{
	mapper_regs[0] = data;
	mapper_map();
}

static void mapper77_map()
{
	mapper_map_prg(32, 0, mapper_regs[0] & 0x0f);
	mapper_map_chr_ramrom( 2, 0, (mapper_regs[0] >> 4) & 0x0f, MEM_ROM);
	mapper_map_chr_ramrom( 2, 1, 1, MEM_RAM);
	mapper_map_chr_ramrom( 2, 2, 2, MEM_RAM);
	mapper_map_chr_ramrom( 2, 3, 3, MEM_RAM);
}

// --[ mapper 78: Irem? (Holy Diver, Uchuusen: Cosmo Carrier)
static void mapper78_write(UINT16 address, UINT8 data)
{
	mapper_regs[0] = data;
	mapper_map();
}

static void mapper78_map()
{
	mapper_map_prg(16, 0, mapper_regs[0] & 7);
	mapper_map_prg(16, 1, -1);
	mapper_map_chr( 8, 0, mapper_regs[0] >> 4);
	if (Cart.Mirroring == 4) // Holy Diver
		set_mirroring(((mapper_regs[0] >> 3) & 1) ? VERTICAL : HORIZONTAL);
	else
		set_mirroring(((mapper_regs[0] >> 3) & 1) ? SINGLE_HIGH : SINGLE_LOW);
}

// --[ mapper 32: Irem G101 (Image Fight, Kaiketsu Yanchamaru 2, Major League, Meikyuu Jima, ...)
#define mapper32_mirror  (mapper_regs[0x1f - 0])
#define mapper32_prg(x)  (mapper_regs[0 + x])
#define mapper32_chr(x)  (mapper_regs[2 + (x)])

static void mapper32_write(UINT16 address, UINT8 data)
{
	switch (address & 0xf000) {
		case 0x8000:
			mapper32_prg(0) = data;
			break;
		case 0x9000:
			mapper32_mirror = data;
			break;
		case 0xa000:
			mapper32_prg(1) = data;
			break;
		case 0xb000:
			mapper32_chr((address & 7)) = data;
			break;
	}
	mapper_map();
}

static void mapper32_map()
{
	mapper_map_prg( 8, 0 ^ (mapper32_mirror & 2), mapper32_prg(0));
	mapper_map_prg( 8, 1, mapper32_prg(1));
	mapper_map_prg( 8, 2 ^ (mapper32_mirror & 2), -2);
	mapper_map_prg( 8, 3, -1);

	for (INT32 i = 0; i < 8; i++)
		mapper_map_chr( 1, i, mapper32_chr(i));

	if (Cart.Crc == 0xd8dfd3d1) {
		// Major League (Japan) hardwired to SINGLE_LOW
		set_mirroring(SINGLE_LOW);
	} else {
		set_mirroring((mapper32_mirror & 1) ? HORIZONTAL : VERTICAL);
	}
}

#undef mapper32_mirror
#undef mapper32_prg
#undef mapper32_chr

// --[ mapper 34: BNROM, NINA-001 (Deadly Towers, Darkseed) (Impossible Mission 2)
static void mapper34_write(UINT16 address, UINT8 data)
{
	if (address >= 0x8000) { // BNROM
		mapper_regs[0] = data;
	} else {
		switch (address) {   // NINA-001
			case 0x7ffd:
			case 0x7ffe:
			case 0x7fff:
				mapper_regs[(address & 0x3) - 1] = data;
				break;
		}
	}
	mapper_map();
}

static void mapper34_map()
{
	mapper_map_prg(32, 0, mapper_regs[0]);

	mapper_map_chr( 4, 0, mapper_regs[1]);
	mapper_map_chr( 4, 1, mapper_regs[2]);
}

// --[ mapper 87: Jaleco (Argus, Ninja JajaMaru Kun, City Connection)
static void mapper87_write(UINT16 address, UINT8 data)
{
	mapper_regs[0] = ((data >> 1) & 1) | ((data << 1) & 2);
	mapper_map();
}

static void mapper87_map()
{
	mapper_map_prg(32, 0, 0);
	mapper_map_chr( 8, 0, mapper_regs[0]);
}

// --[ mapper 88,154: Namcot (Quinty, Dragon Spirit..)
#define mapper88_cmd	(mapper_regs[0x1f - 0])
#define mapper88_mirror	(mapper_regs[0x1f - 1])
#define mapper154       (mapper_regs[0x1f - 2])

static void mapper88_write(UINT16 address, UINT8 data)
{
	switch (address & 0x8001) {
		case 0x8000:
			mapper88_cmd = data & 7;
			mapper88_mirror = (data >> 6) & 1;
			break;
		case 0x8001:
			mapper_regs[mapper88_cmd] = data;
			break;
	}

	mapper_map();
}

static void mapper88_map()
{
	mapper_map_chr( 2, 0, (mapper_regs[0] >> 1) & 0x1f);
	mapper_map_chr( 2, 1, (mapper_regs[1] >> 1) & 0x1f);

	mapper_map_chr( 1, 4, mapper_regs[2] | 0x40);
	mapper_map_chr( 1, 5, mapper_regs[3] | 0x40);
	mapper_map_chr( 1, 6, mapper_regs[4] | 0x40);
	mapper_map_chr( 1, 7, mapper_regs[5] | 0x40);

	mapper_map_prg( 8, 0, mapper_regs[6]);
	mapper_map_prg( 8, 1, mapper_regs[7]);
	mapper_map_prg( 8, 2, -2);
	mapper_map_prg( 8, 3, -1);

	if (mapper154) {
		switch (mapper88_mirror) {
			case 0: set_mirroring(SINGLE_LOW); break;
			case 1: set_mirroring(SINGLE_HIGH); break;
		}
	}
}
#undef mapper88_cmd
#undef mapper88_mirror

// --[ mapper 89: (Tenka no Goikenban: Mito Koumon)
static void mapper89_write(UINT16 address, UINT8 data)
{
	mapper_regs[0] = data;
	mapper_map();
}

static void mapper89_map()
{
	mapper_map_prg(16, 0, (mapper_regs[0] >> 4) & 7);
	mapper_map_prg(16, 1, -1);
	mapper_map_chr( 8, 0, (mapper_regs[0] & 7) | ((mapper_regs[0] >> 4) & 8));
	set_mirroring((mapper_regs[0] & 8) ? SINGLE_HIGH : SINGLE_LOW);
}

// --[ mapper 93: Sunsoft-1/2 PCB: Fantasy Zone, Shanghai
static void mapper93_write(UINT16 address, UINT8 data)
{
	mapper_regs[0] = data;
	mapper_map();
}

static void mapper93_map()
{
	mapper_map_prg(16, 0, mapper_regs[0] >> 4);
	mapper_map_prg(16, 1, -1);
	mapper_map_chr( 8, 0, 0);
}

// --[ mapper 94: Senjou no Ookami (Commando)
static void mapper94_write(UINT16 address, UINT8 data)
{
	mapper_regs[0] = data;
	mapper_map();
}

static void mapper94_map()
{
	mapper_map_prg(16, 0, mapper_regs[0] >> 2);
	mapper_map_prg(16, 1, -1);
	mapper_map_chr( 8, 0, 0);
}

// --[ mapper 97: Kaiketsu Yanchamaru
static void mapper97_write(UINT16 address, UINT8 data)
{
	mapper_regs[0] = data;
	mapper_map();
}

static void mapper97_map()
{
	mapper_map_prg(16, 0, -1);
	mapper_map_prg(16, 1, mapper_regs[0] & 0xf);
	mapper_map_chr( 8, 0, ((mapper_regs[0] >> 1) & 1) | ((mapper_regs[0] << 1) & 2));
	set_mirroring((mapper_regs[0] & 0x80) ? VERTICAL : HORIZONTAL);
}

// --[ mapper 107: (Magic Dragon)
static void mapper107_write(UINT16 address, UINT8 data)
{
	mapper_regs[0] = data;
	mapper_map();
}

static void mapper107_map()
{
	mapper_map_prg(32, 0, (mapper_regs[0] >> 1) & 3);
	mapper_map_chr( 8, 0, mapper_regs[0] & 7);
}

// --[ mapper 101: (Urusei Yatsura - Lum no Wedding Bell (Japan))
static void mapper101_write(UINT16 address, UINT8 data)
{
	mapper_regs[0] = data;
	mapper_map();
}

static void mapper101_map()
{
	mapper_map_prg(32, 0, 0);
	mapper_map_chr( 8, 0, mapper_regs[0]);
}

// --[ mapper 112: ASDER (Huang Di, ...)
#define mapper112_mirror		(mapper_regs[0x1f - 0])
#define mapper112_regnum		(mapper_regs[0x1f - 1])
#define mapper112_chrbank		(mapper_regs[0x1f - 2])

static void mapper112_write(UINT16 address, UINT8 data)
{
	switch (address & 0xe001) {
		case 0x8000: mapper112_regnum = data & 7; break;
		case 0xa000: mapper_regs[mapper112_regnum] = data; break;
		case 0xc000: mapper112_chrbank = data; break;
		case 0xe000: mapper112_mirror = data & 1; break;
	}

	mapper_map();
}

static void mapper112_map()
{
	mapper_map_prg( 8, 0, mapper_regs[0]);
	mapper_map_prg( 8, 1, mapper_regs[1]);

	mapper_map_chr( 2, 0, mapper_regs[2] >> 1);
	mapper_map_chr( 2, 1, mapper_regs[3] >> 1);

	mapper_map_chr( 1, 4, ((mapper112_chrbank & 0x10) << 4) | mapper_regs[4]);
	mapper_map_chr( 1, 5, ((mapper112_chrbank & 0x20) << 3) | mapper_regs[5]);
	mapper_map_chr( 1, 6, ((mapper112_chrbank & 0x40) << 2) | mapper_regs[6]);
	mapper_map_chr( 1, 7, ((mapper112_chrbank & 0x80) << 1) | mapper_regs[7]);

	set_mirroring(mapper112_mirror ? HORIZONTAL : VERTICAL);
}

// --[ mapper 113 NINA-03/NINA-06 ext. (Papillon Gals) / Mojon Twins Multicart
static void mapper113_write(UINT16 address, UINT8 data)
{
	mapper_regs[0] = data;
	mapper_map();
}

static void mapper113_map()
{
	mapper_map_prg(32, 0, (mapper_regs[0] >> 3) & 7);
	mapper_map_chr( 8, 0, ((mapper_regs[0] >> 3) & 8) | (mapper_regs[0] & 7));
	set_mirroring((mapper_regs[0] & 0x80) ? VERTICAL : HORIZONTAL);
}

// --[ mapper 79, 146: NINA-03/NINA-06 (Death Bots), Sachen (146 / Metal Fighter)
static void mapper79_write(UINT16 address, UINT8 data)
{
	mapper_regs[0] = data;
	mapper_map();
}

static void mapper79_map()
{
	mapper_map_prg(32, 0, (mapper_regs[0] >> 3) & 1);
	mapper_map_chr( 8, 0, (mapper_regs[0] & 7));
}

// --[ mapper 137, 138, 139, 141: Sachen 8259x (Super Pang, etc)
static void mapper8259_write(UINT16 address, UINT8 data)
{
	if (address < 0x4100) return;

	if ((address & 0x4101) == 0x4100) {
		mapper_regs[8] = data; // command
	} else {
		mapper_regs[mapper_regs[8] & 7] = data;
		mapper_map();
	}
}

static void mapper8259_map()
{
	mapper_map_prg(32, 0, mapper_regs[5] & 7);

	if (Cart.CHRRomSize != 0) {
		for (INT32 i = 0; i < 4; i++) {
			INT32 bank = 0;

			if (mapper_regs[7] & 1)
				bank = (mapper_regs[0] & 7) | ((mapper_regs[4] & 7) << 3);
			else
				bank = (mapper_regs[i] & 7) | ((mapper_regs[4] & 7) << 3);

			switch (mapper_regs[0x1f]) {
				case 137:                         // 137 8259D
					bank = mapper_regs[i] & 7;
					switch (i & 3) {
						case 1:
							bank |= (mapper_regs[4] & 1) << 4;
							break;
						case 2:
							bank |= (mapper_regs[4] & 2) << 3;
							break;
						case 3:
							bank |= ((mapper_regs[4] & 4) << 2) | ((mapper_regs[6] & 1) << 3);
							break;
					}
					mapper_map_chr( 1, i, bank);
					mapper_map_chr( 4, 1, -1);
					break;
				case 138:                         // 138 8259B
					mapper_map_chr( 2, i, bank);
					break;
				case 139:
					bank = (bank << 2) | (i & 3); // 139 8259C
					mapper_map_chr( 2, i, bank);
					break;
				case 141:
					bank = (bank << 1) | (i & 1); // 141 8259A
					mapper_map_chr( 2, i, bank);
					break;
			}
		}
	}

	if (mapper_regs[7] & 1) {
		set_mirroring(VERTICAL);
	} else {
		switch ((mapper_regs[7] >> 1) & 3) {
			case 0: set_mirroring(VERTICAL); break;
			case 1: set_mirroring(HORIZONTAL); break;
			case 2: set_mirroring(SACHEN); break;
			case 3: set_mirroring(SINGLE_LOW); break;
		}
	}
}

// --[ mapper 150: Sachen 74LS374XX (Tasac)
#define mapper150_cmd       (mapper_regs[0x1f - 0])
#define mapper150_prg       (mapper_regs[0x1f - 1])

static void mapper150_write(UINT16 address, UINT8 data)
{
	switch (address & 0xc101) {
		case 0x4100:
			mapper150_cmd = data & 0x7;
			break;
		case 0x4101:
			switch (mapper150_cmd) {
				case 2:
					mapper150_prg = data & 1;
					break;
				case 5:
					mapper150_prg = data & 7;
					break;
				default:
					mapper_regs[mapper150_cmd] = data;
					break;
			}
			mapper_map();
			break;
	}
}

static UINT8 mapper150_read(UINT16 address)
{
	if ((address & 0xc101) == 0x4000) {
		return (~mapper150_cmd) ^ 1; // '1' (or 0) is switch for Sachen / Sachen Hacker
	}

	return 0;
}

static void mapper150_map()
{
	mapper_map_prg(32, 0, mapper150_prg);

	mapper_map_chr( 8, 0, ((mapper_regs[2] & 0x1) << 3) | ((mapper_regs[4] & 0x1) << 2) | (mapper_regs[6] & 0x03));

	switch ((mapper_regs[7] >> 1) & 3) {
		case 0: set_mirroring(VERTICAL); break;
		case 1: set_mirroring(HORIZONTAL); break;
		case 2: set_mirroring(SACHEN); break;
		case 3: set_mirroring(SINGLE_LOW); break;
	}
}

// ---[ mapper 162 Zelda Triforce of the Gods
#define mapper162_reg(x)			(mapper_regs[0x00 + (x)])

static void mapper162_write(UINT16 address, UINT8 data)
{
	if (address >= 0x5000 && address <= 0x5fff) {
		mapper162_reg((address >> 8) & 0x03) = data;

		mapper_map();
	}
}

static void mapper162_map()
{
	switch (mapper162_reg(3) & 0x05) {
		case 0:
			mapper_map_prg(32, 0, (mapper162_reg(1) & 0x02) | ((mapper162_reg(2) & 0x0f) << 4) | (mapper162_reg(0) & 0x0c));
			break;
		case 1:
			mapper_map_prg(32, 0, ((mapper162_reg(2) & 0x0f) << 4) | (mapper162_reg(0) & 0x0c));
			break;
		case 4:
			mapper_map_prg(32, 0, ((mapper162_reg(1) & 0x02) >> 1) | ((mapper162_reg(2) & 0x0f) << 4) | (mapper162_reg(0) & 0x0e));
			break;
		case 5:
			mapper_map_prg(32, 0, ((mapper162_reg(2) & 0x0f) << 4) | (mapper162_reg(0) & 0x0f));
			break;
	}
}

// ---[ mapper 163 Final Fantasy VII (NJ063) + Advent Children ver. (&etc.)
#define mapper163_reg(x)			(mapper_regs[0x00 + (x)])
#define mapper163_chr(x)			(mapper_regs[0x08 + (x)])
#define mapper163_prg				(mapper_regs[0x1f - 0])
#define mapper163_prot_flip			(mapper_regs[0x1f - 1])
#define mapper163_raster_split		(mapper_regs[0x1f - 2])

static UINT8 mapper163_read(UINT16 address)
{
	switch (address & 0x7700) {
		case 0x5100:
			return mapper163_reg(3) | mapper163_reg(1) | mapper163_reg(0) | (mapper163_reg(2) ^ 0xff);
		case 0x5500:
			return (mapper163_prot_flip == 0) ? (mapper163_reg(3) | mapper163_reg(0)) : 0;
	}

	return 0x4;
}

static void mapper163_write(UINT16 address, UINT8 data)
{
	if ((address & 0xf000) == 0x5000) {
		if (address == 0x5101) {
			if (mapper163_reg(4) != 0 && data == 0) {
				mapper163_prot_flip ^= 1;
			}
			mapper163_reg(4) = data;
		} else if (address == 0x5100 && data == 0x6) {
			mapper163_prg = 0x3;
		} else {
			switch (address & 0x7300) {
				case 0x5000:
					mapper163_reg(0) = data;
					if (!(data & 0x80) && scanline < 128) {
						mapper163_chr(0) = 0;
						mapper163_chr(1) = 1;
					}
					mapper163_raster_split = data & 0x80;
					mapper163_prg = (mapper163_reg(0) & 0xf) | ((mapper163_reg(2) & 0xf) << 4);
					break;
				case 0x5100:
					mapper163_reg(1) = data;
					if (data == 0x6) {
						mapper163_prg = 3;
					}
					break;
				case 0x5200:
					mapper163_reg(2) = data;
					mapper163_prg = (mapper163_reg(0) & 0xf) | ((mapper163_reg(2) & 0xf) << 4);
					break;
				case 0x5300:
					mapper163_reg(3) = data;
					break;
			}
		}
		mapper_map();
	}
}

static void mapper163_map()
{
	mapper_map_prg(32, 0, mapper163_prg);
	mapper_map_chr(4, 0, mapper163_chr(0));
	mapper_map_chr(4, 1, mapper163_chr(1));
}

static void mapper163_cycle(UINT16 address)
{
	static INT32 last_127 = 0;
	static INT32 last_239 = 0;

	if (mapper163_raster_split && pixel > 257) {
		switch (scanline) {
			case 127:
				if (nCurrentFrame != last_127) {
					mapper_map_chr(4, 0, 1);
					mapper_map_chr(4, 1, 1);
					mapper163_chr(0) = 1;
					mapper163_chr(1) = 1;
				}
				last_127 = nCurrentFrame;
				break;
			case 239:
				if (nCurrentFrame != last_239) {
					mapper_map_chr(4, 0, 0);
					mapper_map_chr(4, 1, 0);
					mapper163_chr(0) = 0;
					mapper163_chr(1) = 0;
				}
				last_239 = nCurrentFrame;
				break;
		}
	}
}

#undef mapper163_reg
#undef mapper163_prg
#undef mapper163_chr
#undef mapper163_prot_flip
#undef mapper163_raster_split

// --[ mapper 38: (Crime Busters)
static void mapper38_write(UINT16 address, UINT8 data)
{
	mapper_regs[0] = data;
	mapper_map();
}

static void mapper38_map()
{
	mapper_map_prg(32, 0, mapper_regs[0] & 0x3);
	mapper_map_chr( 8, 0, (mapper_regs[0] >> 2) & 0x3);
}

// --[ mapper 66,140: (Bio Senshi Dan: Increaser tono Tatakai, Youkai Club, ..)
static void mapper140_write(UINT16 address, UINT8 data)
{
	mapper_regs[0] = data;
	mapper_map();
}

static void mapper140_map()
{
	mapper_map_prg(32, 0, mapper_regs[0] >> 4);
	mapper_map_chr( 8, 0, mapper_regs[0] & 0xf);
}

// --[ mapper 11, 144: ColorDreams, Death Race(144)
static void mapper11_write(UINT16 address, UINT8 data)
{
	mapper_regs[0] = data;
	mapper_map();
}

static void mapper144_write(UINT16 address, UINT8 data)
{
	if (address >= 0x8001) {
		mapper_regs[0] = data;
		mapper_map();
	}
}

static void mapper11_map()
{
	mapper_map_prg(32, 0, mapper_regs[0] & 0xf);
	mapper_map_chr( 8, 0, mapper_regs[0] >> 4);
}

// --[ mapper 471: haratyler, haraforce
static void mapper471_write(UINT16 address, UINT8 data)
{
	if (address & 0x8000) {
		mapper_regs[0] = address & 1;

		M6502SetIRQLine(0, CPU_IRQSTATUS_NONE);

		mapper_map();
	}
}

static void mapper471_map()
{
	mapper_map_prg(32, 0, mapper_regs[0] & 0x1);
	mapper_map_chr( 8, 0, mapper_regs[0] & 0x1);
}

static void mapper471_scanline()
{
	mapper_irq(0);
}

// --[ mapper 152: (Arkanoid II, Pocket Zaurus: Juu Ouken no Nazo, ...)
static void mapper152_write(UINT16 address, UINT8 data)
{
	mapper_regs[0] = data;
	mapper_map();
}

static void mapper152_map()
{
	mapper_map_prg(16, 0, (mapper_regs[0] >> 4) & 7);
	mapper_map_prg(16, 1, -1);
	mapper_map_chr( 8, 0, mapper_regs[0] & 0xf);
	set_mirroring((mapper_regs[0] & 0x80) ? SINGLE_HIGH : SINGLE_LOW);
}

// --[ mapper 156: Open (Metal Force, Buzz & Waldog, Koko Adv., Janggun-ui Adeul)
#define mapper156_chr_lo(x)     (mapper_regs[0 + (x)])  // x = 0 - 7
#define mapper156_chr_hi(x)     (mapper_regs[8 + (x)])  // x = 0 - 7
#define mapper156_prg           (mapper_regs[0x1f - 0])
#define mapper156_mirror        (mapper_regs[0x1f - 1])

static void mapper156_write(UINT16 address, UINT8 data)
{
	switch (address) {
		case 0xc000:
		case 0xc001:
		case 0xc002:
		case 0xc003:
		case 0xc008:
		case 0xc009:
		case 0xc00a:
		case 0xc00b:
			mapper156_chr_lo((address & 0x3) | ((address & 0x8) >> 1)) = data;
			break;
		case 0xc004:
		case 0xc005:
		case 0xc006:
		case 0xc007:
		case 0xc00c:
		case 0xc00d:
		case 0xc00e:
		case 0xc00f:
			mapper156_chr_hi((address & 0x3) | ((address & 0x8) >> 1)) = data;
			break;
		case 0xc010:
			mapper156_prg = data;
			break;
		case 0xc014:
			mapper156_mirror = 0x10 | (data & 1);
			break;
	}

	mapper_map();
}

static void mapper156_map()
{
	mapper_map_prg(16, 0, mapper156_prg);
	mapper_map_prg(16, 1, -1);

	for (INT32 i = 0; i < 8; i++) {
		mapper_map_chr( 1, i, (mapper156_chr_hi(i) << 8) | mapper156_chr_lo(i));
	}

	switch (mapper156_mirror) {
		case 0: set_mirroring(SINGLE_LOW); break;
		case 0x10: set_mirroring(VERTICAL); break;
		case 0x11: set_mirroring(HORIZONTAL); break;
	}
}

// --[ mapper 180: Crazy Climber
static void mapper180_write(UINT16 address, UINT8 data)
{
	mapper_regs[0] = data;
	mapper_map();
}

static void mapper180_map()
{
	mapper_map_prg(16, 0, 0);
	mapper_map_prg(16, 1, mapper_regs[0] & 0x7);
	mapper_map_chr( 8, 0, 0);
}

// --[ mapper 184: Atlantis no Nazo, Kanshakudama Nage Kantarou no Toukaidou Gojuusan Tsugi, Wing of Madoola
static void mapper184_write(UINT16 address, UINT8 data)
{
	mapper_regs[0] = data;
	mapper_map();
}

static void mapper184_map()
{
	mapper_map_prg(32, 0, 0);
	mapper_map_chr( 4, 0, mapper_regs[0] & 0xf);
	mapper_map_chr( 4, 1, mapper_regs[0] >> 4);
}

// --[ mapper 185 CNROM+prot
static void mapper185_write(UINT16 address, UINT8 data)
{
	if (address & 0x8000) {
		mapper_regs[0] = data;
		mapper_map();
	}
}

static void mapper185_map()
{
	if ( (mapper_regs[0] & 3) && (mapper_regs[0] != 0x13) ) { // map rom
		mapper_map_chr_ramrom( 8, 0, 0, MEM_ROM);
	} else { // map ram
		mapper_map_chr_ramrom( 8, 0, 0, MEM_RAM);
	}
}

// --[ end mappers

static void mapper_reset()
{
	mapper_init(Cart.Mapper);
}

static void mapper_scan(INT32 nAction, INT32 *pnMin)
{
	SCAN_VAR(PRGMap);
	SCAN_VAR(CHRMap);
	SCAN_VAR(CHRType);
	SCAN_VAR(PRGExpMap);

	SCAN_VAR(mapper_regs);
	SCAN_VAR(mapper_regs16);
	SCAN_VAR(mapper_irq_exec);

	if (mapper_scan_cb) {
		mapper_scan_cb();
	}

	if (nAction & ACB_WRITE) {
		if (mapper_map) mapper_map();
	}
}

static INT32 mapper_init(INT32 mappernum)
{
	INT32 retval = -1;

	if (NESMode & MAPPER_NOCLEAR && RESETMode == RESET_BUTTON) {
		// do nothing! certain mappers need regs preserved on RESET_BUTTON
	} else {
		memset(mapper_regs, 0, sizeof(mapper_regs));
		memset(mapper_regs16, 0, sizeof(mapper_regs16));
	}

	mapper_write = NULL; // 8000 - ffff
	mapper_map = NULL;
	mapper_scanline = NULL; // scanline cb
	mapper_cycle = NULL; // cycle cb (1x per cycle)
	mapper_ppu_clock = NULL; // called after busaddress change (see mapper09) (only in visible & prerender!)
	mapper_ppu_clockall = NULL; // called every ppu clock
	mapper_scan_cb = NULL; // savestate cb (see vrc6)
	mapper_scan_cb_nvram = NULL; // savestate cb (nvram)

	mapper_prg_read = mapper_prg_read_int; // 8000-ffff (read)

	PRGExpMap = 0;
	cart_exp_write = NULL; // 6000 - 7fff
	cart_exp_read = NULL;

	psg_area_write = NULL; // 4020 - 5fff
	psg_area_read = NULL;

	bprintf(0, _T("Mapper #%d init/reset!\n"), mappernum);

	switch (mappernum) {
		case 0x808: { // Famicom Disk System
			NESMode |= MAPPER_NOCLEAR; // preserve mapper regs on soft-reset
			mapper_map_prg(32, 0, 0);
			mapper_map_chr( 8, 0, 0);
			psg_area_write = mapperFDS_write; // 4000 - 5fff
			psg_area_read = mapperFDS_read;
			mapper_write = mapperFDS_prg_write; // 8000 - ffff
			mapper_cycle = mapperFDS_cycle;
			mapper_map   = mapperFDS_map;
			nes_ext_sound_cb = mapperFDS_mixer;
			mapper_scan_cb  = mapperFDS_scan;

			BurnLEDInit(1, LED_POSITION_BOTTOM_RIGHT, LED_SIZE_4x4, LED_COLOR_GREEN, 80);

			mapperFDS_reset();
			mapper_map();
			retval = 0;
			break;
		}

		case 400: { // 8 Bit X-Mas 2017 (RET-X7-GBL)
			cart_exp_write  = mapper400_write;  // 6000 - 7fff
			mapper_write    = mapper400_write;  // 8000 - ffff
			mapper_map      = mapper400_map;

			mapper_regs[0] = 0x80; // default

			mapper_map();
			retval = 0;
			break;
		}

		case 413: { // Super Russian Roulette (BATLAB-SRR-X PCB)
			psg_area_read   = mapper413_psg_read;  // 4000 - 5fff
			cart_exp_read   = mapper413_exp_read;  // 6000 - 7fff
			mapper_prg_read = mapper413_prg_read;  // 8000 - ffff
			mapper_write    = mapper413_prg_write; // 8000 - ffff
			mapper_scanline = mapper413_scanline;
			mapper_map      = mapper413_map;

			mapper_map();
			retval = 0;
			break;
		}

		case 0: { // no mapper
			mapper_map_prg(32, 0, 0);
			mapper_map_chr( 8, 0, 0);
			retval = 0;
			break;
		}

		case 155: // 155 is mmc1 w/wram always mapped @ 6000-7fff
		case 1: { // mmc1
			if (mappernum != 155) {
				cart_exp_write = mapper01_exp_write; // 6000 - 7fff
				cart_exp_read = mapper01_exp_read;
			}
			mapper_write = mapper01_write;
			mapper_map   = mapper01_map;
			mapper_regs[0] = 0xc;
			mapper_map();
			retval = 0;
			break;
		}

		case 2: { // UxROM
			mapper_write = mapper02_write;
			mapper_map   = mapper02_map;
			mapper_map();
			retval = 0;
			break;
		}

		case 15: { // Contra 168-in-1 Multicart
			mapper_write = mapper15_write;
			mapper_map   = mapper15_map;
			mapper_map();
			retval = 0;
			break;
		}

		case 190: { // Magic Kid Googoo
			mapper_write = mapper190_write;
			mapper_map   = mapper190_map;
			mapper_map();
			retval = 0;
			break;
		}

		case 193: { // NTDEC TC-112 (War in the Gulf, Fighting Hero, ..)
			cart_exp_write = mapper193_write;
			mapper_map   = mapper193_map;
			mapper_map();
			retval = 0;
			break;
		}

		case 41: { // Caltron 6-in-1
			cart_exp_write = mapper41_write;
			mapper_write = mapper41_write;
			mapper_map   = mapper41_map;
			mapper_map();
			retval = 0;
			break;
		}

		case 53: { // SuperVision 16-in-1
			NESMode |= MAPPER_NOCLEAR; // preserve mapper regs on soft-reset
			cart_exp_read = mapper53_exp_read;
			cart_exp_write = mapper53_write;
			mapper_write = mapper53_write;
			mapper_map   = mapper53_map;
			mapper_map();
			retval = 0;
			break;
		}

		case 104: { // Golden Five / Pegasus 5-in-1
			mapper_write = mapper104_write;
			mapper_map   = mapper104_map;
			mapper_map();
			retval = 0;
			break;
		}

		case 389: { // Caltron 9-in-1
			mapper_write = mapper389_write;
			mapper_map   = mapper389_map;
			mapper_map();
			retval = 0;
			break;
		}

		case 216: { // Magic Jewelry 2
			mapper_write = mapper216_write;
			mapper_map   = mapper216_map;
			psg_area_read = mapper216_read;
			mapper_map();
			retval = 0;
			break;
		}

		case 132: { // Qi Wang
			mapper_write = mapper132_write;
			mapper_map   = mapper132_map;
			psg_area_read = mapper132_read;
			psg_area_write = mapper132_write;
			mapper_map();
			retval = 0;
			break;
		}

		case 3: { // CNROM
			mapper_write = mapper03_write;
			mapper_map   = mapper03_map;
			if (Cart.Crc == 0xab29ab28) // dropzone
				mapper_cycle = mapper03_cycle;
			mapper_map_prg(32, 0, 0);
			mapper_map();
			retval = 0;
			break;
		}

		case 5: { // MMC5
			cart_exp_write = mapper5_exp_write; // 6000 - 7fff
			cart_exp_read = mapper5_exp_read;
			psg_area_write = mapper5_write; // 4000 - 5fff
			psg_area_read = mapper5_read;
			mapper_write = mapper5_prg_write; // 8000 - ffff
			mapper_map   = mapper5_map;
			mapper_scan_cb  = mapper5_scan;
			mapper_ppu_clockall = mapper5_ppu_clk;
			nes_ext_sound_cb = mapper5_mixer;

			read_nt = &mapper5_ntread;
			write_nt = &mapper5_ntwrite;

			mapper5_reset();

			mapper_map();
			retval = 0;
			break;
		}

		case 7: { // AxROM: Battle Toads, Marble Madness, RC Pro-Am
			mapper_write = mapper07_write;
			mapper_map   = mapper07_map;
		    mapper_map_chr( 8, 0, 0);
			mapper_map();
			retval = 0;
			break;
		}

		case 9: { // mmc2: punch out!
			mapper_write = mapper09_write;
			mapper_map   = mapper09_map;
			mapper_ppu_clock = mapper09_ppu_clk;
			mapper_map_prg( 8, 1, -3);
			mapper_map_prg( 8, 2, -2);
			mapper_map_prg( 8, 3, -1);
			mapper_map();
			retval = 0;
			break;
		}

		case 10: { // mmc4: fire emblem (mmc2 + sram + different prg mapping)
			mapper_write = mapper09_write;
			mapper_map   = mapper10_map;
			mapper_ppu_clock = mapper10_ppu_clk;
			mapper_map();
			retval = 0;
			break;
		}

		case 99: {
			mapper_map = mapper99_map;
			mapper_map();
			if (Cart.Crc == 0x84ad422e) {
				bprintf(0, _T("Patching: VS. Raid on Bungling Bay...\n"));
				// VS. Raid on Bungling Bay patch
				bprintf(0, _T("%02x %02x %02x\n"), Cart.PRGRom[0x16df], Cart.PRGRom[0x16e0], Cart.PRGRom[0x16e1]);
				Cart.PRGRom[0x16df] = 0xea; // game stuck in loop @ 96df - possibly waiting for second cpu?
				Cart.PRGRom[0x16e0] = 0xea;
				Cart.PRGRom[0x16e1] = 0xea;

				nesapuSetMode4017(0x00); // enable frame-irq
			}

			retval = 0;
			break;
		}

		case 13: {
			mapper_write = mapper13_write;
			mapper_map = mapper13_map;
			mapper_map_prg(32, 0, 0);
			mapper_map();
			retval = 0;
			break;
		}

		case 133: {
			psg_area_write = mapper133_write;
			mapper_map = mapper133_map;
			mapper_map_prg(32, 0, 0);
			mapper_map();
			retval = 0;
			break;
		}

		case 159: // 128byte eeprom
		case 16: // 256byte eeprom
			{ // Bandai fcg
			mapper_write = mapper16_write;
			cart_exp_write = mapper16_write;
			mapper_map   = mapper16_map;
			mapper_cycle = mapper16_cycle;
			mapper_map();
			retval = 0;
			break;
		}

		case 153: { // Bandai fcg (Famicom Jump II)
			mapper_write = mapper16_write;
			mapper_map   = mapper153_map;
			mapper_cycle = mapper16_cycle;
			mapper_map();
			retval = 0;
			break;
		}

		case 18: { // Jaleco (Magical John, Pizza Pop, etc)
			mapper_write = mapper18_write;
			mapper_map   = mapper18_map;
			mapper_cycle = mapper18_cycle;
			mapper_map();
			retval = 0;
			break;
		}

		case 210:
		case 19: { // Namco n106/163
			psg_area_read  = mapper19_read;
			psg_area_write = mapper19_write; // 4020 - 5fff
			mapper_write = mapper19_write; // 8000 - ffff
			mapper_map   = mapper19_map;
			mapper_cycle = mapper19_cycle;
			nes_ext_sound_cb = mapper19_mixer;
			mapper_scan_cb = mapper19_scan;
			mapper19_mapper210 = (mappernum == 210);

			//waygan 2  0x8aa76b0b   wagyan 3 0x7aff2388  splatterh 0xb7eeb48b
			if (Cart.Crc == 0x8aa76b0b || Cart.Crc == 0x7aff2388 || Cart.Crc == 0xb7eeb48b) {
				mapper19_mapper210 = 2; // namco 340 (210 submapper 2)
				bprintf(0, _T("Namco 210 submapper 2 (Namco 340)\n"));
			}

			mapper19_reset();
			mapper_map();
			retval = 0;
			break;
		}

		case 21: { // vrc2
			mapper_write = mapper21_write;
			mapper_map   = vrc2vrc4_map;
			mapper_cycle = vrc2vrc4_cycle;
			mapper_map();
			retval = 0;
			break;
		}

		case 22: { // vrc2
			mapper_write = mapper22_write;
			mapper_map   = vrc2vrc4_map;
			vrc2and4_ines22 = 1;
			mapper_map();
			retval = 0;
			break;
		}

		case 23: { // vrc4
			mapper_write = mapper23_write;
			mapper_map   = vrc2vrc4_map;
			mapper_cycle = vrc2vrc4_cycle;
			mapper_map();
			retval = 0;
			break;
		}

		case 25: { // vrc4
			mapper_write = mapper22_write;
			mapper_map   = vrc2vrc4_map;
			mapper_cycle = vrc2vrc4_cycle;
			mapper_map();
			retval = 0;
			break;
		}

		case 24: { // vrc6
			mapper_write = vrc6_write;
			mapper_map   = vrc6_map;
			mapper_cycle = vrc6_cycle;
			vrc6_reset();
			mapper_map();
			nes_ext_sound_cb = vrc6_mixer; // vrc6 sound
			mapper_scan_cb = vrc6_scan;
			retval = 0;
			break;
		}

		case 26: { // vrc6
			mapper_write = vrc6_write;
			mapper_map   = vrc6_map;
			mapper_cycle = vrc6_cycle;
			mapper26 = 1;
			vrc6_reset();
			mapper_map();
			nes_ext_sound_cb = vrc6_mixer; // vrc6 sound
			mapper_scan_cb = vrc6_scan;
			retval = 0;
			break;
		}

		case 227: { // xxx-in-1, Waixing Bio Hazard
			mapper_write = mapper227_write;
			mapper_map   = mapper227_map;
			mapper_map();
			retval = 0;
			break;
		}

		case 172: { // 1991 Du Ma Racing
			psg_area_write = mapper172_write;	// 4020 - 5fff
			psg_area_read = mapper172_read;		// 4020 - 5fff
			mapper_write = mapper172_write;
			mapper_map   = mapper172_map;
			mapper_map();
			retval = 0;
			break;
		}

		case 228: { // Action 52, Cheetah Men II
			mapper_write = mapper228_write;
			psg_area_write = mapper228_psg_write;
			psg_area_read = mapper228_psg_read;
			mapper_map   = mapper228_map;
			mapper_map();
			retval = 0;
			break;
		}

		case 91: { // Older JY Company/Hummer
			cart_exp_write = mapper91_write; // 6000 - 7fff
			mapper_map = mapper91_map;
			mapper_scanline = mapper91_scanline;
			mapper_map();
			retval = 0;
			break;
		}

		case 17: { // Front Far East FFE SMC (Type 17)
			psg_area_write = mapper17_write; // 4020 - 5fff
			mapper_map = mapper17_map;
			mapper_cycle = mapper17_cycle;
			mapper_regs[0] = ~3;
			mapper_regs[1] = ~2;
			mapper_regs[2] = ~1;
			mapper_regs[3] = ~0;
			mapper_map();
			retval = 0;
			break;
		}

		case 211: mapper90_211 = 1;
		case 209: mapper90_209 = 1;
		case 90: { // JY Company
			mapper_write = mapper90_write;       // 8000 - ffff
			psg_area_write = mapper90_psg_write; // 4020 - 5fff
			psg_area_read = mapper90_psg_read;
			cart_exp_write = mapper90_exp_write; // 6000 - 7fff
			cart_exp_read = mapper90_exp_read;

			mapper_scanline = mapper90_scanline;
			mapper_cycle = mapper90_cycle;
			mapper_ppu_clockall = mapper90_ppu_clock; // irq
			if (mapper90_209) {
				read_nt = &mapper90_ntread;
			}

			mapper_map   = mapper90_map;

			// mapper defaults
			mapper90_mul0 = 0xff;
			mapper90_mul1 = 0xff;
			mapper90_accu = 0xff;
			mapper90_testreg = 0xff;
			mapper90_chrlatch(0) = 0;
			mapper90_chrlatch(1) = 4;

			mapper_map();
			retval = 0;
			break;
		}

		case 28: { // Action53 / Home-brew multicart
			mapper_write   = mapper28_write;
			psg_area_write = mapper28_write;
			mapper_map     = mapper28_map;
			//mapper_map()
			NESMode |= MAPPER_NOCLEAR; // preserve mapper regs on soft-reset
			if (RESETMode == RESET_POWER)
				mapper_map_prg(16, 1, -1);
			retval = 0;
			break;
		}

		case 30: { // UNROM-512
			flashrom_chiptype = MC_SST;

			mapper_prg_read = flashrom_read;
			mapper_write = mapper30_write;
			mapper_map   = mapper30_map;
			switch (rom[6] & (1|8)) {
				case 0: set_mirroring(HORIZONTAL); break;
				case 1: set_mirroring(VERTICAL); break;
				case 8: set_mirroring(SINGLE_LOW); mapper30_mirroring_en = 1; break;
				case 9: set_mirroring(FOUR_SCREEN); break;
			}
			mapper_map();
			retval = 0;
			break;
		}

		case 33: { // Taito TC0190
			mapper_write = mapper33_write;
			mapper_map   = mapper33_map;
			mapper_map();
			retval = 0;
			break;
		}

		case 36: { // TXC (Policeman, Strike Wolf)
			psg_area_read  = mapper36_read;
			psg_area_write = mapper36_write;
			mapper_write   = mapper36_write;
			mapper_map     = mapper36_map;
			mapper_map();
			retval = 0;
			break;
		}

		case 42: { // Ai Senshi Nicol FDS Conversion
			mapper_write = mapper42_write;
			mapper_map   = mapper42_map;
			mapper_cycle = mapper42_cycle;
			cart_exp_read = mapper42_exp_read;
			mapper_map();
			retval = 0;
			break;
		}

		case 108: { // Meikyuu Jiin Dababa FDS conversion
			mapper_write = mapper108_write;
			psg_area_write = mapper108_write; // just to silent debug msgs
			mapper_map   = mapper108_map;
			cart_exp_read = mapper108_exp_read;
			mapper_map();
			retval = 0;
			break;
		}

		case 111: { // Cheapocabra (GTROM)
			cart_exp_write = mapper111_write;
			psg_area_write = mapper111_write;
			mapper_map   = mapper111_map;
			mapper_map();
			retval = 0;
			break;
		}

		case 120: { // Tobidase Daisakusen FDS Conversion - garbage! (game crashes after lv1)
			psg_area_write = mapper120_write;
			mapper_map   = mapper120_map;
			cart_exp_read = mapper120_exp_read;
			mapper_map();
			retval = 0;
			break;
		}

		case 48: { // Taito TC0690
			mapper_write = mapper33_write;
			mapper_map   = mapper33_map;
			mapper_scanline = mapper33_scanline;
			mapper48 = 1;
			mapper48_flintstones = (Cart.Crc == 0x12f38740);
			bprintf(0, _T("mapper48 - flintstones? %x\n"), mapper48_flintstones);
			mapper_map();
			retval = 0;
			break;
		}

		case 185: { // CNROM + prot
			mapper_write = mapper185_write;
			mapper_map   = mapper185_map;
			memset(Cart.CHRRam, 0xff, Cart.CHRRamSize);
			mapper_map_prg(32, 0, 0);
			mapper_map();
			retval = 0;
			break;
		}

		case 32: { // Irem G101
			mapper_write = mapper32_write;
			mapper_map = mapper32_map;
			mapper_map();
			retval = 0;
			break;
		}

		case 34: { // BNROM/NINA-001
			mapper_write = mapper34_write;
			cart_exp_write = mapper34_write;
			mapper_map = mapper34_map;
			mapper_regs[1] = 0; // defaults to retain compatibility with BNROM
			mapper_regs[2] = 1;
			mapper_map();
			retval = 0;
			break;
		}

		case 65: { // Irem h3001
			mapper_write = mapper65_write;
			mapper_map = mapper65_map;
			mapper_cycle = mapper65_cycle;
			mapper_regs[2] = -2;
			mapper_map_prg( 8, 3, -1);
			mapper_map();
			retval = 0;
			break;
		}

		case 67: { // Sunsoft-3
			mapper_write = mapper67_write;
			mapper_map = mapper67_map;
			mapper_cycle = mapper67_cycle;
			mapper_map();
			retval = 0;
			break;
		}

		case 68: { // Sunsoft-4
			mapper_write = mapper68_write;
			mapper_map = mapper68_map;
			mapper_cycle = mapper68_cycle;
			cart_exp_read = mapper68_exp_read;
			cart_exp_write = mapper68_exp_write;
			mapper_map();
			retval = 0;
			break;
		}

		case 64: { // Tengen RAMBO-1
			mapper_write = mapper64_write;
			mapper_map   = mapper64_map;
			mapper_scanline = mapper64_scanline;
			mapper_cycle = mapper64_cycle;
			mapper_map_prg( 8, 3, -1);
		    mapper_map();
			retval = 0;
			break;
		}

		case 69: { // sunsoft
			mapper_write = mapper69_write;
			mapper_map   = mapper69_map;
			mapper_cycle = mapper69_cycle;
			cart_exp_read = mapper69_exp_read;
			cart_exp_write = mapper69_exp_write;
			mapper_map();
			AY8910Reset(0);
			retval = 0;
			break;
		}

		case 70: {
			mapper_write = mapper70_write; // 8000 - ffff
			mapper_map   = mapper70_map;
		    mapper_map();
			retval = 0;
			break;
		}

		case 71: { // camerica (codemasters) misc
			mapper_write = mapper71_write; // 8000 - ffff
			mapper_map   = mapper71_map;
		    mapper_map();
			if (Cart.Crc == 0xa64e926a && Cart.PRGRom[0xc4c1] == 0xa5) {
				bprintf(0, _T("Applied Hot-Patch: Quattro Sports / BMX Simulator start fix..\n"));
				Cart.PRGRom[0xc4c1] = 0xa9; // make ctrlr-debounce read happy
			}
			retval = 0;
			break;
		}

		case 73: { // Konami vrc3 (Salamander)
			mapper_write = mapper73_write;
			mapper_map   = mapper73_map;
			mapper_cycle = mapper73_cycle;
		    mapper_map();
			retval = 0;
			break;
		}

		case 75: { // Konami vrc1
			mapper_write = mapper75_write; // 8000 - ffff
			mapper_map   = mapper75_map;
		    mapper_map();
			retval = 0;
			break;
		}

		case 85: { // Konami vrc7 (Lagrange Point, Tiny Toons Adventures 2 (Japan))
			mapper_write = vrc7_write;
			mapper_map   = vrc7_map;
			mapper_cycle = vrc7_cycle;
			BurnYM2413VRC7Reset();
		    mapper_map();
			retval = 0;
			break;
		}

		case 232: { // camerica (codemasters) quattro
			mapper_write = mapper232_write;
			mapper_map   = mapper232_map;
			mapper_map();
			if (Cart.Crc == 0x9adc4130 && Cart.PRGRom[0x2c4c1] == 0xa5) {
				bprintf(0, _T("Applied Hot-Patch: Quattro Sports / BMX Simulator start fix..\n"));
				Cart.PRGRom[0x2c4c1] = 0xa9; // make ctrlr-debounce read happy
			}
			retval = 0;
			break;
		}

		case 77: { // Irem? Napoleon Senki
			mapper_write = mapper77_write; // 8000 - ffff
			mapper_map   = mapper77_map;
		    mapper_map();
			retval = 0;
			break;
		}

		case 78: { // Jaleco JF16
			mapper_write = mapper78_write; // 8000 - ffff
			mapper_map   = mapper78_map;
		    mapper_map();
			retval = 0;
			break;
		}

		case 80: { // Taito x1005
			cart_exp_write = mapper207_write;
			cart_exp_read  = mapper207_read;
			mapper_map     = mapper207_map;
			mapper_scan_cb = mapper207_scan;
			memset(mapper80_ram, 0, sizeof(mapper80_ram));
			mapper207_adv_mirror = 0;
			mapper_map();
			retval = 0;
			break;
		}

		case 82: { // Taito x1017
			cart_exp_write = mapper82_write;
			cart_exp_read  = mapper82_read;
			mapper_map     = mapper82_map;
			mapper_map();
			retval = 0;
			break;
		}

		case 81: { // NTDEC Super Gun (Caltron)
			mapper_write = mapper81_write;
			mapper_map   = mapper81_map;
			mapper_map();
			retval = 0;
			break;
		}

		case 207: { // Taito x1005 w/advanced mirroring
			cart_exp_write = mapper207_write;
			cart_exp_read  = mapper207_read;
			mapper_map     = mapper207_map;
			mapper_scan_cb = mapper207_scan;
			memset(mapper80_ram, 0, sizeof(mapper80_ram));
			mapper207_adv_mirror = 1;
			mapper_map();
			retval = 0;
			break;
		}

		case 87: {
			cart_exp_write = mapper87_write; // 6000 - 7fff!
			mapper_map   = mapper87_map;
		    mapper_map();
			retval = 0;
			break;
		}

		case 88: {
			mapper_write = mapper88_write;
			mapper_map   = mapper88_map;
		    mapper_map();
			retval = 0;
			break;
		}

		case 154: {
			mapper_write = mapper88_write;
			mapper_map   = mapper88_map;
			mapper154 = 1;
		    mapper_map();
			retval = 0;
			break;
		}

		case 101: {
			cart_exp_write = mapper101_write; // 6000 - 7fff!
			mapper_map   = mapper101_map;
			mapper_regs[0] = 0xff;
		    mapper_map();
			retval = 0;
			break;
		}

		case 107: {
			mapper_write = mapper107_write;
			mapper_map   = mapper107_map;
			mapper_regs[0] = 0xff;
		    mapper_map();
			retval = 0;
			break;
		}

		case 38: {
			cart_exp_write = mapper38_write; // 6000 - 7fff
			mapper_map   = mapper38_map;
		    mapper_map();
			retval = 0;
			break;
		}

		case 66: {
			mapper_write = mapper140_write; // 8000 - ffff
			mapper_map   = mapper140_map;
		    mapper_map();
			retval = 0;
			break;
		}

		case 11: {
			mapper_write = mapper11_write; // 8000 - ffff
			mapper_map   = mapper11_map;
		    mapper_map();
			retval = 0;
			break;
		}

		case 144: { // similar to 11
			mapper_write = mapper144_write; // 8000 - ffff
			mapper_map   = mapper11_map;
		    mapper_map();
			retval = 0;
			break;
		}

		case 112: {
			mapper_write = mapper112_write;
			psg_area_write = mapper112_write;
			mapper_map   = mapper112_map;
			mapper_map_prg(8, 2, -2);
			mapper_map_prg(8, 3, -1);
		    mapper_map();
			retval = 0;
			break;
		}

		case 471: {
			mapper_write = mapper471_write; // 8000 - ffff
			psg_area_write = mapper471_write; // 4020 - 5fff (need this to get rid of unmapped debug spam)
			mapper_map   = mapper471_map;
			mapper_scanline = mapper471_scanline;
		    mapper_map();
			retval = 0;
			break;
		}

		case 146: // Sachen Metal Fighter
		case 79: { // NINA-03 / NINA-06
			psg_area_write = mapper79_write; // 4020 - 5fff
			mapper_map     = mapper79_map;
		    mapper_map();
			retval = 0;
			break;
		}

		case 113: { // NINA-03 / NINA-06 extended / Mojon Twins Multicart
			psg_area_write = mapper113_write; // 4020 - 5fff
			mapper_map     = mapper113_map;
		    mapper_map();
			retval = 0;
			break;
		}

		case 137:
		case 138:
		case 139:
		case 141: { // Sachen 8259A/B/C/D
			psg_area_write = mapper8259_write; // 4020 - 5fff -and-
			cart_exp_write = mapper8259_write; // 6000 - 7fff
			mapper_map     = mapper8259_map;
			mapper_regs[0x1f] = mappernum;
			mapper_map_chr( 8, 0, 0);
		    mapper_map();
			retval = 0;
			break;
		}

		case 150: { // Sachen LS
			psg_area_write = mapper150_write; // 4020 - 5fff -and-
			psg_area_read  = mapper150_read;
			cart_exp_write = mapper150_write; // 6000 - 7fff
			cart_exp_read  = mapper150_read;
			mapper_map     = mapper150_map;
		    mapper_map();
			retval = 0;
			break;
		}

		case 162: { // (Waixing) Zelda - Triforce of the Gods
			psg_area_write = mapper162_write; // 4020 - 5fff
			mapper_map     = mapper162_map;
			mapper162_reg(0) = 0x03;
			mapper162_reg(3) = 0x07;
			mapper_map_chr( 8, 0, 0);
		    mapper_map();
			retval = 0;
			break;
		}

		case 163: { // Final Fantasy VII (NJ063)
			psg_area_write = mapper163_write; // 4020 - 5fff
			psg_area_read  = mapper163_read;
			mapper_map     = mapper163_map;
			mapper_ppu_clock = mapper163_cycle;
		    mapper_map();
			retval = 0;
			break;
		}

		case 140: {
			cart_exp_write = mapper140_write; // 6000 - 7fff!
			mapper_map     = mapper140_map;
		    mapper_map();
			retval = 0;
			break;
		}

		case 180: { // crazy climber
			mapper_write = mapper180_write;
			mapper_map   = mapper180_map;
		    mapper_map();
			retval = 0;
			break;
		}

		case 184: {
			cart_exp_write = mapper184_write; // 6000 - 7fff!
			mapper_map     = mapper184_map;
		    mapper_map();
			retval = 0;
			break;
		}

		case 152: {
			mapper_write = mapper152_write;
			mapper_map   = mapper152_map;
		    mapper_map();
			retval = 0;
			break;
		}

		case 156: {
			mapper_write = mapper156_write;
			mapper_map   = mapper156_map;
		    mapper_map();
			retval = 0;
			break;
		}

		case 89: {
			mapper_write = mapper89_write;
			mapper_map   = mapper89_map;
		    mapper_map();
			retval = 0;
			break;
		}

		case 93: { // Sunsoft-1/2: Fantasy Zone, Shanghai
			mapper_write = mapper93_write;
			mapper_map   = mapper93_map;
		    mapper_map();
			retval = 0;
			break;
		}

		case 94: { // Senjou no Ookami (Commando)
			mapper_write = mapper94_write;
			mapper_map   = mapper94_map;
		    mapper_map();
			retval = 0;
			break;
		}

		case 97: { // Kaiketsu Yanchamaru (Kid Niki)
			mapper_write = mapper97_write;
			mapper_map   = mapper97_map;
		    mapper_map();
			retval = 0;
			break;
		}

		case 206: // mmc3 w/no irq (Tengen mimic-1, Namcot 118)
		case 4: { // mmc3
			mapper_write = mapper04_write;
			mapper_map   = mapper04_map;
			mapper_scanline = mapper04_scanline;
			mapper4_mirror = Cart.Mirroring; // wagyan land doesn't set the mapper bit!

			{
				// VS. Mapper 4 / 206 Protection
				mapper04_vs_prottype = 0;
				switch (Cart.Crc) {
					default: break;
					case 0x9f2251e4: // super xevious
						mapper04_vs_prottype++;         // fallthrough!
					case 0xd81d33da: // tko boxing
						mapper04_vs_prottype++;         // fallthrough!
					case 0xac95e2c9: // rbi baseball
						psg_area_read = mapper04_vs_rbi_tko_prot;
						break;
				}
			}

			// default mmc3 regs:
			// chr
			mapper_regs[0] = 0;
			mapper_regs[1] = 2;
			mapper_regs[2] = 4;
			mapper_regs[3] = 5;
			mapper_regs[4] = 6;
			mapper_regs[5] = 7;
			// prg
			mapper_regs[6] = 0;
			mapper_regs[7] = 1;

			mapper_map_prg( 8, 3, -1);
		    mapper_map();
			retval = 0;
			break;
		}

		case 406: { // Haradius Zero (mmc3 + 2xMXIC flash)
			flashrom_chiptype = MXIC;

			mapper_prg_read = flashrom_read;
			mapper_write    = mapper406_write;

			mapper_map      = mapper04_map;
			mapper_scanline = mapper04_scanline;
			mapper4_mirror  = Cart.Mirroring;

			mapper_map_prg( 8, 3, -1);
			mapper_map();
			retval = 0;
			break;
		}

		case 451: { // Haratyler pseudo-mmc3 + AMIC flash
			flashrom_chiptype = AMIC;

			mapper_prg_read = flashrom_read;
			mapper_write    = mapper451_write;

			mapper_map      = mapper451_map;
			mapper_scanline = mapper04_scanline;
			mapper4_mirror  = Cart.Mirroring;

			mapper_map();
			retval = 0;
			break;
		}

		case 12: { // mmc3 variant (dbz 5, mk4, umk3)
			psg_area_write = mapper12_write;
			psg_area_read = mapper12_read;
			mapper_write = mapper04_write;
			mapper_map   = mapper04_map;
			mapper_scanline = mapper04_scanline;
			mapper4_mirror = Cart.Mirroring; // wagyan land doesn't set the mapper bit!
			mapper_map_prg( 8, 3, -1);
		    mapper_map();
			retval = 0;
			break;
		}

		case 76: { // mmc3 variant (digital devil m.)
			mapper_write = mapper04_write;
			mapper_map   = mapper76_map;
			mapper_scanline = mapper04_scanline;
			mapper4_mirror = Cart.Mirroring;
			mapper_map_prg( 8, 3, -1);
		    mapper_map();
			retval = 0;
			break;
		}

		case 268: { // mmc3 variant (COOLBOY / MINDKIDS)
			mapper_write = mapper268_write;

			if (Cart.SubMapper == 1) psg_area_write = mapper268_write; // 5000-5fff
			else cart_exp_write = mapper268_write;                     // 6000-6fff

			mapper_map   = mapper268_map;
			mapper_scanline = mapper04_scanline;
			mapper4_mirror = Cart.Mirroring;

			mapper_map();
			retval = 0;
			break;
		}

		case 95: { // mmc3 variant (dragon buster)
			mapper_write = mapper95_write;
			mapper_map   = mapper95_map;
			mapper_scanline = mapper04_scanline;
			mapper_map_prg( 8, 3, -1);
		    mapper_map();
			retval = 0;
			break;
		}

		case 115: { // mmc3 variant (thunderbolt 2)
			mapper_write = mapper04_write;

			psg_area_write = mapper115_write;
			psg_area_read = mapper115_read;
			cart_exp_write = mapper115_write;
			cart_exp_read = mapper115_read;

			mapper_map   = mapper115_map;
			mapper_scanline = mapper04_scanline;
			mapper4_mirror = Cart.Mirroring; // wagyan land doesn't set the mapper bit!
		    mapper_map();
			retval = 0;
			break;
		}

		case 116: { // Somari (AV Girl Fighter)
			mapper_write = mapper116_write;
			psg_area_write = mapper116_write;
			cart_exp_write = mapper116_write;
			mapper_map   = mapper116_map;
			mapper_scanline = mapper116_mmc3_scanline;
			mapper116_defaults();
		    mapper_map();
			retval = 0;
			break;
		}

		case 14: { // Gouder SL-1632 (Samurai Spirits)
			mapper_write = mapper116_write;
			psg_area_write = mapper116_write;
			cart_exp_write = mapper116_write;
			mapper_map   = mapper14_map; // difference from 116
			mapper_scanline = mapper116_mmc3_scanline;
			mapper116_defaults();
		    mapper_map();
			retval = 0;
			break;
		}

		case 118: { // mmc3-derivative TKSROM/TLSROM (Alien Syndrome, Armadillo)
			mapper_write = mapper04_write;
			mapper_map   = mapper118_map;
			mapper_scanline = mapper04_scanline;
			mapper_map_prg( 8, 3, -1);
		    mapper_map();
			retval = 0;
			break;
		}

		case 119: { // mmc3-derivative w/char ram+rom & ability to map both into diff. banks! (pin-bot, high speed)
			mapper_write = mapper04_write;
			mapper_map   = mapper119_map;
			mapper_scanline = mapper04_scanline;
			mapper_set_chrtype(MEM_RAM);
			mapper_map_prg( 8, 3, -1);
		    mapper_map();
			retval = 0;
			break;
		}

		case 165: { // mmc3-derivative w/mmc4-style char ram(bank0)+rom(others)
			mapper_write = mapper04_write;
			mapper_map   = mapper165_map;
			mapper_ppu_clock = mapper165_ppu_clock;
			mapper_scanline = mapper04_scanline;
			mapper_set_chrtype(MEM_RAM);
			mapper_map_prg( 8, 3, -1);
		    mapper_map();
			retval = 0;
			break;
		}

		case 192: { // mmc3-derivative w/char ram+rom, ram mapped to chr banks 8, 9, a, b
			mapper_write = mapper04_write;
			mapper_map   = mapper192_map;
			mapper_scanline = mapper04_scanline;
			mapper_set_chrtype(MEM_RAM);
			mapper_map_prg( 8, 3, -1);
		    mapper_map();
			retval = 0;
			break;
		}

		case 194: { // mmc3-derivative w/char ram+rom, ram mapped to chr banks 0, 1
			mapper_write = mapper04_write;
			mapper_map   = mapper194_map;
			mapper_scanline = mapper04_scanline;
			mapper_set_chrtype(MEM_RAM);
			mapper_map_prg( 8, 3, -1);
		    mapper_map();
			retval = 0;
			break;
		}

		case 195: { // mmc3-derivative w/char ram+rom, ram mapped to chr banks 0-3, cpu accessable via 5000-5fff
			mapper_write = mapper04_write;
			mapper_map   = mapper195_map;
			psg_area_write  = mapper195_write;	// 5000 - 5fff r/w chr ram
			psg_area_read   = mapper195_read;	// 5000 - 5fff
			mapper_scanline = mapper04_scanline;
			mapper_set_chrtype(MEM_RAM);
			mapper_map_prg( 8, 3, -1);
		    mapper_map();
			retval = 0;
			break;
		}

		case 189: { // mmc3-derivative
			psg_area_write = mapper189_write; // 4020 - 5fff
			cart_exp_write = mapper189_write; // 6000 - 7fff
			mapper_write = mapper04_write;    // 8000 - ffff
			mapper_map   = mapper189_map;
			mapper_scanline = mapper04_scanline;
			mapper4_mirror = Cart.Mirroring; // wagyan land doesn't set the mapper bit!
		    mapper_map();
			retval = 0;
			break;
		}

		case 258: { // mmc3-derivative (blood of jurassic)
			psg_area_write = mapper258_write;	// 4020 - 5fff
			psg_area_read = mapper258_read;		// 4020 - 5fff
			mapper_write = mapper04_write;		// 8000 - ffff
			mapper_map   = mapper258_map;
			mapper_scanline = mapper04_scanline;
			mapper4_mirror = Cart.Mirroring; // wagyan land doesn't set the mapper bit!

			// default mmc3 regs:
			// chr
			mapper_regs[0] = 0;
			mapper_regs[1] = 2;
			mapper_regs[2] = 4;
			mapper_regs[3] = 5;
			mapper_regs[4] = 6;
			mapper_regs[5] = 7;
			// prg
			mapper_regs[6] = 0;
			mapper_regs[7] = 1;

			mapper_map_prg( 8, 3, -1);
		    mapper_map();
			retval = 0;
			break;
		}

		case 262: { // mmc3-derivative (Street Heroes)
			psg_area_write = mapper262_write;
			psg_area_read = mapper262_read;
			mapper_write = mapper04_write;
			mapper_map   = mapper262_map;
			mapper_scanline = mapper04_scanline;
			mapper4_mirror = Cart.Mirroring; // wagyan land doesn't set the mapper bit!
			mapper_map_prg( 8, 3, -1);
		    mapper_map();
			retval = 0;
			break;
		}
	}
	return retval;
}

static void mapper_irq(INT32 delay_cyc)
{
	if (delay_cyc == 0) { // irq now
		M6502SetIRQLine(0, CPU_IRQSTATUS_ACK);
	} else { // irq later (after 'cyc' m2 cycles)
		mapper_irq_exec = delay_cyc;
	}
}

static void mapper_run()
{
	if (mapper_irq_exec) {
		mapper_irq_exec--;
		if (mapper_irq_exec == 0) {
			M6502SetIRQLine(0, CPU_IRQSTATUS_ACK);
		}
	}

	if (mapper_cycle) mapper_cycle();
}

// --------[ end Mappers

static UINT32 nes_palette[3][0x40] = {
{ // dink-fami
	0x5c5c5c, 0x00237e, 0x100e9e, 0x33009b, 0x520074, 0x630037, 0x610500, 0x4c1700, 0x2b2c00, 0x093e00, 0x004700, 0x004505, 0x003744, 0x000000, 0x000000, 0x000000,
	0xa7a7a7, 0x1157d6, 0x3b38ff, 0x6d21fe, 0x9916c8, 0xb11973, 0xae2a1a, 0x904500, 0x626400, 0x307d00, 0x0a8a00, 0x00862a, 0x007385, 0x000000, 0x000000, 0x000000,
	0xfeffff, 0x5ba9ff, 0x8a88ff, 0xc16eff, 0xef61ff, 0xff65c7, 0xff7866, 0xe6961b, 0xb4b700, 0x7fd200, 0x53e027, 0x3cdc79, 0x3fc7da, 0x454545, 0x000000, 0x000000,
	0xfeffff, 0xbadbff, 0xcecdff, 0xe5c2ff, 0xf8bcff, 0xffbee7, 0xffc6be, 0xf4d39c, 0xe0e18a, 0xc9ec8c, 0xb6f2a2, 0xacf0c6, 0xade8ef, 0xb0b0b0, 0x000000, 0x000000,
},
{ // rgb
	0x7c7c7c, 0x0000fc, 0x0000bc, 0x4428bc, 0x940084, 0xa80020, 0xa81000, 0x881400,	0x503000, 0x007800, 0x006800, 0x005800, 0x004058, 0x000000, 0x000000, 0x000000,
	0xbcbcbc, 0x0078f8, 0x0058f8, 0x6844fc, 0xd800cc, 0xe40058, 0xf83800, 0xe45c10,	0xac7c00, 0x00b800, 0x00a800, 0x00a844, 0x008888, 0x000000, 0x000000, 0x000000,
	0xf8f8f8, 0x3cbcfc, 0x6888fc, 0x9878f8, 0xf878f8, 0xf85898, 0xf87858, 0xfca044,	0xf8b800, 0xb8f818, 0x58d854, 0x58f898, 0x00e8d8, 0x787878, 0x000000, 0x000000,
	0xfcfcfc, 0xa4e4fc, 0xb8b8f8, 0xd8b8f8, 0xf8b8f8, 0xf8a4c0, 0xf0d0b0, 0xfce0a8,	0xf8d878, 0xd8f878, 0xb8f8b8, 0xb8f8d8, 0x00fcfc, 0xf8d8f8, 0x000000, 0x000000
},
{ // Royaltea (Rupert Carmichael)
	0x5a6165, 0x0023a8, 0x0f17b0, 0x28129f,	0x550b61, 0x6b0a11, 0x6e0d00, 0x5e1900,	0x3c2402, 0x003104, 0x003508, 0x00341f,	0x002c55, 0x000000, 0x000000, 0x000000,
	0xa7b5bc, 0x0059ff, 0x2a44ff, 0x523cf1,	0x9f34ba, 0xb32846, 0xbb2d09, 0x9e4100,	0x865a00, 0x246d02, 0x007312, 0x007156,	0x0066a6, 0x000000, 0x000000, 0x000000,
	0xffffff, 0x4b9fff, 0x5a91ff, 0x867eff,	0xd97dff, 0xff95cf, 0xff8e76, 0xf7a247,	0xefb412, 0x8cc51c, 0x48d04a, 0x10d197,	0x00c9f0, 0x43484b, 0x000000, 0x000000,
	0xffffff, 0xb1d9ff, 0xb1cfff, 0xbcc8ff,	0xe3c8ff, 0xffd3f7, 0xffd5cb, 0xffdeb9,	0xffe5ad, 0xdbf6af, 0xb7fbc4, 0x9cfbe6,	0x96f7ff, 0xb1c0c7, 0x000000, 0x000000
} };

static UINT32 vs_palette[5][0x40] = {
{ // 2C03, 2C05
	0x6d6d6d, 0x002492, 0x0000db, 0x6d49db, 0x92006d, 0xb6006d, 0xb62400, 0x924900, 0x6d4900, 0x244900, 0x006d24, 0x009200, 0x004949, 0x000000, 0x000000, 0x000000,
	0xb6b6b6, 0x006ddb, 0x0049ff, 0x9200ff, 0xb600ff, 0xff0092, 0xff0000, 0xdb6d00, 0x926d00, 0x249200, 0x009200, 0x00b66d, 0x009292, 0x000000, 0x000000, 0x000000,
	0xffffff, 0x6db6ff, 0x9292ff, 0xdb6dff, 0xff00ff, 0xff6dff, 0xff9200, 0xffb600, 0xdbdb00, 0x6ddb00, 0x00ff00, 0x49ffdb, 0x00ffff, 0x000000, 0x000000, 0x000000,
	0xffffff, 0xb6dbff, 0xdbb6ff, 0xffb6ff, 0xff92ff, 0xffb6b6, 0xffdb92, 0xffff49, 0xffff6d, 0xb6ff49, 0x92ff6d, 0x49ffdb, 0x92dbff, 0x000000, 0x000000, 0x000000
},
{ // 2C04A
	0xffb6b6, 0xdb6dff, 0xff0000, 0x9292ff, 0x009292, 0x244900, 0x494949, 0xff0092, 0xffffff, 0x6d6d6d, 0xffb600, 0xb6006d, 0x92006d, 0xdbdb00, 0x6d4900, 0xffffff,
	0x6db6ff, 0xdbb66d, 0x6d2400, 0x6ddb00, 0x92dbff, 0xdbb6ff, 0xffdb92, 0x0049ff, 0xffdb00, 0x49ffdb, 0x000000, 0x490000, 0xdbdbdb, 0x929292, 0xff00ff, 0x002492,
	0x00006d, 0xb6dbff, 0xffb6ff, 0x00ff00, 0x00ffff, 0x004949, 0x00b66d, 0xb600ff, 0x000000, 0x924900, 0xff92ff, 0xb62400, 0x9200ff, 0x0000db, 0xff9200, 0x000000,
	0x000000, 0x249200, 0xb6b6b6, 0x006d24, 0xb6ff49, 0x6d49db, 0xffff00, 0xdb6d00, 0x004900, 0x006ddb, 0x009200, 0x242424, 0xffff6d, 0xff6dff, 0x926d00, 0x92ff6d
},
{ // 2C04B
	0x000000, 0xffb600, 0x926d00, 0xb6ff49, 0x92ff6d, 0xff6dff, 0x009292, 0xb6dbff, 0xff0000, 0x9200ff, 0xffff6d, 0xff92ff, 0xffffff, 0xdb6dff, 0x92dbff, 0x009200,
	0x004900, 0x6db6ff, 0xb62400, 0xdbdbdb, 0x00b66d, 0x6ddb00, 0x490000, 0x9292ff, 0x494949, 0xff00ff, 0x00006d, 0x49ffdb, 0xdbb6ff, 0x6d4900, 0x000000, 0x6d49db,
	0x92006d, 0xffdb92, 0xff9200, 0xffb6ff, 0x006ddb, 0x6d2400, 0xb6b6b6, 0x0000db, 0xb600ff, 0xffdb00, 0x6d6d6d, 0x244900, 0x0049ff, 0x000000, 0xdbdb00, 0xffffff,
	0xdbb66d, 0x242424, 0x00ff00, 0xdb6d00, 0x004949, 0x002492, 0xff0092, 0x249200, 0x000000, 0x00ffff, 0x924900, 0xffff00, 0xffb6b6, 0xb6006d, 0x006d24, 0x929292
},
{ // 2C04C
	0xb600ff, 0xff6dff, 0x92ff6d, 0xb6b6b6, 0x009200, 0xffffff, 0xb6dbff, 0x244900, 0x002492, 0x000000, 0xffdb92, 0x6d4900, 0xff0092, 0xdbdbdb, 0xdbb66d, 0x92dbff,
	0x9292ff, 0x009292, 0xb6006d, 0x0049ff, 0x249200, 0x926d00, 0xdb6d00, 0x00b66d, 0x6d6d6d, 0x6d49db, 0x000000, 0x0000db, 0xff0000, 0xb62400, 0xff92ff, 0xffb6b6,
	0xdb6dff, 0x004900, 0x00006d, 0xffff00, 0x242424, 0xffb600, 0xff9200, 0xffffff, 0x6ddb00, 0x92006d, 0x6db6ff, 0xff00ff, 0x006ddb, 0x929292, 0x000000, 0x6d2400,
	0x00ffff, 0x490000, 0xb6ff49, 0xffb6ff, 0x924900, 0x00ff00, 0xdbdb00, 0x494949, 0x006d24, 0x000000, 0xdbb6ff, 0xffff6d, 0x9200ff, 0x49ffdb, 0xffdb00, 0x004949
},
{ // 2C04D
	0x926d00, 0x6d49db, 0x009292, 0xdbdb00, 0x000000, 0xffb6b6, 0x002492, 0xdb6d00, 0xb6b6b6, 0x6d2400, 0x00ff00, 0x00006d, 0xffdb92, 0xffff00, 0x009200, 0xb6ff49,
	0xff6dff, 0x490000, 0x0049ff, 0xff92ff, 0x000000, 0x494949, 0xb62400, 0xff9200, 0xdbb66d, 0x00b66d, 0x9292ff, 0x249200, 0x92006d, 0x000000, 0x92ff6d, 0x6db6ff,
	0xb6006d, 0x006d24, 0x924900, 0x0000db, 0x9200ff, 0xb600ff, 0x6d6d6d, 0xff0092, 0x004949, 0xdbdbdb, 0x006ddb, 0x004900, 0x242424, 0xffff6d, 0x929292, 0xff00ff,
	0xffb6ff, 0xffffff, 0x6d4900, 0xff0000, 0xffdb00, 0x49ffdb, 0xffffff, 0x92dbff, 0x000000, 0xffb600, 0xdb6dff, 0xb6dbff, 0x6ddb00, 0xdbb6ff, 0x00ffff, 0x244900
} };

#define DIP_PALETTE (DrvDips[2] & 3)
static INT32 last_palette;
UINT32 *our_palette = NULL;

static void UpdatePalettePointer()
{
	switch (PPUType) {
		default:
		case RP2C02: // NES/FC/Royaltea palette (dip-selectable)
			our_palette = nes_palette[DIP_PALETTE];
			break;
		case RP2C03:	// VS. palettes (... and below!)
		case RP2C05A:
		case RP2C05B:
		case RP2C05C:
		case RP2C05D:
		case RP2C05E:
			our_palette = vs_palette[0];
			break;
		case RP2C04A:
		case RP2C04B:
		case RP2C04C:
		case RP2C04D:
			our_palette = vs_palette[1 + (PPUType - RP2C04A)];
			break;
	}
}

static UINT8 GetAvgBrightness(INT32 x, INT32 y)
{
	// Zapper Detection
	const UINT32 rgbcolor = our_palette[pTransDraw[(y) * 256 + x] & 0x3f];

	return ((rgbcolor & 0xff) + ((rgbcolor >> 8) & 0xff) + ((rgbcolor >> 16) & 0xff)) / 3;
}

static INT32 nes_frame_cycles;
static float nes_ppu_cyc_mult;
static INT32 prerender_line; // ntsc 261, pal 311

static INT32 ppu_frame;
static INT32 ppu_framecycles;
static INT32 mirroring;
static UINT8 nt_ram[0x400 * 4]; // nt (2k std. / 4k four-screen [2k expansion is usually on cart])
static UINT8 pal_ram[0x20];   // palette ram
static UINT8 oam_ram[0x100];  // oamram (sprite)
static OAMBUF oam[0x40];   // "to be drawn" oam
static INT32 oam_cnt;
static OAMBUF oam2[0x40];  // secondary oam (after eval)
static INT32 oam2_cnt;
static UINT8 oamAddr;

static UINT16 vAddr, tAddr; // vram addr (loopy-v), temp vram addr (loopy-t)
static UINT16 vAddr_update;
static INT32 vAddr_update_delay;
static UINT8 fine_x; // fine-x (scroll)

static PPUCTRL ctrl;
static PPUMASK mask;
static PPUSTATUS status;
#define RENDERING (mask.reg & 0x18) // show bg (0x08) + show sprites (0x10)
static INT32 sprite_height; // 8, 16. set on PPUCTRL
static INT32 v_incr; // 1, 32. set on PPUCTRL
static INT32 bgtable_start; // 0, 0x1000. set on PPUCTRL
static INT32 sprtable_start; // 0, 0x1000. set on PPUCTRL
static INT32 ppu_pal_mask; // 0x3f (color) 0x30 (gray). set on PPUMASK
static INT32 ppu_pal_emphasis; // emphasis palette index

static INT32 ppu_no_nmi_this_frame;
static INT32 ppu_odd;
static INT32 ppu_startup; // Start-up delay
static UINT16 ppu_bus_address;
static INT32 ppu_over; // #cycles we've run over/under to be compensated for on next frame
static UINT8 ppu_dbus; // ppu data-bus
static UINT8 ppu_buffer; // VRAM read buffer.

static UINT8 write_latch;
static UINT8 nt_byte;

static UINT8 bgL, bgH;
static UINT16 bg_shiftL, bg_shiftH;

static UINT8 at_byte;
static UINT8 at_shiftL, at_shiftH;
static UINT8 at_latchL, at_latchH;

#define get_bit(x, n) (((x) >> (n)) & 1)
static UINT8 bitrev_table[0x100];

// Nametable mirroring/mapping
static UINT8 *NTMap[4];
static INT32 NTType[4];

static void nametable_map(INT32 nt, INT32 ntbank)
{
	NTMap[nt & 3] = &nt_ram[0x400 * (ntbank & 3)];
	NTType[nt & 3] = MEM_RAM;
}

static void nametable_mapraw(INT32 nt, UINT8 *ntraw, UINT8 type)
{
	NTMap[nt & 3] = ntraw;
	NTType[nt & 3] = type;
}

static void nametable_mapall(INT32 ntbank0, INT32 ntbank1, INT32 ntbank2, INT32 ntbank3)
{
	nametable_map(0, ntbank0);
	nametable_map(1, ntbank1);
	nametable_map(2, ntbank2);
	nametable_map(3, ntbank3);
}

static void set_mirroring(INT32 mode)
{
	switch (mode)
    {
        case HORIZONTAL:  nametable_mapall(0, 0, 1, 1); break;
        case VERTICAL:	  nametable_mapall(0, 1, 0, 1); break;
		case SINGLE_LOW:  nametable_mapall(0, 0, 0, 0); break;
		case SINGLE_HIGH: nametable_mapall(1, 1, 1, 1); break;
		case FOUR_SCREEN: nametable_mapall(0, 1, 2, 3); break;
		case SACHEN:	  nametable_mapall(0, 1, 1, 1); break;
	}

	mirroring = mode;
}

static UINT8 read_nt_int(UINT16 address)
{
	return NTMap[(address & 0xfff) >> 10][address & 0x3ff];
}

static void write_nt_int(UINT16 address, UINT8 data)
{
	if (NTType[(address & 0xfff) >> 10] == MEM_RAM)
		NTMap[(address & 0xfff) >> 10][address & 0x3ff] = data;
}

// The internal PPU-Bus
static UINT8 ppu_bus_read(UINT16 address)
{
	if (ppu_startup) return 0; // ignore reads until line 261 on first frame.

	if (address >= 0x0000 && address <= 0x1fff)
		return mapper_chr_read(address);

	if (address >= 0x2000 && address <= 0x3eff)
		return read_nt(address);

	if (address >= 0x3f00 && address <= 0x3fff) {
		if ((address & 0x13) == 0x10) // 0x10, 0x14, 0x18, 0x1c -> 0x00, 0x04, 0x08, 0x0c
			address &= ~0x10;
		return pal_ram[address & 0x1f] & ppu_pal_mask;
	}

	return 0;
}

static void ppu_bus_write(UINT16 address, UINT8 data)
{
	if (address >= 0x0000 && address <= 0x1fff)
		mapper_chr_write(address, data);

	if (address >= 0x2000 && address <= 0x3eff)
		write_nt(address, data);

	if (address >= 0x3f00 && address <= 0x3fff) {
		if ((address & 0x13) == 0x10)
			address &= ~0x10;
		pal_ram[address & 0x1f] = data;
	}
}

static void h_scroll();
static void v_scroll();

static void ppu_inc_v_addr()
{
	if (RENDERING && (scanline < 241 || scanline == prerender_line)) {
		// no updates while rendering!
		//bprintf(0, _T("no updates while rendering! frame: %X  scanline: %d    pixel: %d\n"), nCurrentFrame, scanline, pixel);

		// Burai Fighter (U) statusbar fix
		h_scroll();
		v_scroll();
		return;
	}

	vAddr = (vAddr + v_incr) & 0x7fff;
	ppu_bus_address = vAddr & 0x3fff;
}

static void get_vsystem_prot(UINT8 &dbus, UINT8 status_reg)
{	// 2C05A-E(D) returns a special ID in the usually-unused PPU status bits
	// as a form of EEPROM-Swap/Copy protection.
	const UINT8 _2c05_ids[5] = { 0x1b, 0x3d, 0x1c, 0x1b, 0x00 };
	if (PPUType >= RP2C05A && PPUType <= RP2C05E) {
		dbus = _2c05_ids[PPUType - RP2C05A] | status_reg;
	}
}

static UINT8 ppu_read(UINT16 reg)
{
	reg &= 7;

	switch (reg)
	{
		case 2: // PPUSTATUS
			if (scanline == 241 && pixel < 3) {
				// re: https://wiki.nesdev.com/w/index.php/PPU_frame_timing
				// PPUSTATUS read: 1 cycle before vbl (pixel == 0) skips status & nmi
				// on or 1 pixel after (pixel == 1 or 2) returns vblank status, but skips nmi
				//bprintf(0, _T("PPUSTATUS: CANCEL NMI.  scanline %d  pixel %d\n"), scanline, pixel);
				ppu_no_nmi_this_frame = 1;
				if (pixel == 0) status.bit.VBlank = 0;
			}
			ppu_dbus = (ppu_dbus & 0x1f) | status.reg;
			get_vsystem_prot(ppu_dbus, status.reg);
			status.bit.VBlank = 0;
			write_latch = 0;
			//bprintf(0, _T("PPUSTATUS - frame: %d   scanline: %d     pixel: %d    res: %X   PC: %X\n"), nCurrentFrame, scanline, pixel, ppu_dbus, M6502GetPrevPC(-1));
			break;

		case 4: // OAMDATA
			if (RENDERING && scanline < 241) {
				// quirks to keep micromachines happy
				if (pixel >= 1 && pixel <= 64) {
					ppu_dbus = 0xff;
					break;
				}
				if (pixel >= 65 && pixel <= 256) {
					ppu_dbus = 0x00;
					break;
				}

				if (pixel >= 257 && pixel <= 320) {
					ppu_dbus = oam2[((pixel & 0xff) >> 3)].x;
					break;
				}

				if ((pixel >= 321 && pixel <= 340) || pixel == 0) {
					ppu_dbus = oam2[0].y;
					break;
				}
			}
			ppu_dbus = oam_ram[oamAddr];
			break;

		case 7: // PPUDATA
			if ((ppu_bus_address & 0x3fff) < 0x3f00) {
				// vram buffer delay
				ppu_dbus = ppu_buffer;
				ppu_buffer = ppu_bus_read(ppu_bus_address);
				//mapper_ppu_clock(ppu_bus_address);
			} else {
				// palette has no buffer delay, buffer gets stuffed with vram though (ppu quirk)
				ppu_dbus = ppu_bus_read(ppu_bus_address);
				ppu_buffer = ppu_bus_read(ppu_bus_address - 0x1000);
			}

			ppu_inc_v_addr();
			break;

	}

	return ppu_dbus;
}

static void ppu_write(UINT16 reg, UINT8 data)
{
	reg &= 7;

	if (PPUType >= RP2C05A && reg < 2) {
		// PPUCTRL / PPUMASK swapped on RP2C05x
		reg ^= 1;
	}

	ppu_dbus = data;

	switch (reg)
	{
		case 0: // PPUCTRL
			if (ppu_startup) return; // ignore writes until line 261
			if (data & 0x80) {
				if ((~ctrl.reg & 0x80) && status.bit.VBlank) {
					//--Note: If NMI is fired here, it will break:
					//Bram Stokers Dracula, Galaxy 5000, GLUK The Thunder aka Thunder Warrior
					//Animal Clipper (HB) - nmi clobbers A register during bootup.
					//Dragon Power scrolling goes bad
					//Solution: Delay NMI by 1(?) opcode
					//bprintf(0, _T("PPUCTRL: toggle-nmi-arm! scanline %d  pixel %d    frame: %d   PPC %X\n"), scanline, pixel, nCurrentFrame, M6502GetPC(-1));
					m6502_set_nmi_hold2();
				}
			} else {
				//bprintf(0, _T("PPUCTRL: %X  cancel-nmi?  scanline %d  pixel %d   frame %d\n"), data, scanline, pixel, nCurrentFrame);
			}

			ctrl.reg = data;
			//bprintf(0, _T("PPUCTRL reg: %X   scanline %d  pixel %d   frame %d  PC  %X\n"), ctrl.reg, scanline, pixel, nCurrentFrame, M6502GetPC(-1));
			tAddr = (tAddr & 0x73ff) | ((data & 0x3) << 10);

			sprite_height = ctrl.bit.sprsize ? 16 : 8;
			v_incr = ctrl.bit.incr ? 32 : 1;
			bgtable_start = ctrl.bit.bgtab * 0x1000;
			sprtable_start = ctrl.bit.sprtab * 0x1000;
			break;

		case 1: // PPUMASK
			if (ppu_startup) return; // ignore writes until line 261
			if ((data & 0x18)==0 && RENDERING) { // rendering ON -> OFF assert ppu_bus_address
				ppu_bus_address = vAddr & 0x3fff;
			}
			mask.reg = data;
			ppu_pal_emphasis = (data >> 5) * 0x40;
			if (NESMode & IS_PAL) {
				ppu_pal_emphasis = (((data & 0x80) | ((data & 0x40) >> 1) | ((data & 0x20) << 1)) >> 5) * 0x40;
			}
			//bprintf(0, _T("mask   %x\n"), data);
			ppu_pal_mask = (mask.bit.gray ? 0x30 : 0x3f);
			break;

		case 3: // OAMADDR
			oamAddr = data;
			break;

		case 4: // OAMDATA
			//bprintf(0, _T("Frame %04x:  OAMDATA[%X]  %X      scanline %d  pixel %d\n"), nCurrentFrame, oamAddr, data, scanline, pixel);
			if (RENDERING && (scanline < 241 || scanline == prerender_line) && (~NESMode & BAD_HOMEBREW)) {
				bprintf(0, _T("write OAM prohibited.  scanline %d\n"), scanline);
				return;
			}
			if ((oamAddr & 3) == 2) data &= 0xe3; // attr mask
			oam_ram[oamAddr] = data;
			oamAddr = (oamAddr + 1) & 0xff;
			break;

		case 5: // PPUSCROLL
			if (ppu_startup) return; // ignore writes until line 261
			if (!write_latch) {      // First write.
				fine_x = data & 7;
				tAddr = (tAddr & 0x7fe0) | ((data & 0xf8) >> 3);
			} else  {                // Second write.
				tAddr = (tAddr & 0x0c1f) | ((data & 0xf8) << 2) | ((data & 0x07) << 12);
			}
			write_latch = !write_latch;
			break;
		case 6: // PPUADDR
			if (ppu_startup) return; // ignore writes until line 261
			if (!write_latch) {		// First write.
				tAddr = (tAddr & 0x00ff) | ((data & 0x3f) << 8);
			} else {                // Second write.
				tAddr = (tAddr & 0x7f00) | data;
				vAddr_update = tAddr;
				vAddr_update_delay = 2;
			}
			write_latch = !write_latch;
			break;
		case 7: // PPUDATA
			ppu_bus_write(ppu_bus_address, data);
			//mapper_ppu_clock(ppu_bus_address);

			ppu_inc_v_addr();
			break;
	}
}

static void h_scroll()
{
	if (RENDERING) {
		if ((vAddr & 0x1f) == 0x1f) {
			vAddr ^= 0x041f;
		} else {
			vAddr++;
		}
	}
}

static void v_scroll()
{
	if (RENDERING) {
		if ((vAddr & 0x7000) == 0x7000) {
			switch (vAddr & 0x03e0) {
				case 0x03a0: vAddr ^= 0x7800 | 0x03a0; break;
				case 0x03e0: vAddr &= ~0x73e0; break;
				default: vAddr = (vAddr & ~0x7000) + 0x0020;
			}
		} else {
			vAddr += 0x1000;
		}
	}
}

static void reload_shifters()
{
	at_latchL = at_byte & 1;
    at_latchH = (at_byte & 2) >> 1;

	bg_shiftL = (bg_shiftL & 0xff00) | bgL;
    bg_shiftH = (bg_shiftH & 0xff00) | bgH;
}

static void evaluate_sprites()
{
	INT32 cur_line = (scanline == prerender_line) ? -1 : scanline;
	oam2_cnt = 0;

    for (INT32 i = oamAddr; i < 0x40; i++) {
        INT32 line = cur_line - oam_ram[(i << 2) + 0];
        if (line >= 0 && line < sprite_height) {
			if (oam2_cnt == 8) {
				status.bit.spovrf = 1;
				if (~DrvDips[0] & 1) // DIP option: disable sprite limit
					break;
			}
			oam2[oam2_cnt].idx  = i;
            oam2[oam2_cnt].y    = oam_ram[(i << 2) + 0];
            oam2[oam2_cnt].tile = oam_ram[(i << 2) + 1];
            oam2[oam2_cnt].attr = oam_ram[(i << 2) + 2];
			oam2[oam2_cnt++].x  = oam_ram[(i << 2) + 3];
		}
	}
}

static void load_sprites()
{
	oam_cnt = 0;
	for (INT32 i = 0; i < oam2_cnt; i++) {
		oam[oam_cnt++] = oam2[i];

		UINT32 sprY = scanline - oam[i].y;
		sprY = (oam[i].attr & 0x80) ? ~sprY : sprY; // invert y-bits if y-flipped

		if (sprite_height == 16) {
			ppu_bus_address = ((oam[i].tile & 1) * 0x1000) + ((oam[i].tile & 0xfe) * 16)
				+ ((sprY & 8) << 1) + (sprY & 7);
		} else {
			ppu_bus_address = sprtable_start + (oam[i].tile * 16) + (sprY & 7);
		}

		oam[i].tileL = ppu_bus_read(ppu_bus_address);
		ppu_bus_address += 8;
		oam[i].tileH = ppu_bus_read(ppu_bus_address);

		if (mapper_ppu_clock) mapper_ppu_clock(ppu_bus_address); // Punch-Out (mapper 9) latches on high-byte read (+8)

		if (oam[i].attr & 0x40) { // reverse bits if x-flipped
			oam[i].tileL = bitrev_table[oam[i].tileL];
			oam[i].tileH = bitrev_table[oam[i].tileH];
		}
    }
}

static void draw_and_shift()
{
    INT32 x = pixel - 2;

	if (scanline < 240 && x >= 0 && x < 256) {
		UINT8 pix = 0;
		UINT8 sprPal = 0;
		UINT8 sprPri = 0;
		UINT8 spr = 0;
		UINT16 eff_x = 0;

		if (!RENDERING && (vAddr & 0x3f00) == 0x3f00) {
			// https://wiki.nesdev.com/w/index.php/PPU_palettes "The background palette hack"
			pix = vAddr & 0x1f;
		}

		if (mask.bit.bg && (mask.bit.bgLeft == 0 && x < 8) == 0) {
			pix = (get_bit(bg_shiftH, 15 - fine_x) << 1) |
				  (get_bit(bg_shiftL, 15 - fine_x) << 0);

			if (pix) {
				pix |= ((get_bit(at_shiftH, 7 - fine_x) << 1) |
						(get_bit(at_shiftL, 7 - fine_x) << 0)) << 2;
			}
        }

		if (mask.bit.spr && (mask.bit.sprLeft == 0 && x < 8) == 0) {
			for (INT32 i = oam_cnt - 1; i >= 0; i--) {
				if (oam[i].idx == 0xff) // no sprite
					continue;

				eff_x = x - oam[i].x;
				if (eff_x >= 8) // sprite out of view
					continue;

				spr = (get_bit(oam[i].tileH, 7 - eff_x) << 1) |
					  (get_bit(oam[i].tileL, 7 - eff_x) << 0);

				if (spr == 0) // transparent sprite, ignore
					continue;

				if (oam[i].idx == 0 && pix && x != 0xff) {
					status.bit.sp0hit = 1;
				}

                spr |= (oam[i].attr & 3) << 2; // add color (attr), 2bpp shift
                sprPal = spr + 0x10; // add sprite color palette-offset
                sprPri = ~oam[i].attr & 0x20; // sprite over bg?
            }
		}

		if (~nBurnLayer & 1) pix = 0; // if tile layer disabled, clear pixel.
        if (sprPal && (pix == 0 || sprPri) && nSpriteEnable & 1) pix = sprPal;

		if (NESMode & SHOW_OVERSCAN) {
			pTransDraw[scanline * 256 + x] = ppu_bus_read(0x3f00 + pix) | ppu_pal_emphasis;
		} else {
			if (scanline >= 8 && scanline < (nScreenHeight + 8)/*232*/)
				pTransDraw[(scanline - 8) * 256 + x] = ppu_bus_read(0x3f00 + pix) | ppu_pal_emphasis;
		}
    }

	bg_shiftL <<= 1;
	bg_shiftH <<= 1;
    at_shiftL = (at_shiftL << 1) | at_latchL;
    at_shiftH = (at_shiftH << 1) | at_latchH;
}

static void scanlinestate(INT32 state)
{
	if (state == VBLANK) {

		switch (pixel) {
			case 1: // enter VBlank
				ppu_bus_address = vAddr & 0x3fff;
				status.bit.VBlank = 1;
				ppu_startup = 0;

				if (NESMode & ALT_TIMING2) {
					if (ctrl.bit.nmi && ppu_no_nmi_this_frame == 0) {
						//bprintf(0, _T("nmi @ frame %d  scanline %d  pixel %d  PPUCTRL %x\n"), nCurrentFrame, scanline, pixel, ctrl.reg);
						M6502SetIRQLine(CPU_IRQLINE_NMI, CPU_IRQSTATUS_AUTO);
					}
					ppu_no_nmi_this_frame = 0;
				}
				break;

			case (6 * 3):
				// 6 CPU-cycles later, do nmi.  fixes boot w/b-wings, bad dudes, gunnac
				// crap on screen with marble madness. (Also passes blargg timing tests)
				if (~NESMode & ALT_TIMING2) {
					if (ctrl.bit.nmi && ppu_no_nmi_this_frame == 0) {
						//bprintf(0, _T("nmi @ frame %d  scanline %d  pixel %d  PPUCTRL %x\n"), nCurrentFrame, scanline, pixel, ctrl.reg);
						M6502SetIRQLine(CPU_IRQLINE_NMI, CPU_IRQSTATUS_AUTO);
					}
					ppu_no_nmi_this_frame = 0;
				}
				break;
		}
	}
	else if (state == VISIBLE || state == PRERENDER) {

		// Sprites
		switch (pixel) {
			case 1:
				memset(oam2, 0xff, sizeof(oam2)); // clear secondary oam

				if (state == PRERENDER) {
					status.reg &= 0x1f; // clear vbl, spr0 hit & overflow bits

					if (oamAddr > 7) { // 2c02 oamram corruption (Huge Insect, Tatakai no Banka pre-revA)
						for (INT32 i = 0; i < 8; i++) {
							oam_ram[i] = oam_ram[(oamAddr & 0xf8) + i];
						}
					}
				}
				break;
			case 257:
				evaluate_sprites();
				if (RENDERING) {
					oamAddr = 0;
				}
				break;
			case 321:
				if (RENDERING) {
					load_sprites();
				} else {
					oam_cnt = 0;
				}
				break;
		}

		// Tiles
		if ( (pixel >= 1 && pixel <= 257) || (pixel >= 321 && pixel <= 337) ) {
			if (pixel != 1) draw_and_shift();
			if (RENDERING) {
				switch (pixel & 7) {
					case 1:
						ppu_bus_address = 0x2000 | (vAddr & 0x0fff); // nametable address
						reload_shifters();
						if (pixel == 257 && RENDERING) {
							// copy horizontal bits from loopy-T to loopy-V
							vAddr = (vAddr & ~0x041f) | (tAddr & 0x041f);
						}
						break;
					case 2:
						nt_byte = ppu_bus_read(ppu_bus_address);
						break;
					case 3:
						ppu_bus_address = 0x23c0 | (vAddr & 0x0c00) | ((vAddr >> 4) & 0x38) | ((vAddr >> 2) & 7); // attribute address
						break;
					case 4:
						at_byte = ppu_bus_read(ppu_bus_address);
						if (vAddr & (1 << 6) /* coarse Y & 2 */) at_byte >>= 4;
						if (vAddr & (1 << 1) /* coarse X & 2 */) at_byte >>= 2;
						break;
					case 5:
						ppu_bus_address = bgtable_start + (nt_byte * 16) + (vAddr >> 12); // background address
						break;
					case 6:
						bgL = ppu_bus_read(ppu_bus_address);
						break;
					case 7:
						ppu_bus_address = 8 + bgtable_start + (nt_byte * 16) + (vAddr >> 12); // background address
						break;
					case 0:
						bgH = ppu_bus_read(ppu_bus_address);
						if (pixel == 256)
							v_scroll();
						else
							h_scroll();
						break;
				}
			}
		}

		if (state == PRERENDER && pixel >= 280 && pixel <= 304 && RENDERING) {
			// copy vertical bits from loopy-T to loopy-V
			vAddr = (vAddr & ~0x7be0) | (tAddr & 0x7be0);
		}

		if (pixel >= 337 && pixel <= 340 && RENDERING) {
			// dummy nt fetches
			ppu_bus_address = 0x2000 | (vAddr & 0x0fff);
		}

		// Signal scanline to mapper: (+18 gets rid of jitter in Kirby, Yume Penguin Monogatari, Klax, ...)
		// Note: was 20, but caused occasional flickering in the rasterized water in "Kira Kira Star Night GOLD" (maybe the others in the series, too?)
		if (pixel == (260+18) /*&& RENDERING*/ && mapper_scanline) mapper_scanline();
		// Mapper callback w/ppu_bus_address - used by mmc2/mmc4 (mapper9/mapper10)
		if (mapper_ppu_clock) mapper_ppu_clock(ppu_bus_address); // ppu callback (visible lines)
    }
}

void ppu_cycle()
{
	ppu_framecycles++;	// keep track of cycles/frame since reset
	pixel++; 			// cycle (pixel)/line

	if (pixel > 340) {
		pixel = 0;
		scanline++;
		if (scanline > prerender_line) {
			scanline = 0;
			ppu_frame++;
			ppu_odd ^= 1;
			if (RENDERING && ppu_odd) {
				// this real hw hack was added to the ppu back in the day for better
				// rf/composite output.  since it messes with current cpu:ppu
				// sync. and isn't really necessary w/emu, let's disable it. -dink
				//pixel++;
				//ppu_framecycles++;
			}
        }
	}

	if (scanline >= 0 && scanline <= 239)
		scanlinestate(VISIBLE);
	else if (scanline == 241)
		scanlinestate(VBLANK);
	else if (scanline == prerender_line) {
		scanlinestate(PRERENDER);
	}

	if (mapper_ppu_clockall) mapper_ppu_clockall(ppu_bus_address); // ppu callback (every line)

	if (vAddr_update_delay > 0) {
		vAddr_update_delay--;
		if (vAddr_update_delay == 0) {
			vAddr = vAddr_update;
			if ((scanline >= 240 && scanline < prerender_line) || !RENDERING) {
				ppu_bus_address = vAddr & 0x3fff;
			}
		}
	}
}

static void ppu_run(INT32 cyc)
{
	while (ppu_over < 0) { // we didn't run enough cycles last frame, catch-up!
		cyc++;
		ppu_over++;
	}

	if ((NESMode & IS_PAL) && (mega_cyc_counter % 5) == 0) {
		cyc++;
	}

	while (cyc) {
		if (ppu_over > 0) { // if we're over some cycles on the start of next:
			ppu_over--;     // frame - idle them away
		} else {
			ppu_cycle();
		}
		cyc--;
	}
}

static void ppu_scan(INT32 nAction)
{
	SCAN_VAR(mirroring);
	SCAN_VAR(scanline);
	SCAN_VAR(pixel);
	SCAN_VAR(ppu_frame);

	SCAN_VAR(vAddr);
	SCAN_VAR(tAddr);
	SCAN_VAR(vAddr_update);
	SCAN_VAR(vAddr_update_delay);

	SCAN_VAR(fine_x);
	SCAN_VAR(oamAddr);

	SCAN_VAR(ctrl);
	SCAN_VAR(mask);
	SCAN_VAR(status);

	SCAN_VAR(sprite_height);
	SCAN_VAR(v_incr);
	SCAN_VAR(bgtable_start);
	SCAN_VAR(sprtable_start);
	SCAN_VAR(ppu_pal_mask);

	SCAN_VAR(ppu_no_nmi_this_frame);
	SCAN_VAR(ppu_odd);
	SCAN_VAR(ppu_startup);
	SCAN_VAR(ppu_bus_address);
	SCAN_VAR(ppu_over);
	SCAN_VAR(ppu_dbus);
	SCAN_VAR(ppu_buffer);
	SCAN_VAR(write_latch);

	SCAN_VAR(nt_byte);
	SCAN_VAR(bgL);
	SCAN_VAR(bgH);
	SCAN_VAR(bg_shiftL);
	SCAN_VAR(bg_shiftH);

	SCAN_VAR(at_byte);
	SCAN_VAR(at_shiftL);
	SCAN_VAR(at_shiftH);
	SCAN_VAR(at_latchL);
	SCAN_VAR(at_latchH);

	// ppu-ram
	SCAN_VAR(nt_ram);
	SCAN_VAR(pal_ram);
	SCAN_VAR(oam_ram);

	if (nAction & ACB_WRITE) {
		set_mirroring(mirroring);
	}
}

static void ppu_reset()
{
	mmc5_nt_ram = &nt_ram[0];

	// start at (around) vblank to remove 1 full frame of input lag
	scanline = 239; // line on titlescreen of micromachines if starts on 240
	if (NESMode & BAD_HOMEBREW) scanline = 0; // animal clipper, enables nmi via ppuctrl, if happens during vblank, game will go nuts
	pixel = 0;
	ppu_frame = 0;

	vAddr = 0;
	tAddr = 0;
	fine_x = 0;
	oamAddr = 0;

	ctrl.reg = 0;
	mask.reg = 0;
	status.reg = 0;

	mmc5_mask = &mask.reg; // point to ppumask register
	mmc5_ctrl = &ctrl.reg; // point to ppuctrl register

	sprite_height = 8;
	v_incr = 1;
	bgtable_start = 0;
	sprtable_start = 0;
	ppu_pal_mask = 0x3f;
	ppu_pal_emphasis = 0;

	ppu_odd = 0;
	ppu_no_nmi_this_frame = 0;
	ppu_startup = 0; // ignore some reads/writes until ppu "warms up" *disabled, see next line*
	// ppu_startup breaks Magic John - but why??  A: games writes ppu registers too early..
	ppu_bus_address = 0;
	ppu_over = 0; // cycles overrun this frame
	ppu_dbus = 0;
	ppu_buffer = 0;

	write_latch = 0;

	ppu_framecycles = 0; // total ran cycles this frame

    memset(nt_ram, 0xff, sizeof(nt_ram));
	memset(pal_ram, 0x00, sizeof(pal_ram));
    memset(oam_ram, 0xff, sizeof(oam_ram));

	memset(oam, 0xff, sizeof(oam));
	memset(oam2, 0xff, sizeof(oam2));

	nt_byte = 0;
	bgL = bgH = 0;
	bg_shiftL = bg_shiftH = 0;

	at_byte = 0;
	at_shiftL = at_shiftH = 0;
	at_latchL = at_latchH = 0;

	oam_cnt = 0;
	oam2_cnt = 0;

	last_palette = DIP_PALETTE;

	UpdatePalettePointer();
}

static void ppu_init(INT32 is_pal)
{
	read_nt = &read_nt_int;
	write_nt = &write_nt_int;
	for (INT32 i = 0; i < 0x100; i++)
		bitrev_table[i] = BITSWAP08(i, 0, 1, 2, 3, 4, 5, 6, 7);

	if (is_pal) {
		nes_frame_cycles = 33248; // pal
		prerender_line = 311;
		nes_ppu_cyc_mult = 3.2;
	} else {
		nes_frame_cycles = 29781; // ntsc (default)
		nes_ppu_cyc_mult = 3.0;
		prerender_line = 261;
	}

	ppu_reset();
}

enum {
	ZAP_SENSE		= 0x00,
	ZAP_NONSENSE	= 0x08,
	ZAP_TRIGGER		= 0x10
};

static UINT8 nes_read_zapper()
{
	if (RENDERING == 0 || scanline < 8 || scanline > 240)
		return ZAP_NONSENSE;

	INT32 in_y = ((BurnGunReturnY(0) * 224) / 255);
	INT32 in_x = BurnGunReturnX(0);
	INT32 real_sl = scanline - 8;

	// offscreen check
	if (in_y == 0 || in_y == 224 || in_x == 0 || in_x == 255) {
		return ZAP_NONSENSE;
	}

	for (INT32 yy = in_y - 2; yy < in_y + 2; yy++) {
		if (yy < real_sl-8 || yy > real_sl || yy < 0 || yy > 224) continue;

		for (INT32 xx = in_x - 2; xx < in_x + 2; xx++) {
			if (xx < 0 || xx > 255) continue;
			if (yy == real_sl && xx >= pixel) break; // <- timing is everything, here.
			if (GetAvgBrightness(xx, yy) > 0x88) { // + flux capacitor makes time travel possible
				return ZAP_SENSE;
			}
		}
	}

	return ZAP_NONSENSE;
}

static UINT8 nes_read_joy(INT32 port)
{
	UINT8 ret = 0;

	if ((NESMode & USE_ZAPPER) && port == 1) {
		// NES Zapper on second port (0x4017)
		ret = nes_read_zapper(); // light sensor
		ret |= (ZapperFire) ? ZAP_TRIGGER : 0x00; // trigger

		if (ZapperReload) {
			ZapperReloadTimer = 10;
			ret = ZAP_TRIGGER | ZAP_NONSENSE;
		} else if (ZapperReloadTimer) {
			ret = ZAP_NONSENSE;
		}

	} else {
		if (NESMode & USE_HORI4P) {
			UINT8 a = (JoyShifter[port&1] >> 0) & 0xff; // joy 1,3
			UINT8 b = (JoyShifter[port&1] >> 8) & 0xff; // joy 2,4
			ret  = (a & 1);			// joy 1,2 d0 (FC hardwired controllers)
			ret |= (b & 1) << 1;	// joy 3,4 d1 (controllers connected to HORI4P)
			a >>= 1;                // shift next bit
			b >>= 1;                // "
			a |= 0x80;              // feed empty high bit (active low)
			b |= 0x80;              // "

			JoyShifter[port&1] = (a & 0xff) | ((b << 8) & 0xff00);
		} else {
			ret = JoyShifter[port&1]&1;
			JoyShifter[port&1] >>= 1;   // shift next
			JoyShifter[port&1] |= 0x80000000; // feed high bit so reads past our data return high
		}

		// MIC "blow" hack (read on 1p controller address, yet, mic is on 2p controller!)
		if (NESMode & IS_FDS && port == 0) {
			if (DrvInputs[1] & ((1<<2) | (1<<3))) { // check if 2p select or start pressed. note: famicom 2p controller doesn't have start or select, we use it as a MIC button.
				ret |= 4;
			}
		}

		// note, some games (f.ex: paperboy) relies on the open bus bits in the high nibble
		ret |= cpu_open_bus & 0xf0;
	}

	return ret;
}

static UINT8 nesvs_read_joy(INT32 port)
{ // VS. Unisystem, VS. Zapper handled in psg_io_write() ctrlr strobe
	UINT8 joy = nes_read_joy(port) & 1;

	switch (port) {
		case 0: // 4016: joy + bottom 3 bits of dip + coin
			joy = (joy & 0x01) | ((DrvDips[3] & 3) << 3) | (NESCoin[0] << 2);
			break;
		case 1: // 4017: joy + top 6 bits of dip
			joy = (joy & 0x01) | (DrvDips[3] & 0xfc);
			break;
	}

	return joy;
}

static UINT8 psg_io_read(UINT16 address)
{
	if (address == 0x4016 || address == 0x4017)
	{	// Gamepad 1 & 2 / Zapper
		if (PPUType > RP2C02) {
			return nesvs_read_joy(address & 1);
		}
		return nes_read_joy(address & 1);
	}

	if (address == 0x4015)
	{
		return nesapuRead(0, address & 0x1f, cpu_open_bus);
	}

	if (address >= 0x4020 && psg_area_read) {
		return psg_area_read(address);
	}

	//bprintf(0, _T("psg_io_read(unmapped) %X\n"), address);

	return cpu_open_bus;
}

static void psg_io_write(UINT16 address, UINT8 data)
{
	if (address == 0x4016)
	{
		if (Cart.Mapper == 99) {
			mapper99_write(address, data);
		}

		if ((JoyStrobe & 1) && (~data & 1)) {
			switch (NESMode & (USE_4SCORE | USE_HORI4P | VS_ZAPPER | VS_REVERSED)) {
				case USE_4SCORE:
					// "Four Score" 4-player adapter (NES / World)
					JoyShifter[0] = DrvInputs[0] | (DrvInputs[2] << 8) | (bitrev_table[0x10] << 16);
					JoyShifter[1] = DrvInputs[1] | (DrvInputs[3] << 8) | (bitrev_table[0x20] << 16);
					break;
				case USE_HORI4P: // mode 2
					// "Hori" 4-player adapter Mode 4 (Japanese / Famicom)
					JoyShifter[0] = DrvInputs[0] | (DrvInputs[2] << 8);
					JoyShifter[1] = DrvInputs[1] | (DrvInputs[3] << 8);
					break;
				case VS_ZAPPER: { // VS. UniSystem Zapper
					UINT8 zap = 0x10;
					zap |= ((~nes_read_zapper() << 3) & 0x40) | (ZapperFire << 7);
					zap |= (ZapperReload) ? 0xc0 : 0x00;
					JoyShifter[0] = zap | 0xffffff00;
					JoyShifter[1] = zap | 0xffffff00;
					break;
				}
				case VS_REVERSED: {
					// some VS. games swap p1/p2 inputs (not select/start aka 0xc0)
					UINT8 in1 = (DrvInputs[1] & 0x0c) | (DrvInputs[0] & ~0x0c);
					UINT8 in0 = (DrvInputs[0] & 0x0c) | (DrvInputs[1] & ~0x0c);
					JoyShifter[0] = in0 | 0xffffff00;
					JoyShifter[1] = in1 | 0xffffff00;
					break;
				}
				default:
					// standard nes controllers
					JoyShifter[0] = DrvInputs[0] | 0xffffff00;
					JoyShifter[1] = DrvInputs[1] | 0xffffff00;
					break;
			}
		}
		JoyStrobe = data;
		return;
	}

	if (address >= 0x4000 && address <= 0x4017)
	{
		nesapuWrite(0, address & 0x1f, data);
		return;
	}

	if (address >= 0x4020 && psg_area_write) {
		psg_area_write(address, data);
		return;
	}

	if (address == 0x4020 && PPUType > RP2C02) return; // 0x4020: ignore coin counter writes on VS. Unisystem

	bprintf(0, _T("psg_io_write(unmapped) %X    %x\n"), address, data);
}

static UINT8 cpu_ram_read(UINT16 address)
{
	return NES_CPU_RAM[address & 0x7FF];
}

static void cpu_ram_write(UINT16 address, UINT8 data)
{
	NES_CPU_RAM[address & 0x7FF] = data;
}

static UINT8 prg_ram_read(UINT16 address) // expansion ram / rom on the cartridge.
{
	if (cart_exp_read) {
		return cart_exp_read(address);
	}

	// some games get irritated (low g-man, mapper 7: double dragon, battle toads) if prg ram exists
	return (NESMode & NO_WORKRAM) ? cpu_open_bus : Cart.WorkRAM[address & Cart.WorkRAMMask];
}

static void prg_ram_write(UINT16 address, UINT8 data)
{
	if (cart_exp_write) {
		cart_exp_write_abort = 0;
		cart_exp_write(address, data);
		if (cart_exp_write_abort) return;
		// fallthrough if abort wasn't set! :)
	}

	if (NESMode & NO_WORKRAM) return;
	Cart.WorkRAM[address & Cart.WorkRAMMask] = data;
}

// cheat system
static UINT8 gg_bit(UINT8 g)
{
	const UINT8 gg_str[0x11] = "APZLGITYEOXUKSVN";

	for (UINT8 i = 0; i < 0x10; i++) {
		if (g == gg_str[i]) {
			return i;
		}
	}
	return 0;
}

static INT32 gg_decode(char *gg_code, UINT16 &address, UINT8 &value, INT32 &compare)
{
	INT32 type = strlen(gg_code);

	if (type != 6 && type != 8) {
		// bad code!
		return 1;
	}

	UINT8 str_bits[8];

	for (UINT8 i = 0; i < type; i++) {
		str_bits[i] = gg_bit(gg_code[i]);
	}

	address = 0x8000 | ((str_bits[1] & 8) << 4) | ((str_bits[2] & 7) << 4) | ((str_bits[3] & 7) << 12) | ((str_bits[3] & 8) << 0) | ((str_bits[4] & 7) << 0) | ((str_bits[4] & 8) << 8) | ((str_bits[5] & 7) << 8);
	value = ((str_bits[0] & 7) << 0) | ((str_bits[0] & 8) << 4) | ((str_bits[1] & 7) << 4);
	compare = -1;

	switch (type) {
		case 6: {
			value |= ((str_bits[5] & 8) << 0);
			break;
		}
		case 8: {
			value |= ((str_bits[7] & 8) << 0);
			compare = ((str_bits[5] & 8) << 0) | ((str_bits[6] & 7) << 0) | ((str_bits[6] & 8) << 4) | ((str_bits[7] & 7) << 4);
			break;
		}
	}

	return 0;
}

const INT32 cheat_MAX = 0x100;
static INT32 cheats_active = 0;

struct cheat_struct {
	char code[0x10]; // gamegenie code
	UINT16 address;
	UINT8 value;
	INT32 compare; // -1, compare disabled.
};

static cheat_struct cheats[cheat_MAX];

void nes_add_cheat(char *code) // 6/8 character game genie codes allowed
{
	UINT16 address;
	UINT8 value;
	INT32 compare;

	if (!gg_decode(code, address, value, compare) && cheats_active < (cheat_MAX-1)) {
		strncpy(cheats[cheats_active].code, code, 9);
		cheats[cheats_active].address = address;
		cheats[cheats_active].value = value;
		cheats[cheats_active].compare = compare;
		bprintf(0, _T("cheat #%d (%S) added.  (%x, %x, %d)\n"), cheats_active, cheats[cheats_active].code, address, value, compare);
		cheats_active++;
	} else {
		if (cheats_active < (cheat_MAX-1)) {
			bprintf(0, _T("nes cheat engine: bad GameGenie code %S\n"), code);
		} else {
			bprintf(0, _T("nes cheat engine: too many active!\n"));
		}
	}
}

void nes_remove_cheat(char *code)
{
	cheat_struct cheat_temp[cheat_MAX];
	INT32 temp_num = 0;

	for (INT32 i = 0; i < cheats_active; i++) {
		if (strcmp(code, cheats[i].code) != 0) {
			memcpy(&cheat_temp[temp_num], &cheats[i], sizeof(cheat_struct));
			temp_num++;
		} else {
			bprintf(0, _T("cheat %S disabled.\n"), cheats[i].code);
		}
	}

	memcpy(cheats, cheat_temp, sizeof(cheats));
	cheats_active = temp_num;
}

static inline UINT8 cheat_check(UINT16 address, UINT8 value)
{
	for (INT32 i = 0; i < cheats_active; i++) {
		if (cheats[i].address == address && (cheats[i].compare == -1 || cheats[i].compare == value)) {
		 //   bprintf(0, _T("."));
			return cheats[i].value;
		}
	}

	return value;
}


static UINT8 cpu_bus_read(UINT16 address)
{
	UINT8 ret = 0;
	switch (address & 0xe000)
	{
		case 0x0000:  //    0 - 1fff
			ret = cpu_ram_read(address); break;
		case 0x2000:  // 2000 - 3fff
			ret = ppu_read(address); break;
		case 0x4000:  // 4000 - 5fff
			ret = psg_io_read(address); break;
		case 0x6000:  // 6000 - 7fff
			ret = prg_ram_read(address); break;
		default:      // 8000 - ffff
			ret = mapper_prg_read(address); break;
	}

	ret = cheat_check(address, ret);

	cpu_open_bus = ret;

	return ret;
}


#define DEBUG_DMA 0

static void cpu_bus_write(UINT16 address, UINT8 data)
{
	cpu_open_bus = data;

	if (address == 0x4014) { // OAM_DMA
#if DEBUG_DMA
		bprintf(0, _T("DMA, tcyc %d   scanline: %d    pixel: %d\n"), M6502TotalCycles(), scanline, pixel);
#endif
		UINT8 byte = 0;
		M6502Stall(1);		// 1 dummy cyc

		if (M6502TotalCycles() & 1) {
			M6502Stall(1);	// 1 if starts on odd cycle
		}

		for (INT32 i = 0; i < 256; i++) {
			M6502Stall(1); // 1 for cpu_read
			byte = cpu_bus_read(data * 0x100 + i);
			M6502Stall(1); // 1 for cpu_write to ppu
			ppu_write(0x2004, byte);
		}
#if DEBUG_DMA
		bprintf(0, _T("..end-DMA, tcyc %d   scanline: %d    pixel: %d\n"), M6502TotalCycles(), scanline, pixel);
#endif
		return;
	}

	switch (address & 0xe000) {
		case 0x0000: //    0 - 1fff
			cpu_ram_write(address, data); break;
		case 0x2000: // 2000 - 3fff
			ppu_write(address, data); break;
		case 0x4000: // 4000 - 5fff
			psg_io_write(address, data); break;
		case 0x6000: // 6000 - 7fff
			prg_ram_write(address, data); break;
		default:     // 8000 - ffff
			if (mapper_write) mapper_write(address, data);
			return;
	}
}

static INT32 DrvDoReset()
{
	if (RESETMode == RESET_POWER) {
		memset(NES_CPU_RAM, 0x00, 0x800);  // only cleared @ power-on

		if (NESMode & RAM_RANDOM) { // Some games prefer random RAM @ power-on
			UINT8 Pattern[0x08] = { 0x01, 0x5a, 0x01, 0x49, 0xe5, 0xf8, 0xa5, 0x10 };

			for (INT32 i = 0; i < 0x800; i++) {
				NES_CPU_RAM[i] = Pattern[i & 0x07];
			}
		}
	}
	M6502Open(0);
	M6502Reset();
	M6502Close();
	nesapuReset();
	//	if (RESETMode == RESET_POWER) {
	// Nebs 'n Debs thinks we're in 50hz/PAL mode on reset if we don't reset PPU here..
	// note: This is actually due to a bug in the game
		ppu_reset();
	//	}
	mapper_reset();

	JoyShifter[0] = JoyShifter[1] = 0xffffffff;
	JoyStrobe = 0;
	ZapperReloadTimer = 0;

	cyc_counter = 0;
	mega_cyc_counter = 0;

	{
		INT32 nAspectX, nAspectY;
		BurnDrvGetAspect(&nAspectX, &nAspectY);
		if (DrvDips[1] & 1) { // 4:3
			if (nAspectX != 4) {
				bprintf(0, _T("*  NES: Changing to 4:3 aspect\n"));
				BurnDrvSetAspect(4, 3);
				Reinitialise();
			}
		} else { // no aspect ratio handling
			if (nAspectX != SCREEN_WIDTH) {
				bprintf(0, _T("*  NES: Changing to pixel aspect\n"));
				BurnDrvSetAspect(SCREEN_WIDTH, SCREEN_HEIGHT);
				Reinitialise();
			}
		}
	}

	if (PPUType > RP2C02) {
		HiscoreReset();
	}

	return 0;
}

static INT32 NESInit()
{
	nes_init_cheat_functions(nes_add_cheat, nes_remove_cheat);

	GenericTilesInit();

	NES_CPU_RAM = (UINT8*)BurnMalloc(0x800);

	cheats_active = 0;

	struct BurnRomInfo ri;
	char *romname = NULL;
	BurnDrvGetRomInfo(&ri, 0);
	BurnDrvGetRomName(&romname, 0, 0);
	UINT32 length = ri.nLen;
	UINT32 is_FDS = (strstr(romname, ".fds") != 0);
	bprintf(0, _T("ROM Name: %S\n"), romname);
	rom = BurnMalloc((length < 0x100000) ? 0x100000 : length);

	bprintf(0, _T("ROM Length: %d\n"), ri.nLen);
	RESETMode = RESET_POWER;

	if (is_FDS) {
		if (BurnLoadRom(rom + 0x6000, 0x80, 1)) return 1; // bios @ 0xe000
		if (fds_load(rom, ri.nLen, ri.nCrc)) return 1;
	} else {
		if (BurnLoadRom(rom, 0, 1)) return 1;
		if (cartridge_load(rom, ri.nLen, ri.nCrc)) return 1;
	}

	BurnSetRefreshRate((NESMode & IS_PAL) ? 50.00 : 60.00);

	M6502Init(0, TYPE_N2A03);
	M6502Open(0);
	M6502SetWriteHandler(cpu_bus_write);
	M6502SetReadHandler(cpu_bus_read);
	M6502Close();

	ppu_init((NESMode & IS_PAL) ? 1 : 0);

	if (NESMode & IS_PAL) {
		nesapuInitPal(0, 1798773, 0);
	} else {
		nesapuInit(0, 1798773, 0);
	}
	if (NESMode & APU_HACKERY) {
		nesapu4017hack(1);
	}
	nesapuSetAllRoutes(0, 2.40, BURN_SND_ROUTE_BOTH);

	DrvDoReset();

	return 0;
}

static INT32 NES4ScoreInit()
{
	INT32 rc = NESInit();

	NESMode |= USE_4SCORE;

	bprintf(0, _T("*  FourScore 4 Player device.\n"));

	return rc;
}

static INT32 NESHori4pInit()
{
	INT32 rc = NESInit();

	NESMode |= USE_HORI4P;

	bprintf(0, _T("*  Hori 4 Player device (Mode 2).\n"));

	return rc;
}

static INT32 NESReversedInit()
{
	INT32 rc = NESInit();

	NESMode |= VS_REVERSED;

	bprintf(0, _T("*  Inputs reversed (p1/p2 -> p2/p1).\n"));

	return rc;
}

static INT32 NESZapperInit()
{
	INT32 rc = NESInit();

	NESMode |= (PPUType == RP2C02) ? USE_ZAPPER : VS_ZAPPER;
	BurnGunInit(1, true);

	bprintf(0, _T("*  Zapper on Port #2.\n"));

	return rc;
}

// stereo effector (delay line+comb filter)
struct ms_ring {
	INT16 *l;
	INT16 *r;
	INT32 ring_size;
	INT32 inpos;
	INT32 outpos_l;
	INT32 outpos_r;

	void exit() {
		if (ring_size || l || r) {
			BurnFree(l);
			BurnFree(r);
			ring_size = 0;
			bprintf(0, _T("ms_ring exited.\n"));
		}
	}

	void init() {
		ring_size = (INT32)((double)14 / 1000 * nBurnSoundRate); // 14ms ring buffer

		l = (INT16*)BurnMalloc(ring_size * sizeof(INT16));
		r = (INT16*)BurnMalloc(ring_size * sizeof(INT16));

		for (INT32 i = 0; i < ring_size; i++) {
			write(0, 0);
		}
		inpos = 0; // position in @ beginning of ring, out @ end
		outpos_l = 1;
		outpos_r = 1;
		bprintf(0, _T("ms_ring initted (%d entry ringbuffer)\n"), ring_size);
	}

	INT32 needs_init() {
		return (l == NULL || r == NULL || ring_size == 0);
	}

	void write(INT16 sam_l, INT16 sam_r) {
		l[inpos] = sam_l;
		r[inpos] = sam_r;
		inpos = (inpos + 1) % ring_size;
	}

	INT16 read_r() {
		INT16 temp = r[outpos_r];
		outpos_r = (outpos_r + 1) % ring_size;
		return temp;
	}

	INT16 read_l() {
		INT16 temp = l[outpos_l];
		outpos_l = (outpos_l + 1) % ring_size;
		return temp;
	}

	void process(INT16 *buffer, INT32 samples) {
		if (needs_init()) {
			init();
		}

		for (INT32 i = 0; i < samples; i++) {
			write(buffer[i * 2 + 0], buffer[i * 2 + 1]);
			INT16 sam_mask = ((read_l(), read_r()) / 2) * 0.75;
			INT16 sam_now = (buffer[i * 2 + 0] + buffer[i * 2 + 1]) / 2;
			buffer[i * 2 + 0] = sam_now + sam_mask;
			buffer[i * 2 + 1] = sam_now - sam_mask;
		}
	}
};

static ms_ring ms_delay;

// end stereoeffect

static INT32 NESExit()
{
	GenericTilesExit();
	M6502Exit();
	nesapuExit();

	// Mapper EXT-hardware exits
	if (Cart.Mapper == 69) { // SunSoft fme-7 (5b) audio expansion - ay8910. mapper69
		AY8910Exit(0);
	}

	if (Cart.Mapper == 85) { // VRC7 audio expansion - ym2413
		BurnYM2413Exit();
	}

	if (NESMode & FLASH_EEPROM) {
		TCHAR desc[64];
		_stprintf(desc, _T("Mapper %d"), Cart.Mapper);

		// Save IPS patch (aka: flasheeprom-saves @ exit)
		SaveIPSPatch(desc, Cart.CartOrig, Cart.Cart, Cart.CartSize);
	}

	if (Cart.FDSMode) {
		// exit saver:
		SaveIPSPatch(_T("FDS DISK"), Cart.FDSDiskRawOrig, Cart.FDSDiskRaw, Cart.FDSDiskRawSize);

		BurnFree(Cart.FDSDiskRaw);
		BurnFree(Cart.FDSDiskRawOrig);

		BurnLEDExit();
	}

	if (NESMode & (USE_ZAPPER | VS_ZAPPER))
		BurnGunExit();

	BurnFree(Cart.CartOrig);
	BurnFree(rom);
	BurnFree(NES_CPU_RAM);
	BurnFree(Cart.WorkRAM);
	BurnFree(Cart.CHRRam);

	ms_delay.exit();

	NESMode = 0;

	return 0;
}

static UINT32 EmphRGB(INT32 pal_idx, UINT8 type, UINT32 *palette)
{
/*
	dink ppu color emphasis notes
	ppumask	register	(reg >> 5) (r/g swapped for PAL)

	red		20		 	1
	green	40			2
	blue	80			4

	// All possible combinations, palette offset, (reg >> 5)
	normal	0-3f		0
	r		40-7f		1
	g		80-bf		2
	rg		c0-ff		3
	b		100 - 13f	4
	rb		140 - 17f	5
	gb		180 - 1bf	6
	rgb		1c0 - 1ff	7
*/

	UINT64 er = 1.0 * (1 << 16);
	UINT64 eg = 1.0 * (1 << 16);
	UINT64 eb = 1.0 * (1 << 16);
	UINT32 EMPH   = 1.2 * (1 << 16);
	UINT32 DEEMPH = 0.8 * (1 << 16);
	if (type & 1) {
		er = (er *   EMPH) >> 16;
		eg = (eg * DEEMPH) >> 16;
		eb = (eb * DEEMPH) >> 16;
	}
	if (type & 2) {
		er = (er * DEEMPH) >> 16;
		eg = (eg *   EMPH) >> 16;
		eb = (eb * DEEMPH) >> 16;
	}
	if (type & 4) {
		er = (er * DEEMPH) >> 16;
		eg = (eg * DEEMPH) >> 16;
		eb = (eb *   EMPH) >> 16;
	}

	UINT32 r = (((palette[pal_idx & 0x3f] >> 16) & 0xff) * er) >> 16;
	if (r > 0xff) r = 0xff;
	UINT32 g = (((palette[pal_idx & 0x3f] >>  8) & 0xff) * eg) >> 16;
	if (g > 0xff) g = 0xff;
	UINT32 b = (((palette[pal_idx & 0x3f] >>  0) & 0xff) * eb) >> 16;
	if (b > 0xff) b = 0xff;

	return BurnHighCol(r, g, b, 0);
}

static void DrvCalcPalette()
{
	UpdatePalettePointer();

	// Normal NES Palette
	for (INT32 i = 0; i < 0x40; i++) {
		DrvPalette[i] = BurnHighCol((our_palette[i] >> 16) & 0xff, (our_palette[i] >> 8) & 0xff, our_palette[i] & 0xff, 0);
	}

	// Emphasized Palettes (all combinations, see comments-table in EmphRGB)
	for (INT32 i = 0x40; i < 0x200; i++) {
		DrvPalette[i] = EmphRGB(i, i >> 6, our_palette);
	}

	// Palette for the FDS Swap Disk icon
	for (INT32 fadelv = 0; fadelv < 0x10; fadelv++) {
		for (INT32 i = 0x200; i < 0x210; i++) {
			DrvPalette[i + (fadelv * 0x10)] = BurnHighCol(disk_ab_pal[(i & 0xf) * 3 + 2] / (fadelv + 1), disk_ab_pal[(i & 0xf) * 3 + 1] / (fadelv + 1), disk_ab_pal[(i & 0xf) * 3 + 0] / (fadelv + 1), 0);
		}
	}
}

static INT32 NESDraw()
{
	if (NESRecalc || last_palette != DIP_PALETTE) {
		DrvCalcPalette();
		NESRecalc = 0;
		last_palette = DIP_PALETTE;
	}

	if ((NESMode & IS_FDS) && (FDSFrameAction == SWAP_DISK || FDSFrameAction == FA_FADEOUT)) {
		static INT32 fader = 0;
		if (FDSFrameAction == SWAP_DISK) fader = 0;
		if (FDSFrameAction == FA_FADEOUT && ((FDSFrameCounter%2)==0)) {
			if (fader < 0x8)
				fader++;
		}

		switch (FDSFrameDiskIcon) {
			case 0:
				RenderCustomTile(pTransDraw, 38, 18, 0, 109/*x*/, 100/*y*/, 0, 8, 0x200 + (fader * 0x10), &disk_ab[0]);
				break;
			case 1:
				RenderCustomTile(pTransDraw, 38, 18, 0, 109/*x*/, 100/*y*/, 0, 8, 0x200 + (fader * 0x10), &disk_ab[18*38]);
				break;
		}
	}

	BurnTransferCopy(DrvPalette);

	if (NESMode & (USE_ZAPPER | VS_ZAPPER))
		BurnGunDrawTargets();

	if (NESMode & IS_FDS)
		BurnLEDRender();

	return 0;
}

static void clear_opposites(UINT8 &inpt)
{
	// some games will straight-up crash or go berzerk if up+down or left+right
	// is pressed.  This can easily happen when playing via kbd or severly
	// worn gamepad.

	if ((inpt & ( (1 << 4) | (1 << 5) )) == ((1 << 4) | (1 << 5)) )
		inpt &= ~((1 << 4) | (1 << 5)); // up + down pressed, cancel both

	if ((inpt & ( (1 << 6) | (1 << 7) )) == ((1 << 6) | (1 << 7)) )
		inpt &= ~((1 << 6) | (1 << 7)); // left + right pressed, cancel both
}

#define DEBUG_CYC 0

//#define nes_frame_cycles 29781(ntsc) 33248(pal)

INT32 nes_scanline()
{
	return scanline;
}

static INT32 NESFrame()
{
#if DEBUG_CYC
	bprintf(0, _T("enter frame:  scanline %d   pixel %d  ppucyc %d    cyc_counter %d\n"), scanline, pixel, ppu_framecycles, cyc_counter);
#endif
	if (DrvReset)
	{
		RESETMode = RESET_BUTTON;
		DrvDoReset();
	}

	{	// compile inputs!
		DrvInputs[0] = DrvInputs[1] = 0x00;
		DrvInputs[2] = DrvInputs[3] = 0x00;
		for (INT32 i = 0; i < 8; i++) {
			DrvInputs[0] ^= (NESJoy1[i] & 1) << i;
			DrvInputs[1] ^= (NESJoy2[i] & 1) << i;
			DrvInputs[2] ^= (NESJoy3[i] & 1) << i;
			DrvInputs[3] ^= (NESJoy4[i] & 1) << i;
		}

		clear_opposites(DrvInputs[0]);
		clear_opposites(DrvInputs[1]);
		clear_opposites(DrvInputs[2]);
		clear_opposites(DrvInputs[3]);

		if (NESMode & (USE_ZAPPER | VS_ZAPPER)) {
			BurnGunMakeInputs(0, ZapperX, ZapperY);

			if (ZapperReloadTimer) {
				ZapperReloadTimer--;
			}
		}

		if (NESMode & IS_FDS) {
			FDS_Insert(FDSEject);

			if (~DrvDips[0] & 2) {
				FDS_FrameTicker();
				FDS_SwapSidesAuto(FDSSwap);
			} else {
				FDS_SwapSides(FDSSwap);
			}
		}
	}

	M6502Open(0);
	M6502NewFrame();
	M6502Idle(cyc_counter);
	cyc_counter = 0;
#if DEBUG_CYC
	INT32 last_ppu = ppu_framecycles;
#endif
	if (ppu_over > 0) { // idle away extra ppu cycles
		ppu_framecycles = ppu_over;
		ppu_over = 0;
	} else {
		ppu_framecycles = 0;
	}

	for (INT32 i = 0; i < nes_frame_cycles; i++)
	{
		cyc_counter ++; // frame-based
		mega_cyc_counter ++; // "since reset"-based

		nesapu_runclock(cyc_counter - 1);  // clock dmc & external sound (n163, vrc, fds)

		if ((cyc_counter - M6502TotalCycles()) > 0)	{
			M6502Run(cyc_counter - M6502TotalCycles());
			// to debug game hard-lock: uncomment and press n 4 times to get pc.
			// tip: 99.9% its either a mapper bug or game needs ALT_TIMING flag
#if defined (FBNEO_DEBUG)
			extern int counter;
			if (counter == -4) bprintf(0, _T("PC:  %x   tc: %d   cyc_ctr: %d\n"), M6502GetPC(-1), M6502TotalCycles(), cyc_counter);
#endif
		}

		mapper_run();

		INT32 p_cyc = (cyc_counter * nes_ppu_cyc_mult) - ppu_framecycles;
		if (p_cyc > 0) {
			ppu_run(p_cyc);
		}
	}

	if (NESMode & ALT_TIMING) {
		ppu_framecycles--;
	}
	if (NESMode & IS_PAL) {
		ppu_over = ppu_framecycles - 106392;
	} else {
		ppu_over = ppu_framecycles - ((~NESMode & ALT_TIMING) ? 89342 : 89343);
	}

#if DEBUG_CYC
	INT32 cc = cyc_counter;
#endif

	cyc_counter = M6502TotalCycles() - nes_frame_cycles; // the overflow of cycles for next frame to idle away

#if DEBUG_CYC
	bprintf(0, _T("6502 cycles ran: %d   cyc_counter %d   rollover: %d    ppu.over %d   ppu.framecyc %d    last_ppu %d\n"), M6502TotalCycles(), cc, cyc_counter, ppu_over, ppu_framecycles, last_ppu);
#endif

	if (pBurnSoundOut) {
		nesapuSetDMCBitDirection(DrvDips[1] & 8);
		nesapuUpdate(0, pBurnSoundOut, nBurnSoundLen);
		BurnSoundDCFilter();

		// Mapper EXT-hardware sound renders
		if (Cart.Mapper == 69) { // SunSoft fme-7 (5b) audio expansion - ay8910. mapper69
			AY8910Render(pBurnSoundOut, nBurnSoundLen);
		}

		if (Cart.Mapper == 85) { // VRC7 audio expansion - YM2413
			BurnYM2413Render(pBurnSoundOut, nBurnSoundLen);
		}

		if (DrvDips[1] & 0x02) {
			ms_delay.process(pBurnSoundOut, nBurnSoundLen);
		}
	}
	M6502Close();

	if (pBurnDraw)
	{
		NESDraw();
	}
	return 0;
}

static INT32 NESScan(INT32 nAction, INT32 *pnMin)
{
	if (pnMin) {
		*pnMin = 0x029708;
	}

	if (nAction & ACB_VOLATILE) {
		M6502Scan(nAction);
		nesapuScan(nAction, pnMin);

		SCAN_VAR(cpu_open_bus);
		SCAN_VAR(cyc_counter);
		SCAN_VAR(JoyShifter);
		SCAN_VAR(JoyStrobe);
		SCAN_VAR(ZapperReloadTimer);

		ScanVar(NES_CPU_RAM, 0x800, "CPU Ram");
		ScanVar(Cart.WorkRAM, Cart.WorkRAMSize, "Work Ram");
		ScanVar(Cart.CHRRam, Cart.CHRRamSize, "CHR Ram");

		mapper_scan(nAction, pnMin);

		ppu_scan(nAction);

		// Mapper EXT-hardware sound scans
		if (Cart.Mapper == 69) { // SunSoft fme-7 (5b) audio expansion - ay8910. mapper69
			AY8910Scan(nAction, pnMin);
		}
		if (Cart.Mapper == 85) { // VRC7 audio expansion - YM2413
			BurnYM2413Scan(nAction, pnMin);
		}

		if (NESMode & (USE_ZAPPER | VS_ZAPPER))
			BurnGunScan();

		if (nAction & ACB_WRITE) {
			// save for later?
		}
	}

	if (nAction & ACB_NVRAM) {
		if (Cart.BatteryBackedSRAM) {
			ScanVar(Cart.WorkRAM, Cart.WorkRAMSize, "s-ram");
		}

		if (mapper_scan_cb_nvram) {
			mapper_scan_cb_nvram();
		}
	}

	return 0;
}

static INT32 NESGetZipName(char** pszName, UINT32 i)
{
	static char szFilename[MAX_PATH];
	char* pszGameName = NULL;

	if (pszName == NULL) {
		return 1;
	}

	if (i == 0) {
		pszGameName = BurnDrvGetTextA(DRV_NAME);
	} else {
		if (i == 1 && BurnDrvGetTextA(DRV_BOARDROM)) {
			pszGameName = BurnDrvGetTextA(DRV_BOARDROM);
		} else {
			pszGameName = BurnDrvGetTextA(DRV_PARENT);
		}
	}

	if (pszGameName == NULL || i > 2) {
		*pszName = NULL;
		return 1;
	}

	// remove nes_
	memset(szFilename, 0, MAX_PATH);
	for (UINT32 j = 0; j < (strlen(pszGameName) - 4); j++) {
		szFilename[j] = pszGameName[j+4];
	}

	*pszName = szFilename;

	return 0;
}

// -------------------------
// FDS 'Famicom Disk System'
// -------------------------

static struct BurnRomInfo emptyRomDesc[] = {
	{ "",                    0,          0, 0 },
};

// FDS System BIOS
static struct BurnRomInfo fds_fdsbiosRomDesc[] = {
    { "fdsbios.nes",     0x2000, 0x5e607dcf, BRF_BIOS }, // 0x80 - standard bios
};

STD_ROM_PICK(fds_fdsbios)
STD_ROM_FN(fds_fdsbios)

struct BurnDriver BurnDrvfds_fdsbios = {
	"fds_fdsbios", NULL, NULL, NULL, "198x",
	"FDS System BIOS\0", "BIOS only", "NES", "NES",
	NULL, NULL, NULL, NULL,
	BDF_BOARDROM, 0, HARDWARE_FDS, GBF_BIOS, 0,
	NESGetZipName, fds_fdsbiosRomInfo, fds_fdsbiosRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// FDS IRQ Test (Sour, v7)
static struct BurnRomInfo fds_fdsirqtestRomDesc[] = {
	{ "fdsirqtests.fds",          65516, 0xa5a63b30, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_fdsirqtest, fds_fdsirqtest, fds_fdsbios)
STD_ROM_FN(fds_fdsirqtest)

struct BurnDriver BurnDrvfds_fdsirqtest = {
	"fds_fdsirqtest", NULL, "fds_fdsbios", NULL, "1989?",
	"FDS IRQ Test (Sour, v7)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_MISC, 0,
	NESGetZipName, fds_fdsirqtestRomInfo, fds_fdsirqtestRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// 19 - Neunzehn (Japan)
static struct BurnRomInfo fds_19neunzehnjRomDesc[] = {
	{ "19 - Neunzehn (Japan).fds",          131016, 0xe6e06610, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_19neunzehnj, fds_19neunzehnj, fds_fdsbios)
STD_ROM_FN(fds_19neunzehnj)

struct BurnDriver BurnDrvfds_19neunzehnj = {
	"fds_19neunzehnj", "fds_19neunzehn", "fds_fdsbios", NULL, "1988",
	"19 - Neunzehn (Japan)\0", NULL, "Soft Pro", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_FDS, GBF_STRATEGY, 0,
	NESGetZipName, fds_19neunzehnjRomInfo, fds_19neunzehnjRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// 19 - Neunzehn (Hack, English)
// https://www.romhacking.net/translations/2490/
static struct BurnRomInfo fds_19neunzehnRomDesc[] = {
	{ "19 - Neunzehn (T-Eng).fds",          131000, 0xda11432a, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_19neunzehn, fds_19neunzehn, fds_fdsbios)
STD_ROM_FN(fds_19neunzehn)

struct BurnDriver BurnDrvfds_19neunzehn = {
	"fds_19neunzehn", NULL, "fds_fdsbios", NULL, "2015",
	"19 - Neunzehn (Hack, English)\0", NULL, "MrRichard999", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_FDS, GBF_STRATEGY, 0,
	NESGetZipName, fds_19neunzehnRomInfo, fds_19neunzehnRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Adian no Tsue (Japan)
static struct BurnRomInfo fds_adiannotsueRomDesc[] = {
	{ "Adian no Tsue (Japan).fds",          131000, 0xdcc7a8d6, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_adiannotsue, fds_adiannotsue, fds_fdsbios)
STD_ROM_FN(fds_adiannotsue)

struct BurnDriver BurnDrvfds_adiannotsue = {
	"fds_adiannotsue", NULL, "fds_fdsbios", NULL, "1986",
	"Adian no Tsue (Japan)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_QUIZ, 0,
	NESGetZipName, fds_adiannotsueRomInfo, fds_adiannotsueRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ai Senshi Nicol (Japan)
static struct BurnRomInfo fds_aisenshinicolRomDesc[] = {
	{ "Ai Senshi Nicol (Japan).fds",          131000, 0x21a1ad6e, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_aisenshinicol, fds_aisenshinicol, fds_fdsbios)
STD_ROM_FN(fds_aisenshinicol)

struct BurnDriver BurnDrvfds_aisenshinicol = {
	"fds_aisenshinicol", NULL, "fds_fdsbios", NULL, "1987",
	"Ai Senshi Nicol (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_RUNGUN | GBF_ADV, 0,
	NESGetZipName, fds_aisenshinicolRomInfo, fds_aisenshinicolRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Aki to Tsukasa no Fushigi no Kabe (Japan)
static struct BurnRomInfo fds_akitsunofusnokaRomDesc[] = {
	{ "Aki to Tsukasa no Fushigi no Kabe (Japan).fds",          131016, 0xd7b4a01e, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_akitsunofusnoka, fds_akitsunofusnoka, fds_fdsbios)
STD_ROM_FN(fds_akitsunofusnoka)

struct BurnDriver BurnDrvfds_akitsunofusnoka = {
	"fds_akitsunofusnoka", NULL, "fds_fdsbios", NULL, "1988",
	"Aki to Tsukasa no Fushigi no Kabe (Japan)\0", NULL, "Super Pig", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_BREAKOUT | GBF_PUZZLE, 0,
	NESGetZipName, fds_akitsunofusnokaRomInfo, fds_akitsunofusnokaRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Akumajou Dracula (Japan)
static struct BurnRomInfo fds_akumajoudraculajRomDesc[] = {
	{ "Akumajou Dracula (Japan).fds",          131016, 0xffed3158, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_akumajoudraculaj, fds_akumajoudraculaj, fds_fdsbios)
STD_ROM_FN(fds_akumajoudraculaj)

struct BurnDriver BurnDrvfds_akumajoudraculaj = {
	"fds_akumajoudraculaj", "fds_akumajoudracula", "fds_fdsbios", NULL, "1986",
	"Akumajou Dracula (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_FDS, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, fds_akumajoudraculajRomInfo, fds_akumajoudraculajRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Akumajou Dracula (Hack, English)
// https://www.romhacking.net/translations/5543/
static struct BurnRomInfo fds_akumajoudraculaRomDesc[] = {
	{ "Akumajou Dracula (T-Eng).fds",          131016, 0xf72f22af, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_akumajoudracula, fds_akumajoudracula, fds_fdsbios)
STD_ROM_FN(fds_akumajoudracula)

struct BurnDriver BurnDrvfds_akumajoudracula = {
	"fds_akumajoudracula", NULL, "fds_fdsbios", NULL, "2020",
	"Akumajou Dracula (Hack, English)\0", NULL, "DvD Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_FDS, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, fds_akumajoudraculaRomInfo, fds_akumajoudraculaRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Akuu Senki Raijin (Japan)
static struct BurnRomInfo fds_akuusenraiRomDesc[] = {
	{ "Akuu Senki Raijin (Japan).fds",          131016, 0x5117e64d, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_akuusenrai, fds_akuusenrai, fds_fdsbios)
STD_ROM_FN(fds_akuusenrai)

struct BurnDriver BurnDrvfds_akuusenrai = {
	"fds_akuusenrai", NULL, "fds_fdsbios", NULL, "1988",
	"Akuu Senki Raijin (Japan)\0", NULL, "Square", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_RUNGUN | GBF_VERSHOOT, 0,
	NESGetZipName, fds_akuusenraiRomInfo, fds_akuusenraiRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// All Night Nippon Super Mario Brothers (Japan)
static struct BurnRomInfo fds_allnignipsupmabrRomDesc[] = {
	{ "All Night Nippon Super Mario Brothers (Japan).fds",          65500, 0x43e7fe95, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_allnignipsupmabr, fds_allnignipsupmabr, fds_fdsbios)
STD_ROM_FN(fds_allnignipsupmabr)

struct BurnDriver BurnDrvfds_allnignipsupmabr = {
	"fds_allnignipsupmabr", NULL, "fds_fdsbios", NULL, "1986",
	"All Night Nippon Super Mario Brothers (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_PLATFORM, 0,
	NESGetZipName, fds_allnignipsupmabrRomInfo, fds_allnignipsupmabrRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Apple Town Monogatari - Little Computer People (Japan)
static struct BurnRomInfo fds_appletowmonRomDesc[] = {
	{ "Apple Town Monogatari - Little Computer People (Japan).fds",          131016, 0xbf89dd4a, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_appletowmon, fds_appletowmon, fds_fdsbios)
STD_ROM_FN(fds_appletowmon)

struct BurnDriver BurnDrvfds_appletowmon = {
	"fds_appletowmon", NULL, "fds_fdsbios", NULL, "1987",
	"Apple Town Monogatari - Little Computer People (Japan)\0", NULL, "Square", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_ADV, 0,
	NESGetZipName, fds_appletowmonRomInfo, fds_appletowmonRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Armana no Kiseki (Japan)
static struct BurnRomInfo fds_armananokisekijRomDesc[] = {
	{ "Armana no Kiseki (Japan).fds",          131016, 0x0bad64a5, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_armananokisekij, fds_armananokisekij, fds_fdsbios)
STD_ROM_FN(fds_armananokisekij)

struct BurnDriver BurnDrvfds_armananokisekij = {
	"fds_armananokisekij", "fds_armananokiseki", "fds_fdsbios", NULL, "1987",
	"Armana no Kiseki (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_FDS, GBF_PLATFORM, 0,
	NESGetZipName, fds_armananokisekijRomInfo, fds_armananokisekijRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Armana no Kiseki (Hack, English)
// https://www.romhacking.net/translations/1696/
static struct BurnRomInfo fds_armananokisekiRomDesc[] = {
	{ "Armana no Kiseki (T-Eng).fds",          131000, 0x8b61e398, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_armananokiseki, fds_armananokiseki, fds_fdsbios)
STD_ROM_FN(fds_armananokiseki)

struct BurnDriver BurnDrvfds_armananokiseki = {
	"fds_armananokiseki", NULL, "fds_fdsbios", NULL, "2012",
	"Armana no Kiseki (Hack, English)\0", NULL, "DvD Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_FDS, GBF_PLATFORM, 0,
	NESGetZipName, fds_armananokisekiRomInfo, fds_armananokisekiRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Aspic - Majaou no Noroi (Japan)
static struct BurnRomInfo fds_aspicjRomDesc[] = {
	{ "Aspic - Majaou no Noroi (J)(1988)(Bothtec).fds",          131000, 0x1999addb, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_aspicj, fds_aspicj, fds_fdsbios)
STD_ROM_FN(fds_aspicj)

struct BurnDriver BurnDrvfds_aspicj = {
	"fds_aspicj", "fds_aspic", "fds_fdsbios", NULL, "1988",
	"Aspic - Majaou no Noroi (Japan)\0", NULL, "Bothtec", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_FDS, GBF_RPG, 0,
	NESGetZipName, fds_aspicjRomInfo, fds_aspicjRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Aspic - Curse of the Snakelord (Hack, English)
// https://www.romhacking.net/translations/6861/
static struct BurnRomInfo fds_aspicRomDesc[] = {
	{ "Aspic - Curse of the Snakelord T-Eng (2023)(BlackPaladin).fds",          131000, 0x9f1976dd, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_aspic, fds_aspic, fds_fdsbios)
STD_ROM_FN(fds_aspic)

struct BurnDriver BurnDrvfds_aspic = {
	"fds_aspic", NULL, "fds_fdsbios", NULL, "2023",
	"Aspic - Curse of the Snakelord (Hack, English)\0", NULL, "BlackPaladin", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_FDS, GBF_RPG, 0,
	NESGetZipName, fds_aspicRomInfo, fds_aspicRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bakutoushi Patton-kun (Japan)
static struct BurnRomInfo fds_bakutpatkunRomDesc[] = {
	{ "Bakutoushi Patton-kun (Japan).fds",          131016, 0xbdb5104d, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_bakutpatkun, fds_bakutpatkun, fds_fdsbios)
STD_ROM_FN(fds_bakutpatkun)

struct BurnDriver BurnDrvfds_bakutpatkun = {
	"fds_bakutpatkun", NULL, "fds_fdsbios", NULL, "1988",
	"Bakutoushi Patton-kun (Japan)\0", NULL, "Soft Pro", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_FDS, GBF_ACTION, 0,
	NESGetZipName, fds_bakutpatkunRomInfo, fds_bakutpatkunRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Big Challenge! Dogfight Spirit (Japan)
static struct BurnRomInfo fds_bigchadogspiRomDesc[] = {
	{ "Big Challenge! Dogfight Spirit (Japan).fds",          131016, 0xfcdb9fc9, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_bigchadogspi, fds_bigchadogspi, fds_fdsbios)
STD_ROM_FN(fds_bigchadogspi)

struct BurnDriver BurnDrvfds_bigchadogspi = {
	"fds_bigchadogspi", NULL, "fds_fdsbios", NULL, "1988",
	"Big Challenge! Dogfight Spirit (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_VERSHOOT, 0,
	NESGetZipName, fds_bigchadogspiRomInfo, fds_bigchadogspiRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Big Challenge! Go! Go! Bowling (Japan)
static struct BurnRomInfo fds_bigchagogoboRomDesc[] = {
	{ "Big Challenge! Go! Go! Bowling (Japan).fds",          131016, 0x11519f4a, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_bigchagogobo, fds_bigchagogobo, fds_fdsbios)
STD_ROM_FN(fds_bigchagogobo)

struct BurnDriver BurnDrvfds_bigchagogobo = {
	"fds_bigchagogobo", NULL, "fds_fdsbios", NULL, "1989",
	"Big Challenge! Go! Go! Bowling (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_FDS, GBF_SPORTSMISC, 0,
	NESGetZipName, fds_bigchagogoboRomInfo, fds_bigchagogoboRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Big Challenge! Gun Fighter (Japan)
static struct BurnRomInfo fds_bigchagunfigRomDesc[] = {
	{ "Big Challenge! Gun Fighter (Japan).fds",          131016, 0x691cb0c1, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_bigchagunfig, fds_bigchagunfig, fds_fdsbios)
STD_ROM_FN(fds_bigchagunfig)

struct BurnDriver BurnDrvfds_bigchagunfig = {
	"fds_bigchagunfig", NULL, "fds_fdsbios", NULL, "1989",
	"Big Challenge! Gun Fighter (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, fds_bigchagunfigRomInfo, fds_bigchagunfigRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Big Challenge! Juudou Senshuken (Japan)
static struct BurnRomInfo fds_bigchajuusenRomDesc[] = {
	{ "Big Challenge! Juudou Senshuken (Japan).fds",          131016, 0xa65712a7, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_bigchajuusen, fds_bigchajuusen, fds_fdsbios)
STD_ROM_FN(fds_bigchajuusen)

struct BurnDriver BurnDrvfds_bigchajuusen = {
	"fds_bigchajuusen", NULL, "fds_fdsbios", NULL, "1988",
	"Big Challenge! Juudou Senshuken (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_VSFIGHT, 0,
	NESGetZipName, fds_bigchajuusenRomInfo, fds_bigchajuusenRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bio Miracle Bokutte Upa (Japan)
static struct BurnRomInfo fds_biomirbokupaRomDesc[] = {
	{ "Bio Miracle Bokutte Upa (Japan).fds",          131016, 0x75e44b0d, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_biomirbokupa, fds_biomirbokupa, fds_fdsbios)
STD_ROM_FN(fds_biomirbokupa)

struct BurnDriver BurnDrvfds_biomirbokupa = {
	"fds_biomirbokupa", NULL, "fds_fdsbios", NULL, "1988",
	"Bio Miracle Bokutte Upa (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_PLATFORM, 0,
	NESGetZipName, fds_biomirbokupaRomInfo, fds_biomirbokupaRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bomber Man (Japan)
static struct BurnRomInfo fds_bombermanRomDesc[] = {
	{ "Bomber Man (Japan).fds",          65516, 0x4f7bee06, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_bomberman, fds_bomberman, fds_fdsbios)
STD_ROM_FN(fds_bomberman)

struct BurnDriver BurnDrvfds_bomberman = {
	"fds_bomberman", NULL, "fds_fdsbios", NULL, "1990",
	"Bomber Man (Japan)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_MAZE | GBF_ACTION, 0,
	NESGetZipName, fds_bombermanRomInfo, fds_bombermanRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bubble Bobble (Japan)
static struct BurnRomInfo fds_bubblebobbleRomDesc[] = {
	{ "Bubble Bobble (Japan).fds",          131000, 0x8c8d153e, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_bubblebobble, fds_bubblebobble, fds_fdsbios)
STD_ROM_FN(fds_bubblebobble)

struct BurnDriver BurnDrvfds_bubblebobble = {
	"fds_bubblebobble", NULL, "fds_fdsbios", NULL, "1988",
	"Bubble Bobble (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_PLATFORM, 0,
	NESGetZipName, fds_bubblebobbleRomInfo, fds_bubblebobbleRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// BurgerTime (Japan)
static struct BurnRomInfo fds_burgertimeRomDesc[] = {
	{ "BurgerTime (Japan).fds",          65516, 0x44e41aba, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_burgertime, fds_burgertime, fds_fdsbios)
STD_ROM_FN(fds_burgertime)

struct BurnDriver BurnDrvfds_burgertime = {
	"fds_burgertime", NULL, "fds_fdsbios", NULL, "1987",
	"BurgerTime (Japan)\0", NULL, "Data East", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_ACTION, 0,
	NESGetZipName, fds_burgertimeRomInfo, fds_burgertimeRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Chitei Tairiku Ordola (Japan)
static struct BurnRomInfo fds_chitetaiordRomDesc[] = {
	{ "Chitei Tairiku Ordola (Japan).fds",          131000, 0xaacd4f64, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_chitetaiord, fds_chitetaiord, fds_fdsbios)
STD_ROM_FN(fds_chitetaiord)

struct BurnDriver BurnDrvfds_chitetaiord = {
	"fds_chitetaiord", NULL, "fds_fdsbios", NULL, "1987",
	"Chitei Tairiku Ordola (Japan)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_MISC, 0,
	NESGetZipName, fds_chitetaiordRomInfo, fds_chitetaiordRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Clu Clu Land (Japan)
static struct BurnRomInfo fds_cluclulandRomDesc[] = {
	{ "Clu Clu Land (Japan).fds",          65516, 0x72d0bde6, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_clucluland, fds_clucluland, fds_fdsbios)
STD_ROM_FN(fds_clucluland)

struct BurnDriver BurnDrvfds_clucluland = {
	"fds_clucluland", NULL, "fds_fdsbios", NULL, "1988",
	"Clu Clu Land (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_ACTION, 0,
	NESGetZipName, fds_cluclulandRomInfo, fds_cluclulandRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cocona World (Japan)
static struct BurnRomInfo fds_coconaworldRomDesc[] = {
	{ "Cocona World (Japan).fds",          131016, 0x0b429e6c, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_coconaworld, fds_coconaworld, fds_fdsbios)
STD_ROM_FN(fds_coconaworld)

struct BurnDriver BurnDrvfds_coconaworld = {
	"fds_coconaworld", NULL, "fds_fdsbios", NULL, "1987",
	"Cocona World (Japan)\0", NULL, "Sofel", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_ADV, 0,
	NESGetZipName, fds_coconaworldRomInfo, fds_coconaworldRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dandy - Zeuon no Fukkatsu (Japan)
static struct BurnRomInfo fds_dandyjRomDesc[] = {
	{ "Dandy - Zeuon no Fukkatsu (Japan).fds",          131016, 0xa2bfcbcc, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_dandyj, fds_dandyj, fds_fdsbios)
STD_ROM_FN(fds_dandyj)

struct BurnDriver BurnDrvfds_dandyj = {
	"fds_dandyj", "fds_dandy", "fds_fdsbios", NULL, "1988",
	"Dandy - Zeuon no Fukkatsu (Japan)\0", NULL, "Pony Canyon", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_FDS, GBF_RPG, 0,
	NESGetZipName, fds_dandyjRomInfo, fds_dandyjRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dandy - Zeuon no Fukkatsu (Hack, English)
// https://www.romhacking.net/translations/6395/
static struct BurnRomInfo fds_dandyRomDesc[] = {
	{ "Dandy - Zeuon no Fukkatsu (T-Eng).fds",          131383, 0x29a1613f, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_dandy, fds_dandy, fds_fdsbios)
STD_ROM_FN(fds_dandy)

struct BurnDriver BurnDrvfds_dandy = {
	"fds_dandy", NULL, "fds_fdsbios", NULL, "2021",
	"Dandy - Zeuon no Fukkatsu (Hack, English)\0", NULL, "Stardust Crusaders", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_FDS, GBF_RPG, 0,
	NESGetZipName, fds_dandyRomInfo, fds_dandyRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dead Zone (Japan)
static struct BurnRomInfo fds_deadzonejRomDesc[] = {
	{ "Dead Zone (Japan).fds",          131000, 0xde673254, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_deadzonej, fds_deadzonej, fds_fdsbios)
STD_ROM_FN(fds_deadzonej)

struct BurnDriver BurnDrvfds_deadzonej = {
	"fds_deadzonej", "fds_deadzone", "fds_fdsbios", NULL, "1986",
	"Dead Zone (Japan)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_FDS, GBF_ADV, 0,
	NESGetZipName, fds_deadzonejRomInfo, fds_deadzonejRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dead Zone (Hack, English)
// https://www.romhacking.net/translations/5154/
static struct BurnRomInfo fds_deadzoneRomDesc[] = {
	{ "Dead Zone (T-Eng).fds",          131000, 0x1bf2409a, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_deadzone, fds_deadzone, fds_fdsbios)
STD_ROM_FN(fds_deadzone)

struct BurnDriver BurnDrvfds_deadzone = {
	"fds_deadzone", NULL, "fds_fdsbios", NULL, "2019",
	"Dead Zone (Hack, English)\0", NULL, "Stardust Crusaders", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_FDS, GBF_ADV, 0,
	NESGetZipName, fds_deadzoneRomInfo, fds_deadzoneRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dig Dug (Japan)
static struct BurnRomInfo fds_digdugRomDesc[] = {
	{ "Dig Dug (Japan).fds",          65516, 0xeb126143, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_digdug, fds_digdug, fds_fdsbios)
STD_ROM_FN(fds_digdug)

struct BurnDriver BurnDrvfds_digdug = {
	"fds_digdug", NULL, "fds_fdsbios", NULL, "1990",
	"Dig Dug (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_ACTION, 0,
	NESGetZipName, fds_digdugRomInfo, fds_digdugRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dig Dug II (Japan)
static struct BurnRomInfo fds_digdugiiRomDesc[] = {
	{ "Dig Dug II (Japan).fds",          65516, 0x1b2b1342, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_digdugii, fds_digdugii, fds_fdsbios)
STD_ROM_FN(fds_digdugii)

struct BurnDriver BurnDrvfds_digdugii = {
	"fds_digdugii", NULL, "fds_fdsbios", NULL, "1990",
	"Dig Dug II (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_ACTION, 0,
	NESGetZipName, fds_digdugiiRomInfo, fds_digdugiiRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dirty Pair - Project Eden (Japan)
static struct BurnRomInfo fds_dirtypaijRomDesc[] = {
	{ "Dirty Pair - Project Eden (Japan).fds",          131016, 0x0bba3177, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_dirtypaij, fds_dirtypaij, fds_fdsbios)
STD_ROM_FN(fds_dirtypaij)

struct BurnDriver BurnDrvfds_dirtypaij = {
	"fds_dirtypaij", "fds_dirtypai", "fds_fdsbios", NULL, "1987",
	"Dirty Pair - Project Eden (Japan)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_FDS, GBF_HORSHOOT | GBF_PLATFORM, 0,
	NESGetZipName, fds_dirtypaijRomInfo, fds_dirtypaijRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dirty Pair - Project Eden (Hack, English)
// https://www.romhacking.net/translations/1735/
static struct BurnRomInfo fds_dirtypaiRomDesc[] = {
	{ "Dirty Pair - Project Eden (T-Eng).fds",          131000, 0x5707b40a, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_dirtypai, fds_dirtypai, fds_fdsbios)
STD_ROM_FN(fds_dirtypai)

struct BurnDriver BurnDrvfds_dirtypai = {
	"fds_dirtypai", NULL, "fds_fdsbios", NULL, "2021",
	"Dirty Pair - Project Eden (Hack, English)\0", NULL, "Stardust Crusaders", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_FDS, GBF_HORSHOOT | GBF_PLATFORM, 0,
	NESGetZipName, fds_dirtypaiRomInfo, fds_dirtypaiRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo fds_dokidokipanicRomDesc[] = {
	{ "Doki Doki Panic (Japan).fds",          131016, 0xb36dfcd2, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_dokidokipanic, fds_dokidokipanic, fds_fdsbios)
STD_ROM_FN(fds_dokidokipanic)

struct BurnDriver BurnDrvfds_dokidokipanic = {
	"fds_dokidokipanic", NULL, "fds_fdsbios", NULL, "1987",
	"Doki Doki Panic (Japan)\0", NULL, "Nintendo - Fuji TV", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_PLATFORM, 0,
	NESGetZipName, fds_dokidokipanicRomInfo, fds_dokidokipanicRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Donkey Kong (Japan)
static struct BurnRomInfo fds_donkeykongRomDesc[] = {
	{ "Donkey Kong (Japan).fds",          65516, 0x6c0740e9, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_donkeykong, fds_donkeykong, fds_fdsbios)
STD_ROM_FN(fds_donkeykong)

struct BurnDriver BurnDrvfds_donkeykong = {
	"fds_donkeykong", NULL, "fds_fdsbios", NULL, "1988",
	"Donkey Kong (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_ACTION, 0,
	NESGetZipName, fds_donkeykongRomInfo, fds_donkeykongRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Donkey Kong Jr. (Japan)
static struct BurnRomInfo fds_donkeykongjrRomDesc[] = {
	{ "Donkey Kong Jr. (Japan).fds",          65516, 0x3046966a, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_donkeykongjr, fds_donkeykongjr, fds_fdsbios)
STD_ROM_FN(fds_donkeykongjr)

struct BurnDriver BurnDrvfds_donkeykongjr = {
	"fds_donkeykongjr", NULL, "fds_fdsbios", NULL, "1988",
	"Donkey Kong Jr. (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_ACTION, 0,
	NESGetZipName, fds_donkeykongjrRomInfo, fds_donkeykongjrRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Doremikko (Japan)
static struct BurnRomInfo fds_doremikkoRomDesc[] = {
	{ "Doremikko (Japan)(1987)(Konami).fds",          131000, 0xbee7a47b, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_doremikko, fds_doremikko, fds_fdsbios)
STD_ROM_FN(fds_doremikko)

struct BurnDriver BurnDrvfds_doremikko = {
	"fds_doremikko", NULL, "fds_fdsbios", NULL, "1987",
	"Doremikko (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_MISC, 0,
	NESGetZipName, fds_doremikkoRomInfo, fds_doremikkoRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dr. Chaos - Jigoku no Tobira (Japan)
static struct BurnRomInfo fds_drchaRomDesc[] = {
	{ "Dr. Chaos - Jigoku no Tobira (Japan).fds",          131000, 0x7954bd8f, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_drcha, fds_drcha, fds_fdsbios)
STD_ROM_FN(fds_drcha)

struct BurnDriver BurnDrvfds_drcha = {
	"fds_drcha", NULL, "fds_fdsbios", NULL, "1987",
	"Dr. Chaos - Jigoku no Tobira (Japan)\0", NULL, "Pony Canyon", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, fds_drchaRomInfo, fds_drchaRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dracula II - Noroi no Fuuin (Japan)
static struct BurnRomInfo fds_dracuiiRomDesc[] = {
	{ "Dracula II - Noroi no Fuuin (Japan).fds",          131016, 0x2d1ec77c, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_dracuii, fds_dracuii, fds_fdsbios)
STD_ROM_FN(fds_dracuii)

struct BurnDriver BurnDrvfds_dracuii = {
	"fds_dracuii", NULL, "fds_fdsbios", NULL, "1987",
	"Dracula II - Noroi no Fuuin (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, fds_dracuiiRomInfo, fds_dracuiiRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Druid - Kyoufu no Tobira (Japan)
static struct BurnRomInfo fds_druidRomDesc[] = {
	{ "Druid - Kyoufu no Tobira (Japan).fds",          131016, 0xb5d4e955, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_druid, fds_druid, fds_fdsbios)
STD_ROM_FN(fds_druid)

struct BurnDriver BurnDrvfds_druid = {
	"fds_druid", "fds_druiden", "fds_fdsbios", NULL, "1988",
	"Druid - Kyoufu no Tobira (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_FDS, GBF_MAZE | GBF_RUNGUN, 0,
	NESGetZipName, fds_druidRomInfo, fds_druidRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Druid - The Gate of Fear (Hack, English)
// http://www.romhacking.net/translations/6470/
static struct BurnRomInfo fds_druidenRomDesc[] = {
	{ "Druid - Kyoufu no Tobira (T-Eng)(2022)(BlackPaladin).fds",          131000, 0x1e9dc522, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_druiden, fds_druiden, fds_fdsbios)
STD_ROM_FN(fds_druiden)

struct BurnDriver BurnDrvfds_druiden = {
	"fds_druiden", NULL, "fds_fdsbios", NULL, "2022",
	"Druid - The Gate of Fear (Hack, English)\0", NULL, "BlackPaladin", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_FDS, GBF_MAZE | GBF_RUNGUN, 0,
	NESGetZipName, fds_druidenRomInfo, fds_druidenRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Egger Land (Japan)
static struct BurnRomInfo fds_eggerlandRomDesc[] = {
	{ "Egger Land (Japan).fds",          131016, 0x84f75912, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_eggerland, fds_eggerland, fds_fdsbios)
STD_ROM_FN(fds_eggerland)

struct BurnDriver BurnDrvfds_eggerland = {
	"fds_eggerland", NULL, "fds_fdsbios", NULL, "1987",
	"Egger Land (Japan)\0", NULL, "HAL Laboratory", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_PUZZLE, 0,
	NESGetZipName, fds_eggerlandRomInfo, fds_eggerlandRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Egger Land - Souzouhe no Tabidachi (Japan)
static struct BurnRomInfo fds_eggerlansouenotaRomDesc[] = {
	{ "Egger Land - Souzouhe no Tabidachi (Japan).fds",          131016, 0x2441b3b9, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_eggerlansouenota, fds_eggerlansouenota, fds_fdsbios)
STD_ROM_FN(fds_eggerlansouenota)

struct BurnDriver BurnDrvfds_eggerlansouenota = {
	"fds_eggerlansouenota", NULL, "fds_fdsbios", NULL, "1988",
	"Egger Land - Souzouhe no Tabidachi (Japan)\0", NULL, "HAL Laboratory", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_PUZZLE, 0,
	NESGetZipName, fds_eggerlansouenotaRomInfo, fds_eggerlansouenotaRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Electrician (Japan)
static struct BurnRomInfo fds_electrician1RomDesc[] = {
	{ "Electrician (Japan).fds",          131016, 0x9c37e289, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_electrician1, fds_electrician1, fds_fdsbios)
STD_ROM_FN(fds_electrician1)

struct BurnDriver BurnDrvfds_electrician1 = {
	"fds_electrician1", "fds_electrician", "fds_fdsbios", NULL, "1986",
	"Electrician (Japan)\0", NULL, "Kemco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_FDS, GBF_ACTION, 0,
	NESGetZipName, fds_electrician1RomInfo, fds_electrician1RomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Electrician (Hack, English)
// https://www.romhacking.net/translations/5/
static struct BurnRomInfo fds_electricianRomDesc[] = {
	{ "Electrician (T-eng).fds",          131016, 0x4aa51f48, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_electrician, fds_electrician, fds_fdsbios)
STD_ROM_FN(fds_electrician)

struct BurnDriver BurnDrvfds_electrician = {
	"fds_electrician", NULL, "fds_fdsbios", NULL, "2001",
	"Electrician (Hack, English)\0", NULL, "King Mike", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_FDS, GBF_ACTION, 0,
	NESGetZipName, fds_electricianRomInfo, fds_electricianRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Esper Dream (Japan).fds
static struct BurnRomInfo fds_esperdreamjRomDesc[] = {
	{ "Esper Dream (Japan).fds",          131000, 0x1d40f83f, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_esperdreamj, fds_esperdreamj, fds_fdsbios)
STD_ROM_FN(fds_esperdreamj)

struct BurnDriver BurnDrvfds_esperdreamj = {
	"fds_esperdreamj", "fds_esperdream", "fds_fdsbios", NULL, "1987",
	"Esper Dream (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_FDS, GBF_ADV, 0,
	NESGetZipName, fds_esperdreamjRomInfo, fds_esperdreamjRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Esper Dream (Hack, English)
// https://www.romhacking.net/translations/656
static struct BurnRomInfo fds_esperdreamRomDesc[] = {
	{ "Esper Dream (T-Eng).fds",          131000, 0x51d8c9f1, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_esperdream, fds_esperdream, fds_fdsbios)
STD_ROM_FN(fds_esperdream)

struct BurnDriver BurnDrvfds_esperdream = {
	"fds_esperdream", NULL, "fds_fdsbios", NULL, "2003",
	"Esper Dream (Hack, English)\0", NULL, "Mute", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_FDS, GBF_ADV, 0,
	NESGetZipName, fds_esperdreamRomInfo, fds_esperdreamRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Exciting Soccer - Konami Cup (Japan)
static struct BurnRomInfo fds_excitsocRomDesc[] = {
	{ "Exciting Soccer - Konami Cup (Japan).fds",          131016, 0x43ccd4ba, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_excitsoc, fds_excitsoc, fds_fdsbios)
STD_ROM_FN(fds_excitsoc)

struct BurnDriver BurnDrvfds_excitsoc = {
	"fds_excitsoc", NULL, "fds_fdsbios", NULL, "1988",
	"Exciting Soccer - Konami Cup (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_SPORTSFOOTBALL, 0,
	NESGetZipName, fds_excitsocRomInfo, fds_excitsocRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo fds_fairypinRomDesc[] = {
	{ "Fairy Pinball - Yousei Tachi no Pinball (Japan).fds",          131016, 0x1ce10f77, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_fairypin, fds_fairypin, fds_fdsbios)
STD_ROM_FN(fds_fairypin)

struct BurnDriver BurnDrvfds_fairypin = {
	"fds_fairypin", NULL, "fds_fdsbios", NULL, "1987",
	"Fairy Pinball - Yousei Tachi no Pinball (Japan)\0", NULL, "Hacker International", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_PINBALL, 0,
	NESGetZipName, fds_fairypinRomInfo, fds_fairypinRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo fds_falsionRomDesc[] = {
	{ "Falsion (Japan).fds",          131016, 0x398bc9dc, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_falsion, fds_falsion, fds_fdsbios)
STD_ROM_FN(fds_falsion)

struct BurnDriver BurnDrvfds_falsion = {
	"fds_falsion", NULL, "fds_fdsbios", NULL, "1987",
	"Falsion (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_SHOOT, 0,
	NESGetZipName, fds_falsionRomInfo, fds_falsionRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo fds_famicgrapriRomDesc[] = {
	{ "Famicom Grand Prix - F1 Race (Japan).fds",          131016, 0x7040bf35, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_famicgrapri, fds_famicgrapri, fds_fdsbios)
STD_ROM_FN(fds_famicgrapri)

struct BurnDriver BurnDrvfds_famicgrapri = {
	"fds_famicgrapri", NULL, "fds_fdsbios", NULL, "1987",
	"Famicom Grand Prix - F1 Race (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_RACING, 0,
	NESGetZipName, fds_famicgrapriRomInfo, fds_famicgrapriRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo fds_famicgrapriiiRomDesc[] = {
	{ "Famicom Grand Prix II - 3D Hot Rally (Japan).fds",          131016, 0x012267d8, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_famicgrapriii, fds_famicgrapriii, fds_fdsbios)
STD_ROM_FN(fds_famicgrapriii)

struct BurnDriver BurnDrvfds_famicgrapriii = {
	"fds_famicgrapriii", NULL, "fds_fdsbios", NULL, "1988",
	"Famicom Grand Prix II - 3D Hot Rally (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_RACING, 0,
	NESGetZipName, fds_famicgrapriiiRomInfo, fds_famicgrapriiiRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo fds_famimdisvol1RomDesc[] = {
	{ "Famimaga Disk Vol. 1 - Hong Kong (Japan).fds",          65516, 0xc6f69987, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_famimdisvol1, fds_famimdisvol1, fds_fdsbios)
STD_ROM_FN(fds_famimdisvol1)

struct BurnDriver BurnDrvfds_famimdisvol1 = {
	"fds_famimdisvol1", NULL, "fds_fdsbios", NULL, "1990",
	"Famimaga Disk Vol. 1 - Hong Kong (Japan)\0", NULL, "Tokuma Shoten", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_PUZZLE, 0,
	NESGetZipName, fds_famimdisvol1RomInfo, fds_famimdisvol1RomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo fds_famimdisvol2RomDesc[] = {
	{ "Famimaga Disk Vol. 2 - Panic Space (Japan).fds",          131016, 0x1274645d, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_famimdisvol2, fds_famimdisvol2, fds_fdsbios)
STD_ROM_FN(fds_famimdisvol2)

struct BurnDriver BurnDrvfds_famimdisvol2 = {
	"fds_famimdisvol2", NULL, "fds_fdsbios", NULL, "1990",
	"Famimaga Disk Vol. 2 - Panic Space (Japan)\0", NULL, "Tokuma Shoten", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_PUZZLE, 0,
	NESGetZipName, fds_famimdisvol2RomInfo, fds_famimdisvol2RomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo fds_famimdisvol3RomDesc[] = {
	{ "Famimaga Disk Vol. 3 - All 1 (Japan).fds",          65516, 0x936c8017, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_famimdisvol3, fds_famimdisvol3, fds_fdsbios)
STD_ROM_FN(fds_famimdisvol3)

struct BurnDriver BurnDrvfds_famimdisvol3 = {
	"fds_famimdisvol3", NULL, "fds_fdsbios", NULL, "1991",
	"Famimaga Disk Vol. 3 - All 1 (Japan)\0", NULL, "Tokuma Shoten", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_PUZZLE, 0,
	NESGetZipName, fds_famimdisvol3RomInfo, fds_famimdisvol3RomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo fds_famimdisvol4RomDesc[] = {
	{ "Famimaga Disk Vol. 4 - Clox (Japan).fds",          65516, 0xe46ffd9b, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_famimdisvol4, fds_famimdisvol4, fds_fdsbios)
STD_ROM_FN(fds_famimdisvol4)

struct BurnDriver BurnDrvfds_famimdisvol4 = {
	"fds_famimdisvol4", NULL, "fds_fdsbios", NULL, "1991",
	"Famimaga Disk Vol. 4 - Clox (Japan)\0", NULL, "Tokuma Shoten", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_PUZZLE, 0,
	NESGetZipName, fds_famimdisvol4RomInfo, fds_famimdisvol4RomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo fds_famimdisvol5RomDesc[] = {
	{ "Famimaga Disk Vol. 5 - Puyo Puyo (Japan).fds",          131016, 0xe84c7927, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_famimdisvol5, fds_famimdisvol5, fds_fdsbios)
STD_ROM_FN(fds_famimdisvol5)

struct BurnDriver BurnDrvfds_famimdisvol5 = {
	"fds_famimdisvol5", NULL, "fds_fdsbios", NULL, "1991",
	"Famimaga Disk Vol. 5 - Puyo Puyo (Japan)\0", NULL, "Tokuma Shoten", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_PUZZLE, 0,
	NESGetZipName, fds_famimdisvol5RomInfo, fds_famimdisvol5RomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo fds_famimdisvol6RomDesc[] = {
	{ "Famimaga Disk Vol. 6 - Janken Disk Jou (Japan).fds",          131016, 0x251ddeaa, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_famimdisvol6, fds_famimdisvol6, fds_fdsbios)
STD_ROM_FN(fds_famimdisvol6)

struct BurnDriver BurnDrvfds_famimdisvol6 = {
	"fds_famimdisvol6", NULL, "fds_fdsbios", NULL, "1992",
	"Famimaga Disk Vol. 6 - Janken Disk Jou (Japan)\0", NULL, "Tokuma Shoten", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, fds_famimdisvol6RomInfo, fds_famimdisvol6RomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo fds_finalcomRomDesc[] = {
	{ "Final Command - Akai Yousai (Japan).fds",          131016, 0xb89d5131, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_finalcom, fds_finalcom, fds_fdsbios)
STD_ROM_FN(fds_finalcom)

struct BurnDriver BurnDrvfds_finalcom = {
	"fds_finalcom", NULL, "fds_fdsbios", NULL, "1988",
	"Final Command - Akai Yousai (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_RUNGUN, 0,
	NESGetZipName, fds_finalcomRomInfo, fds_finalcomRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo fds_firebamRomDesc[] = {
	{ "Fire Bam (Japan).fds",          131016, 0x9e5c5ede, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_firebam, fds_firebam, fds_fdsbios)
STD_ROM_FN(fds_firebam)

struct BurnDriver BurnDrvfds_firebam = {
	"fds_firebam", NULL, "fds_fdsbios", NULL, "1988",
	"Fire Bam (Japan)\0", NULL, "HAL Laboratory", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, fds_firebamRomInfo, fds_firebamRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo fds_firerockRomDesc[] = {
	{ "Fire Rock (Japan).fds",          131016, 0xe44c7313, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_firerock, fds_firerock, fds_fdsbios)
STD_ROM_FN(fds_firerock)

struct BurnDriver BurnDrvfds_firerock = {
	"fds_firerock", NULL, "fds_fdsbios", NULL, "1988",
	"Fire Rock (Japan)\0", NULL, "System Sacom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_PLATFORM, 0,
	NESGetZipName, fds_firerockRomInfo, fds_firerockRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo fds_fuuunankokuRomDesc[] = {
	{ "Fuuun Shourinken - Ankoku no Maou (Japan)(1988)(Jaleco).fds",          131000, 0x3c5f6468, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_fuuunankoku, fds_fuuunankoku, fds_fdsbios)
STD_ROM_FN(fds_fuuunankoku)

struct BurnDriver BurnDrvfds_fuuunankoku = {
	"fds_fuuunankoku", NULL, "fds_fdsbios", NULL, "1988",
	"Fuuun Shourin Ken - Ankoku no Maou (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_VSFIGHT | GBF_ADV, 0,
	NESGetZipName, fds_fuuunankokuRomInfo, fds_fuuunankokuRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo fds_fuuunshokenRomDesc[] = {
	{ "Fuuun Shourin Ken (Japan).fds",          131016, 0xb5b75934, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_fuuunshoken, fds_fuuunshoken, fds_fdsbios)
STD_ROM_FN(fds_fuuunshoken)

struct BurnDriver BurnDrvfds_fuuunshoken = {
	"fds_fuuunshoken", NULL, "fds_fdsbios", NULL, "1987",
	"Fuuun Shourin Ken (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_VSFIGHT, 0,
	NESGetZipName, fds_fuuunshokenRomInfo, fds_fuuunshokenRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Galaga (Japan)
static struct BurnRomInfo fds_galagaRomDesc[] = {
	{ "Galaga (Japan).fds",          65516, 0xa9ba7801, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_galaga, fds_galaga, fds_fdsbios)
STD_ROM_FN(fds_galaga)

struct BurnDriver BurnDrvfds_galaga = {
	"fds_galaga", NULL, "fds_fdsbios", NULL, "1990",
	"Galaga (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_SHOOT, 0,
	NESGetZipName, fds_galagaRomInfo, fds_galagaRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Galaxian (Japan)
static struct BurnRomInfo fds_galaxianRomDesc[] = {
	{ "Galaxian (Japan).fds",          65516, 0x429169f5, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_galaxian, fds_galaxian, fds_fdsbios)
STD_ROM_FN(fds_galaxian)

struct BurnDriver BurnDrvfds_galaxian = {
	"fds_galaxian", NULL, "fds_fdsbios", NULL, "1990",
	"Galaxian (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_SHOOT, 0,
	NESGetZipName, fds_galaxianRomInfo, fds_galaxianRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gall Force - Eternal Story (Japan)
static struct BurnRomInfo fds_gallforjRomDesc[] = {
	{ "Gall Force - Eternal Story (Japan).fds",          131016, 0x51ef74fb, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_gallforj, fds_gallforj, fds_fdsbios)
STD_ROM_FN(fds_gallforj)

struct BurnDriver BurnDrvfds_gallforj = {
	"fds_gallforj", "fds_gallfor", "fds_fdsbios", NULL, "1986",
	"Gall Force - Eternal Story (Japan)\0", NULL, "HAL Laboratory", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_FDS, GBF_VERSHOOT, 0,
	NESGetZipName, fds_gallforjRomInfo, fds_gallforjRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gall Force - Eternal Story (Hack, English)
// https://www.romhacking.net/translations/1356/
static struct BurnRomInfo fds_gallforRomDesc[] = {
	{ "Gall Force - Eternal Story (T-Eng).fds",          131000, 0xd66e007f, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_gallfor, fds_gallfor, fds_fdsbios)
STD_ROM_FN(fds_gallfor)

struct BurnDriver BurnDrvfds_gallfor = {
	"fds_gallfor", NULL, "fds_fdsbios", NULL, "2008",
	"Gall Force - Eternal Story (Hack, English)\0", NULL, "Gil Galad", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_FDS, GBF_VERSHOOT, 0,
	NESGetZipName, fds_gallforRomInfo, fds_gallforRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ginga Denshou - Galaxy Odyssey (Japan)
static struct BurnRomInfo fds_gingadenRomDesc[] = {
	{ "Ginga Denshou - Galaxy Odyssey (Japan).fds",          131016, 0xd38240da, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_gingaden, fds_gingaden, fds_fdsbios)
STD_ROM_FN(fds_gingaden)

struct BurnDriver BurnDrvfds_gingaden = {
	"fds_gingaden", NULL, "fds_fdsbios", NULL, "1986",
	"Ginga Denshou - Galaxy Odyssey (Japan)\0", NULL, "Imagineer", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_VERSHOOT | GBF_RPG, 0,
	NESGetZipName, fds_gingadenRomInfo, fds_gingadenRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Golf (Japan)
static struct BurnRomInfo fds_golfRomDesc[] = {
	{ "Golf (Japan).fds",          65516, 0x4667eafa, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_golf, fds_golf, fds_fdsbios)
STD_ROM_FN(fds_golf)

struct BurnDriver BurnDrvfds_golf = {
	"fds_golf", NULL, "fds_fdsbios", NULL, "1985",
	"Golf (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_SPORTSMISC, 0,
	NESGetZipName, fds_golfRomInfo, fds_golfRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Golf - Japan Course (Japan)
static struct BurnRomInfo fds_golfjapcouRomDesc[] = {
	{ "Golf - Japan Course (Japan).fds",          131016, 0xdbacfaaa, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_golfjapcou, fds_golfjapcou, fds_fdsbios)
STD_ROM_FN(fds_golfjapcou)

struct BurnDriver BurnDrvfds_golfjapcou = {
	"fds_golfjapcou", NULL, "fds_fdsbios", NULL, "1987",
	"Golf - Japan Course (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_SPORTSMISC, 0,
	NESGetZipName, fds_golfjapcouRomInfo, fds_golfjapcouRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Golf - US Course (Japan)
static struct BurnRomInfo fds_golfuscourseRomDesc[] = {
	{ "Golf - US Course (Japan).fds",          131016, 0x0ef5dae4, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_golfuscourse, fds_golfuscourse, fds_fdsbios)
STD_ROM_FN(fds_golfuscourse)

struct BurnDriver BurnDrvfds_golfuscourse = {
	"fds_golfuscourse", NULL, "fds_fdsbios", NULL, "1987",
	"Golf - US Course (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_SPORTSMISC, 0,
	NESGetZipName, fds_golfuscourseRomInfo, fds_golfuscourseRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Goonies, The (Japan)
static struct BurnRomInfo fds_gooniesRomDesc[] = {
	{ "Goonies (Japan).fds",          65516, 0x81b760a2, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_goonies, fds_goonies, fds_fdsbios)
STD_ROM_FN(fds_goonies)

struct BurnDriver BurnDrvfds_goonies = {
	"fds_goonies", NULL, "fds_fdsbios", NULL, "1988",
	"Goonies, The (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_PLATFORM, 0,
	NESGetZipName, fds_gooniesRomInfo, fds_gooniesRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Green Beret (Japan)
static struct BurnRomInfo fds_greenberetRomDesc[] = {
	{ "Green Beret (Japan).fds",          131016, 0xe7f0577b, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_greenberet, fds_greenberet, fds_fdsbios)
STD_ROM_FN(fds_greenberet)

struct BurnDriver BurnDrvfds_greenberet = {
	"fds_greenberet", NULL, "fds_fdsbios", NULL, "1987",
	"Green Beret (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, fds_greenberetRomInfo, fds_greenberetRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gun.Smoke (Japan)
static struct BurnRomInfo fds_gunsmokeRomDesc[] = {
	{ "Gun.Smoke (Japan).fds",          131016, 0xbe761b95, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_gunsmoke, fds_gunsmoke, fds_fdsbios)
STD_ROM_FN(fds_gunsmoke)

struct BurnDriver BurnDrvfds_gunsmoke = {
	"fds_gunsmoke", NULL, "fds_fdsbios", NULL, "1988",
	"Gun.Smoke (Japan)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_RUNGUN, 0,
	NESGetZipName, fds_gunsmokeRomInfo, fds_gunsmokeRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gyruss (Japan)
static struct BurnRomInfo fds_gyruss1RomDesc[] = {
	{ "Gyruss (Japan).fds",          131016, 0x4552202c, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_gyruss1, fds_gyruss1, fds_fdsbios)
STD_ROM_FN(fds_gyruss1)

struct BurnDriver BurnDrvfds_gyruss1 = {
	"fds_gyruss1", "fds_gyruss", "fds_fdsbios", NULL, "1988",
	"Gyruss (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_FDS, GBF_SHOOT, 0,
	NESGetZipName, fds_gyruss1RomInfo, fds_gyruss1RomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gyruss (Hack, English)
// https://www.romhacking.net/translations/3026/
static struct BurnRomInfo fds_gyrussRomDesc[] = {
	{ "Gyruss (T-eng).fds",          131000, 0xf17f2728, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_gyruss, fds_gyruss, fds_fdsbios)
STD_ROM_FN(fds_gyruss)

struct BurnDriver BurnDrvfds_gyruss = {
	"fds_gyruss", NULL, "fds_fdsbios", NULL, "2021",
	"Gyruss (Hack, English)\0", NULL, "Stardust Crusader", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_FDS, GBF_SHOOT, 0,
	NESGetZipName, fds_gyrussRomInfo, fds_gyrussRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Halley Wars (Japan)
static struct BurnRomInfo fds_halleywarsRomDesc[] = {
	{ "Halley Wars (Japan).fds",          131016, 0x583b11ca, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_halleywars, fds_halleywars, fds_fdsbios)
STD_ROM_FN(fds_halleywars)

struct BurnDriver BurnDrvfds_halleywars = {
	"fds_halleywars", NULL, "fds_fdsbios", NULL, "1989",
	"Halley Wars (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_VERSHOOT, 0,
	NESGetZipName, fds_halleywarsRomInfo, fds_halleywarsRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hao-kun no Fushigi na Tabi (Japan)
static struct BurnRomInfo fds_haokunnofusnataRomDesc[] = {
	{ "Hao-kun no Fushigi na Tabi (Japan).fds",          131016, 0x085f5f88, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_haokunnofusnata, fds_haokunnofusnata, fds_fdsbios)
STD_ROM_FN(fds_haokunnofusnata)

struct BurnDriver BurnDrvfds_haokunnofusnata = {
	"fds_haokunnofusnata", NULL, "fds_fdsbios", NULL, "1987",
	"Hao-kun no Fushigi na Tabi (Japan)\0", NULL, "Square", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_PLATFORM, 0,
	NESGetZipName, fds_haokunnofusnataRomInfo, fds_haokunnofusnataRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hikari Shinwa - Palutena no Kagami (Hack, English)
// https://www.romhacking.net/translations/7059/
static struct BurnRomInfo fds_hikarshiRomDesc[] = {
	{ "Hikari Shinwa - Palutena no Kagami T-Eng (2023)(BlackPaladin).fds",          131000, 0x78a03745, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_hikarshi, fds_hikarshi, fds_fdsbios)
STD_ROM_FN(fds_hikarshi)

struct BurnDriver BurnDrvfds_hikarshi = {
	"fds_hikarshi", NULL, "fds_fdsbios", NULL, "2023",
	"Hikari Shinwa - Palutena no Kagami (Hack, English)\0", "Myth of Light Palutena's Mirror, The", "BlackPaladin", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_FDS, GBF_PLATFORM, 0,
	NESGetZipName, fds_hikarshiRomInfo, fds_hikarshiRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hikari Shinwa - Palutena no Kagami (Japan)
static struct BurnRomInfo fds_hikarshijRomDesc[] = {
	{ "Hikari Shinwa - Palutena no Kagami (Japan).fds",          131000, 0x32516fcf, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_hikarshij, fds_hikarshij, fds_fdsbios)
STD_ROM_FN(fds_hikarshij)

struct BurnDriver BurnDrvfds_hikarshij = {
	"fds_hikarshij", "fds_hikarshi", "fds_fdsbios", NULL, "1986",
	"Hikari Shinwa - Palutena no Kagami (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_FDS, GBF_PLATFORM, 0,
	NESGetZipName, fds_hikarshijRomInfo, fds_hikarshijRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ice Hockey (Japan)
static struct BurnRomInfo fds_icehockeyRomDesc[] = {
	{ "Ice Hockey (Japan).fds",          65516, 0x7bb390de, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_icehockey, fds_icehockey, fds_fdsbios)
STD_ROM_FN(fds_icehockey)

struct BurnDriver BurnDrvfds_icehockey = {
	"fds_icehockey", NULL, "fds_fdsbios", NULL, "1988",
	"Ice Hockey (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_SPORTSMISC, 0,
	NESGetZipName, fds_icehockeyRomInfo, fds_icehockeyRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Idol Hotline - Nakayama Miho no Tokimeki High School (Japan)
static struct BurnRomInfo fds_idolhljRomDesc[] = {
	{ "Idol Hotline - Nakayama Miho no Tokimeki High School (Japan)(DV10)(1987)(Nintendo).fds",          131000, 0x9c9616b8, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_idolhlj, fds_idolhlj, fds_fdsbios)
STD_ROM_FN(fds_idolhlj)

struct BurnDriver BurnDrvfds_idolhlj = {
	"fds_idolhlj", "fds_idolhl", "fds_fdsbios", NULL, "1987",
	"Idol Hotline - Nakayama Miho no Tokimeki High School (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_FDS, GBF_ADV, 0,
	NESGetZipName, fds_idolhljRomInfo, fds_idolhljRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Idol Hotline - Nakayama Miho no Tokimeki High School (Hack, English)
// https://www.romhacking.net/translations/6574/
static struct BurnRomInfo fds_idolhlRomDesc[] = {
	{ "Idol Hotline - Nakayama Miho no Tokimeki High School (T-Eng)(2022)(FCandChill).fds",          131000, 0x772a6bcc, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_idolhl, fds_idolhl, fds_fdsbios)
STD_ROM_FN(fds_idolhl)

struct BurnDriver BurnDrvfds_idolhl = {
	"fds_idolhl", NULL, "fds_fdsbios", NULL, "2022",
	"Idol Hotline - Nakayama Miho no Tokimeki High School (Hack, English)\0", NULL, "FCandChill", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_FDS, GBF_ADV, 0,
	NESGetZipName, fds_idolhlRomInfo, fds_idolhlRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ishidou (Japan)
static struct BurnRomInfo fds_ishidoujRomDesc[] = {
	{ "Ishidou (Japan).fds",          131000, 0x0c54a19e, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_ishidouj, fds_ishidouj, fds_fdsbios)
STD_ROM_FN(fds_ishidouj)

struct BurnDriver BurnDrvfds_ishidouj = {
	"fds_ishidouj", "fds_ishidou", "fds_fdsbios", NULL, "1990",
	"Ishidou (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_FDS, GBF_PUZZLE, 0,
	NESGetZipName, fds_ishidoujRomInfo, fds_ishidoujRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ishidou (Hack, English)
// https://www.romhacking.net/translations/1579/
static struct BurnRomInfo fds_ishidouRomDesc[] = {
	{ "Ishidou (T-Eng).fds",          131000, 0xebfcf648, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_ishidou, fds_ishidou, fds_fdsbios)
STD_ROM_FN(fds_ishidou)

struct BurnDriver BurnDrvfds_ishidou = {
	"fds_ishidou", NULL, "fds_fdsbios", NULL, "2011",
	"Ishidou (Hack, English)\0", NULL, "Django", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_FDS, GBF_PUZZLE, 0,
	NESGetZipName, fds_ishidouRomInfo, fds_ishidouRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Jikai Shounen Met Mag (Japan)
static struct BurnRomInfo fds_jikaishometmagRomDesc[] = {
	{ "Jikai Shounen Met Mag (Japan).fds",          131016, 0xc8ce0200, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_jikaishometmag, fds_jikaishometmag, fds_fdsbios)
STD_ROM_FN(fds_jikaishometmag)

struct BurnDriver BurnDrvfds_jikaishometmag = {
	"fds_jikaishometmag", NULL, "fds_fdsbios", NULL, "1987",
	"Jikai Shounen Met Mag (Japan)\0", NULL, "Square - Thinking Rabbit", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_PLATFORM | GBF_PUZZLE, 0,
	NESGetZipName, fds_jikaishometmagRomInfo, fds_jikaishometmagRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kaettekita Mario Bros. (Japan)
static struct BurnRomInfo fds_kaettmarbroRomDesc[] = {
	{ "Kaettekita Mario Brothers (Japan).fds",          131016, 0x12358ded, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_kaettmarbro, fds_kaettmarbro, fds_fdsbios)
STD_ROM_FN(fds_kaettmarbro)

struct BurnDriver BurnDrvfds_kaettmarbro = {
	"fds_kaettmarbro", "fds_returnmarbro", "fds_fdsbios", NULL, "1988",
	"Kaettekita Mario Bros. (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_FDS, GBF_PLATFORM, 0,
	NESGetZipName, fds_kaettmarbroRomInfo, fds_kaettmarbroRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};



// Kalin no Tsurugi (Japan)
static struct BurnRomInfo fds_kalinnotsurugijRomDesc[] = {
	{ "Kalin no Tsurugi (Japan).fds",          131000, 0xc63a0059, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_kalinnotsurugij, fds_kalinnotsurugij, fds_fdsbios)
STD_ROM_FN(fds_kalinnotsurugij)

struct BurnDriver BurnDrvfds_kalinnotsurugij = {
	"fds_kalinnotsurugij", "fds_kalinnotsurugi", "fds_fdsbios", NULL, "1987",
	"Kalin no Tsurugi (Japan)\0", NULL, "Square", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_FDS, GBF_ACTION | GBF_RPG, 0,
	NESGetZipName, fds_kalinnotsurugijRomInfo, fds_kalinnotsurugijRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kalin no Tsurugi (Hack, English)
static struct BurnRomInfo fds_kalinnotsurugiRomDesc[] = {
	{ "Kalin no Tsurugi (T-Eng).fds",          131000, 0x7825c974, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_kalinnotsurugi, fds_kalinnotsurugi, fds_fdsbios)
STD_ROM_FN(fds_kalinnotsurugi)

struct BurnDriver BurnDrvfds_kalinnotsurugi = {
	"fds_kalinnotsurugi", NULL, "fds_fdsbios", NULL, "2005",
	"Kalin no Tsurugi (Hack, English)\0", NULL, "filler, KingMike, satsu", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_FDS, GBF_ACTION | GBF_RPG, 0,
	NESGetZipName, fds_kalinnotsurugiRomInfo, fds_kalinnotsurugiRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kamen Rider Black - Taiketsu Shadow Moon (Japan)
static struct BurnRomInfo fds_kamenridblaRomDesc[] = {
	{ "Kamen Rider Black - Taiketsu Shadow Moon (Japan).fds",          131016, 0x0db848ea, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_kamenridbla, fds_kamenridbla, fds_fdsbios)
STD_ROM_FN(fds_kamenridbla)

struct BurnDriver BurnDrvfds_kamenridbla = {
	"fds_kamenridbla", "fds_kamenridblaen", "fds_fdsbios", NULL, "1988",
	"Kamen Rider Black - Taiketsu Shadow Moon (Japan)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_FDS, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, fds_kamenridblaRomInfo, fds_kamenridblaRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kamen Rider Black - Taiketsu Shadow Moon (Hack, English)
// https://www.romhacking.net/translations/6703/
static struct BurnRomInfo fds_kamenridblaenRomDesc[] = {
	{ "Kamen Rider Black - Taiketsu Shadow Moon T-Eng (2022)(BlackPaladin).fds",          131016, 0x0ca67b03, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_kamenridblaen, fds_kamenridblaen, fds_fdsbios)
STD_ROM_FN(fds_kamenridblaen)

struct BurnDriver BurnDrvfds_kamenridblaen = {
	"fds_kamenridblaen", NULL, "fds_fdsbios", NULL, "2022",
	"Kamen Rider Black - Taiketsu Shadow Moon (Hack, English)\0", NULL, "BlackPaladin", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_FDS, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, fds_kamenridblaenRomInfo, fds_kamenridblaenRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kick and Run (Japan)
static struct BurnRomInfo fds_kickandrunRomDesc[] = {
	{ "Kick and Run (Japan).fds",          131016, 0xa37d4c85, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_kickandrun, fds_kickandrun, fds_fdsbios)
STD_ROM_FN(fds_kickandrun)

struct BurnDriver BurnDrvfds_kickandrun = {
	"fds_kickandrun", NULL, "fds_fdsbios", NULL, "1988",
	"Kick and Run (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_SPORTSFOOTBALL, 0,
	NESGetZipName, fds_kickandrunRomInfo, fds_kickandrunRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kick Challenger - Air Foot (Japan)
static struct BurnRomInfo fds_kickchaRomDesc[] = {
	{ "Kick Challenger - Air Foot (Japan).fds",          131016, 0xc83ef278, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_kickcha, fds_kickcha, fds_fdsbios)
STD_ROM_FN(fds_kickcha)

struct BurnDriver BurnDrvfds_kickcha = {
	"fds_kickcha", NULL, "fds_fdsbios", NULL, "1987",
	"Kick Challenger - Air Foot (Japan)\0", NULL, "Vap", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_ACTION, 0,
	NESGetZipName, fds_kickchaRomInfo, fds_kickchaRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kieta Princess (Japan)
static struct BurnRomInfo fds_kietaprincessRomDesc[] = {
	{ "Kieta Princess (Japan).fds",          131000, 0x60d55cea, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_kietaprincess, fds_kietaprincess, fds_fdsbios)
STD_ROM_FN(fds_kietaprincess)

struct BurnDriver BurnDrvfds_kietaprincess = {
	"fds_kietaprincess", NULL, "fds_fdsbios", NULL, "1986",
	"Kieta Princess (Japan)\0", NULL, "Imagineer", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, fds_kietaprincessRomInfo, fds_kietaprincessRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kiki Kaikai - Dotou Hen (Japan) (Rev 1)
static struct BurnRomInfo fds_kikikaijRomDesc[] = {
	{ "Kiki Kaikai Dotou Hen (J)(Rev 1)(1987)(Taito).fds",          131000, 0x007aa4fd, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_kikikaij, fds_kikikaij, fds_fdsbios)
STD_ROM_FN(fds_kikikaij)

struct BurnDriver BurnDrvfds_kikikaij = {
	"fds_kikikaij", "fds_kikikai", "fds_fdsbios", NULL, "1987",
	"Kiki Kaikai - Dotou Hen (Japan) (Rev 1)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_FDS, GBF_RUNGUN, 0,
	NESGetZipName, fds_kikikaijRomInfo, fds_kikikaijRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kiki Kaikai - Dotou Hen (Hack, English)
// https://www.romhacking.net/translations/7204/
static struct BurnRomInfo fds_kikikaiRomDesc[] = {
	{ "Kiki Kaikai Dotou Hen T-Eng (2024)(BlackPaladin).fds",          131000, 0x61d3af7e, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_kikikai, fds_kikikai, fds_fdsbios)
STD_ROM_FN(fds_kikikai)

struct BurnDriver BurnDrvfds_kikikai = {
	"fds_kikikai", NULL, "fds_fdsbios", NULL, "2024",
	"Kiki Kaikai - Dotou Hen (Hack, English)\0", "Mysterious Ghost World - The Turbulent Chapters", "BlackPaladin", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_FDS, GBF_RUNGUN, 0,
	NESGetZipName, fds_kikikaiRomInfo, fds_kikikaiRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kinnikuman - Kinnikusei Oui Soudatsusen (Japan)
static struct BurnRomInfo fds_kinniRomDesc[] = {
	{ "Kinnikuman - Kinnikusei Oui Soudatsusen (Japan).fds",          131016, 0x5149b663, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_kinni, fds_kinni, fds_fdsbios)
STD_ROM_FN(fds_kinni)

struct BurnDriver BurnDrvfds_kinni = {
	"fds_kinni", NULL, "fds_fdsbios", NULL, "1987",
	"Kinnikuman - Kinnikusei Oui Soudatsusen (Japan)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_SCRFIGHT, 0,
	NESGetZipName, fds_kinniRomInfo, fds_kinniRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kitten's Tale, A - The Adventures of Chatran (Hack, English)
// https://www.romhacking.net/translations/7242/
static struct BurnRomInfo fds_kittentaleRomDesc[] = {
	{ "Kitten's Tale, A - The Adventures of Chatran T-Eng (2024)(BlackPaladin).fds",          131000, 0xa05d0c22, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_kittentale, fds_kittentale, fds_fdsbios)
STD_ROM_FN(fds_kittentale)

struct BurnDriver BurnDrvfds_kittentale = {
	"fds_kittentale", NULL, "fds_fdsbios", NULL, "2024",
	"Kitten's Tale, A - The Adventures of Chatran (Hack, English)\0", NULL, "BlackPaladin", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_FDS, GBF_PLATFORM, 0,
	NESGetZipName, fds_kittentaleRomInfo, fds_kittentaleRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Knight Lore - Majou no Ookami Otoko (Japan)
static struct BurnRomInfo fds_knighlorRomDesc[] = {
	{ "Knight Lore - Majou no Ookami Otoko (Japan).fds",          131016, 0xc07a8b04, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_knighlor, fds_knighlor, fds_fdsbios)
STD_ROM_FN(fds_knighlor)

struct BurnDriver BurnDrvfds_knighlor = {
	"fds_knighlor", NULL, "fds_fdsbios", NULL, "1986",
	"Knight Lore - Majou no Ookami Otoko (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, fds_knighlorRomInfo, fds_knighlorRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Knight Move (Japan)
static struct BurnRomInfo fds_knightmovejRomDesc[] = {
	{ "Knight Move (Japan).fds",          65500, 0x6d365e2f, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_knightmovej, fds_knightmovej, fds_fdsbios)
STD_ROM_FN(fds_knightmovej)

struct BurnDriver BurnDrvfds_knightmovej = {
	"fds_knightmovej", "fds_knightmove", "fds_fdsbios", NULL, "1990",
	"Knight Move (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_FDS, GBF_PUZZLE, 0,
	NESGetZipName, fds_knightmovejRomInfo, fds_knightmovejRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Knight Move (Hack, English)
// https://www.romhacking.net/translations/691/
static struct BurnRomInfo fds_knightmoveRomDesc[] = {
	{ "Knight Move (T-Eng).fds",          65500, 0x474b83c4, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_knightmove, fds_knightmove, fds_fdsbios)
STD_ROM_FN(fds_knightmove)

struct BurnDriver BurnDrvfds_knightmove = {
	"fds_knightmove", NULL, "fds_fdsbios", NULL, "2003",
	"Knight Move (Hack, English)\0", NULL, "PentarouZero", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_FDS, GBF_PUZZLE, 0,
	NESGetZipName, fds_knightmoveRomInfo, fds_knightmoveRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Konamic Tennis (Japan)
static struct BurnRomInfo fds_konamictennisRomDesc[] = {
	{ "Konamic Tennis (Japan).fds",          131000, 0xedbaee55, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_konamictennis, fds_konamictennis, fds_fdsbios)
STD_ROM_FN(fds_konamictennis)

struct BurnDriver BurnDrvfds_konamictennis = {
	"fds_konamictennis", NULL, "fds_fdsbios", NULL, "1988",
	"Konamic Tennis (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_SPORTSMISC, 0,
	NESGetZipName, fds_konamictennisRomInfo, fds_konamictennisRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Koneko Monogatari - The Adventures of Chatran (Japan)
static struct BurnRomInfo fds_konekmonRomDesc[] = {
	{ "Koneko Monogatari - The Adventures of Chatran (Japan).fds",          131016, 0xe3387bf0, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_konekmon, fds_konekmon, fds_fdsbios)
STD_ROM_FN(fds_konekmon)

struct BurnDriver BurnDrvfds_konekmon = {
	"fds_konekmon", "fds_kittentale", "fds_fdsbios", NULL, "1986",
	"Koneko Monogatari - The Adventures of Chatran (Japan)\0", NULL, "Pony Canyon", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_FDS, GBF_PLATFORM, 0,
	NESGetZipName, fds_konekmonRomInfo, fds_konekmonRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Link no Bouken - The Legend of Zelda 2 (Japan)
static struct BurnRomInfo fds_linknoboujRomDesc[] = {
	{ "Link no Bouken - The Legend of Zelda 2 (Japan).fds",          131016, 0xa118214f, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_linknobouj, fds_linknobouj, fds_fdsbios)
STD_ROM_FN(fds_linknobouj)

struct BurnDriver BurnDrvfds_linknobouj = {
	"fds_linknobouj", "fds_linknobou", "fds_fdsbios", NULL, "1987",
	"Link no Bouken - The Legend of Zelda 2 (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_FDS, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, fds_linknoboujRomInfo, fds_linknoboujRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Link no Bouken - The Legend of Zelda 2 (Hack, English)
// https://www.romhacking.net/translations/3177/
static struct BurnRomInfo fds_linknobouRomDesc[] = {
	{ "Link no Bouken - The Legend of Zelda 2 (T-Eng).fds",          131000, 0x359d3f2b, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_linknobou, fds_linknobou, fds_fdsbios)
STD_ROM_FN(fds_linknobou)

struct BurnDriver BurnDrvfds_linknobou = {
	"fds_linknobou", NULL, "fds_fdsbios", NULL, "2017",
	"Link no Bouken - The Legend of Zelda 2 (Hack, English)\0", NULL, "columbo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_FDS, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, fds_linknobouRomInfo, fds_linknobouRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lutter (Japan)
static struct BurnRomInfo fds_lutterRomDesc[] = {
	{ "Lutter (Japan).fds",          131016, 0x54335232, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_lutter, fds_lutter, fds_fdsbios)
STD_ROM_FN(fds_lutter)

struct BurnDriver BurnDrvfds_lutter = {
	"fds_lutter", NULL, "fds_fdsbios", NULL, "1989",
	"Lutter (Japan)\0", NULL, "Athena", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_ACTION | GBF_RPG, 0,
	NESGetZipName, fds_lutterRomInfo, fds_lutterRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Maerchen Veil (Japan)
static struct BurnRomInfo fds_maerchenveilRomDesc[] = {
	{ "Maerchen Veil (Japan).fds",          131016, 0x618d10a2, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_maerchenveil, fds_maerchenveil, fds_fdsbios)
STD_ROM_FN(fds_maerchenveil)

struct BurnDriver BurnDrvfds_maerchenveil = {
	"fds_maerchenveil", NULL, "fds_fdsbios", NULL, "1987",
	"Maerchen Veil (Japan)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_ACTION | GBF_RPG, 0,
	NESGetZipName, fds_maerchenveilRomInfo, fds_maerchenveilRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Magma Project - Hacker (Japan)
static struct BurnRomInfo fds_magmaproRomDesc[] = {
	{ "Magma Project - Hacker (Japan).fds",          131016, 0x59d51115, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_magmapro, fds_magmapro, fds_fdsbios)
STD_ROM_FN(fds_magmapro)

struct BurnDriver BurnDrvfds_magmapro = {
	"fds_magmapro", NULL, "fds_fdsbios", NULL, "1989",
	"Magma Project - Hacker (Japan)\0", NULL, "Bits Laboratory", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_RPG, 0,
	NESGetZipName, fds_magmaproRomInfo, fds_magmaproRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Matou no Houkai - The Hero of Babel (Japan)
static struct BurnRomInfo fds_matounohouRomDesc[] = {
	{ "Matou no Houkai - The Hero of Babel (Japan).fds",          131016, 0x0596b36a, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_matounohou, fds_matounohou, fds_fdsbios)
STD_ROM_FN(fds_matounohou)

struct BurnDriver BurnDrvfds_matounohou = {
	"fds_matounohou", NULL, "fds_fdsbios", NULL, "1988",
	"Matou no Houkai - The Hero of Babel (Japan)\0", NULL, "Pony Canyon", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_PLATFORM, 0,
	NESGetZipName, fds_matounohouRomInfo, fds_matounohouRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Meikyuu Jiin Dababa (Japan)
static struct BurnRomInfo fds_meikyjiidabjRomDesc[] = {
	{ "Meikyuu Jiin Dababa (Japan).fds",          131000, 0x1526d32e, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_meikyjiidabj, fds_meikyjiidabj, fds_fdsbios)
STD_ROM_FN(fds_meikyjiidabj)

struct BurnDriver BurnDrvfds_meikyjiidabj = {
	"fds_meikyjiidabj", "fds_meikyjiidab", "fds_fdsbios", NULL, "1987",
	"Meikyuu Jiin Dababa (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_FDS, GBF_RUNGUN, 0,
	NESGetZipName, fds_meikyjiidabjRomInfo, fds_meikyjiidabjRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Meikyuu Jiin Dababa (Hack, English)
// https://www.romhacking.net/translations/2918/
static struct BurnRomInfo fds_meikyjiidabRomDesc[] = {
	{ "Meikyuu Jiin Dababa (T-Eng).fds",          131000, 0x4d13e6b7, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_meikyjiidab, fds_meikyjiidab, fds_fdsbios)
STD_ROM_FN(fds_meikyjiidab)

struct BurnDriver BurnDrvfds_meikyjiidab = {
	"fds_meikyjiidab", NULL, "fds_fdsbios", NULL, "2017",
	"Meikyuu Jiin Dababa (Hack, English)\0", NULL, "FlashPV", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_FDS, GBF_RUNGUN, 0,
	NESGetZipName, fds_meikyjiidabRomInfo, fds_meikyjiidabRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Metroid (Japan)
static struct BurnRomInfo fds_metroidjRomDesc[] = {
	{ "Metroid (Japan).fds",          131000, 0x5e4f013d, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_metroidj, fds_metroidj, fds_fdsbios)
STD_ROM_FN(fds_metroidj)

struct BurnDriver BurnDrvfds_metroidj = {
	"fds_metroidj", "fds_metroid", "fds_fdsbios", NULL, "1986",
	"Metroid (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_FDS, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, fds_metroidjRomInfo, fds_metroidjRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Metroid (Hack, English)
// https://www.romhacking.net/translations/3183/
static struct BurnRomInfo fds_metroidRomDesc[] = {
	{ "Metroid (T-Eng).fds",          131000, 0x2711adba, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_metroid, fds_metroid, fds_fdsbios)
STD_ROM_FN(fds_metroid)

struct BurnDriver BurnDrvfds_metroid = {
	"fds_metroid", NULL, "fds_fdsbios", NULL, "2016",
	"Metroid (Hack, English)\0", NULL, "Jordiway73", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_FDS, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, fds_metroidRomInfo, fds_metroidRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Michael English Daibouken (Japan)
static struct BurnRomInfo fds_michaengdaiRomDesc[] = {
	{ "Michael English Daibouken (Japan).fds",          131000, 0xe5ab0e6c, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_michaengdai, fds_michaengdai, fds_fdsbios)
STD_ROM_FN(fds_michaengdai)

struct BurnDriver BurnDrvfds_michaengdai = {
	"fds_michaengdai", NULL, "fds_fdsbios", NULL, "1987",
	"Michael English Daibouken (Japan)\0", NULL, "Scorpion Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_ACTION, 0,
	NESGetZipName, fds_michaengdaiRomInfo, fds_michaengdaiRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Moero TwinBee - Cinnamon Hakase wo Sukue! (Japan)
static struct BurnRomInfo fds_moerotwiRomDesc[] = {
	{ "Moero TwinBee - Cinnamon Hakase wo Sukue! (Japan).fds",          131016, 0x0d684aa7, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_moerotwi, fds_moerotwi, fds_fdsbios)
STD_ROM_FN(fds_moerotwi)

struct BurnDriver BurnDrvfds_moerotwi = {
	"fds_moerotwi", NULL, "fds_fdsbios", NULL, "1986",
	"Moero TwinBee - Cinnamon Hakase wo Sukue! (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 3, HARDWARE_FDS, GBF_HORSHOOT, 0,
	NESGetZipName, fds_moerotwiRomInfo, fds_moerotwiRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Monty on the Run - Monty no Doki Doki Dai Dassou (Japan)
static struct BurnRomInfo fds_montyonrunjRomDesc[] = {
	{ "Monty on the Run - Monty no Doki Doki Dai Dassou (Japan).fds",          131016, 0xbb7ab325, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_montyonrunj, fds_montyonrunj, fds_fdsbios)
STD_ROM_FN(fds_montyonrunj)

struct BurnDriver BurnDrvfds_montyonrunj = {
	"fds_montyonrunj", "fds_montyonrun", "fds_fdsbios", NULL, "1987",
	"Monty on the Run - Monty no Doki Doki Dai Dassou (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_FDS, GBF_PLATFORM, 0,
	NESGetZipName, fds_montyonrunjRomInfo, fds_montyonrunjRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Monty on the Run - Monty no Doki Doki Dai Dassou (Hack, English)
// https://www.romhacking.net/translations/1545/
static struct BurnRomInfo fds_montyonrunRomDesc[] = {
	{ "Monty on the Run - Monty no Doki Doki Dai Dassou (T-Eng).fds",          131001, 0xd7242483, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_montyonrun, fds_montyonrun, fds_fdsbios)
STD_ROM_FN(fds_montyonrun)

struct BurnDriver BurnDrvfds_montyonrun = {
	"fds_montyonrun", NULL, "fds_fdsbios", NULL, "2021",
	"Monty on the Run - Monty no Doki Doki Dai Dassou (Hack, English)\0", NULL, "Stardust Crusaders", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_FDS, GBF_PLATFORM, 0,
	NESGetZipName, fds_montyonrunRomInfo, fds_montyonrunRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Moonball Magic (Japan)
static struct BurnRomInfo fds_moonballmagicRomDesc[] = {
	{ "Moonball Magic (Japan).fds",          131016, 0x99a87df8, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_moonballmagic, fds_moonballmagic, fds_fdsbios)
STD_ROM_FN(fds_moonballmagic)

struct BurnDriver BurnDrvfds_moonballmagic = {
	"fds_moonballmagic", NULL, "fds_fdsbios", NULL, "1988",
	"Moonball Magic (Japan)\0", NULL, "System Sacom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_PINBALL, 0,
	NESGetZipName, fds_moonballmagicRomInfo, fds_moonballmagicRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mysterious Murasame Castle, The (Hack, English)
// https://www.romhacking.net/translations/628/
static struct BurnRomInfo fds_mystemurcasRomDesc[] = {
	{ "Mysterious Murasame Castle (T-Eng).fds",          131000, 0x5da99951, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_mystemurcas, fds_mystemurcas, fds_fdsbios)
STD_ROM_FN(fds_mystemurcas)

struct BurnDriver BurnDrvfds_mystemurcas = {
	"fds_mystemurcas", NULL, "fds_fdsbios", NULL, "2011",
	"Mysterious Murasame Castle, The (Hack, English)\0", NULL, "Spinner 8 and friends", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_FDS, GBF_ACTION, 0,
	NESGetZipName, fds_mystemurcasRomInfo, fds_mystemurcasRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Namida no Soukoban Special (Japan)
static struct BurnRomInfo fds_namidaRomDesc[] = {
	{ "Namida no Soukoban Special (Japan).fds",          131000, 0x0c5b12d6, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_namida, fds_namida, fds_fdsbios)
STD_ROM_FN(fds_namida)

struct BurnDriver BurnDrvfds_namida = {
	"fds_namida", NULL, "fds_fdsbios", NULL, "1986",
	"Namida no Soukoban Special (Japan)\0", NULL, "ASCII Corp.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_PUZZLE, 0,
	NESGetZipName, fds_namidaRomInfo, fds_namidaRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Nazo no Kabe - Block Kuzushi (Japan)
static struct BurnRomInfo fds_nazonokabRomDesc[] = {
	{ "Nazo no Kabe - Block Kuzushi (Japan).fds",          131000, 0x09292f11, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_nazonokab, fds_nazonokab, fds_fdsbios)
STD_ROM_FN(fds_nazonokab)

struct BurnDriver BurnDrvfds_nazonokab = {
	"fds_nazonokab", NULL, "fds_fdsbios", NULL, "1986",
	"Nazo no Kabe - Block Kuzushi (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_BREAKOUT, 0,
	NESGetZipName, fds_nazonokabRomInfo, fds_nazonokabRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Nazo no Murasamejou (Japan)
static struct BurnRomInfo fds_nazonomurRomDesc[] = {
	{ "Nazo no Murasamejou (Japan).fds",          131016, 0x2acde825, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_nazonomur, fds_nazonomur, fds_fdsbios)
STD_ROM_FN(fds_nazonomur)

struct BurnDriver BurnDrvfds_nazonomur = {
	"fds_nazonomur", "fds_mystemurcas", "fds_fdsbios", NULL, "1986",
	"Nazo no Murasamejou (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_FDS, GBF_ACTION, 0,
	NESGetZipName, fds_nazonomurRomInfo, fds_nazonomurRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Otocky (Japan)
static struct BurnRomInfo fds_otockyRomDesc[] = {
	{ "Otocky (Japan).fds",          131016, 0xd7a49861, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_otocky, fds_otocky, fds_fdsbios)
STD_ROM_FN(fds_otocky)

struct BurnDriver BurnDrvfds_otocky = {
	"fds_otocky", NULL, "fds_fdsbios", NULL, "1987",
	"Otocky (Japan)\0", NULL, "ASCII Corp.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_HORSHOOT, 0,
	NESGetZipName, fds_otockyRomInfo, fds_otockyRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo fds_patlaRomDesc[] = {
	{ "Patlabor - The Mobile Police - Dai 2 Shoutai Shutsudou Seyo! (Japan).fds",          131016, 0xb5639859, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_patla, fds_patla, fds_fdsbios)
STD_ROM_FN(fds_patla)

struct BurnDriver BurnDrvfds_patla = {
	"fds_patla", "fds_patlaen", "fds_fdsbios", NULL, "1989",
	"Patlabor - The Mobile Police - Dai 2 Shoutai Shutsudou Seyo! (Japan)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_FDS, GBF_SHOOT | GBF_PLATFORM, 0,
	NESGetZipName, fds_patlaRomInfo, fds_patlaRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo fds_patlaenRomDesc[] = {
	{ "Patlabor - The Mobile Police - Dai 2 Shoutai Shutsudou Seyo! T-Eng (2003)(Vice Translations).fds",          131016, 0x9d8236f8, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_patlaen, fds_patlaen, fds_fdsbios)
STD_ROM_FN(fds_patlaen)

struct BurnDriver BurnDrvfds_patlaen = {
	"fds_patlaen", NULL, "fds_fdsbios", NULL, "2003",
	"Patlabor - The Mobile Police - Dai 2 Shoutai Shutsudou Seyo! (Hack, English)\0", NULL, "Vice Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_FDS, GBF_SHOOT | GBF_PLATFORM, 0,
	NESGetZipName, fds_patlaenRomInfo, fds_patlaenRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo fds_progolsarkagnotoRomDesc[] = {
	{ "Pro Golfer Saru - Kage no Tournament (Japan).fds",          131016, 0x8261910e, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_progolsarkagnoto, fds_progolsarkagnoto, fds_fdsbios)
STD_ROM_FN(fds_progolsarkagnoto)

struct BurnDriver BurnDrvfds_progolsarkagnoto = {
	"fds_progolsarkagnoto", NULL, "fds_fdsbios", NULL, "1987",
	"Pro Golfer Saru - Kage no Tournament (Japan)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_SPORTSMISC, 0,
	NESGetZipName, fds_progolsarkagnotoRomInfo, fds_progolsarkagnotoRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo fds_puttputtgolfRomDesc[] = {
	{ "Putt Putt Golf (Japan).fds",          131016, 0x0ac52ae0, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_puttputtgolf, fds_puttputtgolf, fds_fdsbios)
STD_ROM_FN(fds_puttputtgolf)

struct BurnDriver BurnDrvfds_puttputtgolf = {
	"fds_puttputtgolf", NULL, "fds_fdsbios", NULL, "1989",
	"Putt Putt Golf (Japan)\0", NULL, "Pack-In-Video", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_SPORTSMISC, 0,
	NESGetZipName, fds_puttputtgolfRomInfo, fds_puttputtgolfRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo fds_puzzleboysjRomDesc[] = {
	{ "Puzzle Boys (Japan).fds",          131000, 0xb9f22094, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_puzzleboysj, fds_puzzleboysj, fds_fdsbios)
STD_ROM_FN(fds_puzzleboysj)

struct BurnDriver BurnDrvfds_puzzleboysj = {
	"fds_puzzleboysj", "fds_puzzleboys", "fds_fdsbios", NULL, "1990",
	"Puzzle Boys (Japan)\0", NULL, "Atlus", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_FDS, GBF_PUZZLE, 0,
	NESGetZipName, fds_puzzleboysjRomInfo, fds_puzzleboysjRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo fds_puzzleboysRomDesc[] = {
	{ "Puzzle Boys (T-Eng).fds",          131000, 0xfa03eba9, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_puzzleboys, fds_puzzleboys, fds_fdsbios)
STD_ROM_FN(fds_puzzleboys)

struct BurnDriver BurnDrvfds_puzzleboys = {
	"fds_puzzleboys", NULL, "fds_fdsbios", NULL, "2011",
	"Puzzle Boys (Hack, English)\0", NULL, "DvD Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_FDS, GBF_PUZZLE, 0,
	NESGetZipName, fds_puzzleboysRomInfo, fds_puzzleboysRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo fds_radicbomjirkunRomDesc[] = {
	{ "Radical Bomber!! Jirai-kun (Japan).fds",          131016, 0x2b41056b, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_radicbomjirkun, fds_radicbomjirkun, fds_fdsbios)
STD_ROM_FN(fds_radicbomjirkun)

struct BurnDriver BurnDrvfds_radicbomjirkun = {
	"fds_radicbomjirkun", NULL, "fds_fdsbios", NULL, "1988",
	"Radical Bomber!! Jirai-kun (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_PUZZLE | GBF_ADV, 0,
	NESGetZipName, fds_radicbomjirkunRomInfo, fds_radicbomjirkunRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Reflect World (Japan)
static struct BurnRomInfo fds_reflectworldRomDesc[] = {
	{ "Reflect World (Japan).fds",          131016, 0x2c24cd2d, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_reflectworld, fds_reflectworld, fds_fdsbios)
STD_ROM_FN(fds_reflectworld)

struct BurnDriver BurnDrvfds_reflectworld = {
	"fds_reflectworld", NULL, "fds_fdsbios", NULL, "1987",
	"Reflect World (Japan)\0", NULL, "East Cube", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_SHOOT | GBF_RPG, 0,
	NESGetZipName, fds_reflectworldRomInfo, fds_reflectworldRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Relics - Ankoku Yousai (Japan)
static struct BurnRomInfo fds_relicsRomDesc[] = {
	{ "Relics - Ankoku Yousai (Japan).fds",          131016, 0xfb0ae491, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_relics, fds_relics, fds_fdsbios)
STD_ROM_FN(fds_relics)

struct BurnDriver BurnDrvfds_relics = {
	"fds_relics", "fds_relicsen", "fds_fdsbios", NULL, "1987",
	"Relics - Ankoku Yousai (Japan)\0", NULL, "Bothtec", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_FDS, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, fds_relicsRomInfo, fds_relicsRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Relics - The Dark Fortress (Hack, English)
// https://www.romhacking.net/translations/7086/
static struct BurnRomInfo fds_relicsenRomDesc[] = {
	{ "Relics - Ankoku Yousai T-Eng (2023)(BlackPaladin).fds",          131000, 0x389a10ad, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_relicsen, fds_relicsen, fds_fdsbios)
STD_ROM_FN(fds_relicsen)

struct BurnDriver BurnDrvfds_relicsen = {
	"fds_relicsen", NULL, "fds_fdsbios", NULL, "2023",
	"Relics - The Dark Fortress (Hack, English)\0", NULL, "BlackPaladin", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_FDS, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, fds_relicsenRomInfo, fds_relicsenRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Replicart (Japan)
static struct BurnRomInfo fds_replicartRomDesc[] = {
	{ "Replicart (Japan).fds",          131016, 0xc3cbc847, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_replicart, fds_replicart, fds_fdsbios)
STD_ROM_FN(fds_replicart)

struct BurnDriver BurnDrvfds_replicart = {
	"fds_replicart", NULL, "fds_fdsbios", NULL, "1988",
	"Replicart (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_ACTION, 0,
	NESGetZipName, fds_replicartRomInfo, fds_replicartRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Return of Mario Bros. (Hack, English)
// https://www.romhacking.net/translations/6364/
static struct BurnRomInfo fds_returnmarbroRomDesc[] = {
	{ "Return of Mario Bros. T-Eng (2021)(FCandChill).fds",          131000, 0xc3c31d57, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_returnmarbro, fds_returnmarbro, fds_fdsbios)
STD_ROM_FN(fds_returnmarbro)

struct BurnDriver BurnDrvfds_returnmarbro = {
	"fds_returnmarbro", NULL, "fds_fdsbios", NULL, "2021",
	"Return of Mario Bros. (Hack, English)\0", NULL, "FCandChill", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_FDS, GBF_PLATFORM, 0,
	NESGetZipName, fds_returnmarbroRomInfo, fds_returnmarbroRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Roger Rabbit (Japan)
static struct BurnRomInfo fds_rogerrabbitRomDesc[] = {
	{ "Roger Rabbit (Japan).fds",          131016, 0xb43f9b16, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_rogerrabbit, fds_rogerrabbit, fds_fdsbios)
STD_ROM_FN(fds_rogerrabbit)

struct BurnDriver BurnDrvfds_rogerrabbit = {
	"fds_rogerrabbit", NULL, "fds_fdsbios", NULL, "1989",
	"Roger Rabbit (Japan)\0", NULL, "Kemco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_PLATFORM, 0,
	NESGetZipName, fds_rogerrabbitRomInfo, fds_rogerrabbitRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Samurai Sword (Japan)
static struct BurnRomInfo fds_samswordRomDesc[] = {
	{ "Samurai Sword (Japan)(1988)(Capcom).fds",          131016, 0x5ca021ff, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_samsword, fds_samsword, fds_fdsbios)
STD_ROM_FN(fds_samsword)

struct BurnDriver BurnDrvfds_samsword = {
	"fds_samsword", "fds_samsworden", "fds_fdsbios", NULL, "1988",
	"Samurai Sword (Japan)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_FDS, GBF_ADV, 0,
	NESGetZipName, fds_samswordRomInfo, fds_samswordRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Samurai Sword (Hack, English)
// https://www.romhacking.net/translations/699/
static struct BurnRomInfo fds_samswordenRomDesc[] = {
	{ "Samurai Sword (T-Eng)(2003)(Mute).fds",          131016, 0x45ddd0f4, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_samsworden, fds_samsworden, fds_fdsbios)
STD_ROM_FN(fds_samsworden)

struct BurnDriver BurnDrvfds_samsworden = {
	"fds_samsworden", NULL, "fds_fdsbios", NULL, "2003",
	"Samurai Sword (Hack, English)\0", NULL, "Mute", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_FDS, GBF_ADV, 0,
	NESGetZipName, fds_samswordenRomInfo, fds_samswordenRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// SD Gundam World - Gachapon Senshi - Scramble Wars (Japan)
static struct BurnRomInfo fds_sdgunworgacsescwaRomDesc[] = {
	{ "SD Gundam World - Gachapon Senshi - Scramble Wars (Japan).fds",          131000, 0x9d287c3f, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_sdgunworgacsescwa, fds_sdgunworgacsescwa, fds_fdsbios)
STD_ROM_FN(fds_sdgunworgacsescwa)

struct BurnDriver BurnDrvfds_sdgunworgacsescwa = {
	"fds_sdgunworgacsescwa", NULL, "fds_fdsbios", NULL, "1987",
	"SD Gundam World - Gachapon Senshi - Scramble Wars (Japan)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_STRATEGY, 0,
	NESGetZipName, fds_sdgunworgacsescwaRomInfo, fds_sdgunworgacsescwaRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Section-Z (Japan)
static struct BurnRomInfo fds_sectionzRomDesc[] = {
	{ "Section-Z (Japan).fds",          131016, 0x392488e2, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_sectionz, fds_sectionz, fds_fdsbios)
STD_ROM_FN(fds_sectionz)

struct BurnDriver BurnDrvfds_sectionz = {
	"fds_sectionz", NULL, "fds_fdsbios", NULL, "1987",
	"Section-Z (Japan)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_HORSHOOT, 0,
	NESGetZipName, fds_sectionzRomInfo, fds_sectionzRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Seiken Psychocalibur - Majuu no Mori Densetsu (Japan)
static struct BurnRomInfo fds_seikepsyjRomDesc[] = {
	{ "Seiken Psychocalibur - Majuu no Mori Densetsu (Japan).fds",          131000, 0xaea5691a, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_seikepsyj, fds_seikepsyj, fds_fdsbios)
STD_ROM_FN(fds_seikepsyj)

struct BurnDriver BurnDrvfds_seikepsyj = {
	"fds_seikepsyj", "fds_seikepsy", "fds_fdsbios", NULL, "1987",
	"Seiken Psychocalibur - Majuu no Mori Densetsu (Japan)\0", NULL, "Imagineer", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_FDS, GBF_ACTION | GBF_RPG, 0,
	NESGetZipName, fds_seikepsyjRomInfo, fds_seikepsyjRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Seiken Psychocalibur - Majuu no Mori Densetsu (Hack, English)
// https://www.romhacking.net/translations/8/
static struct BurnRomInfo fds_seikepsyRomDesc[] = {
	{ "Seiken Psychocalibur - Majuu no Mori Densetsu (T-Eng).fds",          131000, 0x1ec1552b, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_seikepsy, fds_seikepsy, fds_fdsbios)
STD_ROM_FN(fds_seikepsy)

struct BurnDriver BurnDrvfds_seikepsy = {
	"fds_seikepsy", NULL, "fds_fdsbios", NULL, "2013",
	"Seiken Psychocalibur - Majuu no Mori Densetsu (Hack, English)\0", NULL, "The Spoony Bard", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_FDS, GBF_ACTION | GBF_RPG, 0,
	NESGetZipName, fds_seikepsyRomInfo, fds_seikepsyRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Sexy Invaders (Japan)
static struct BurnRomInfo fds_sexyinvadersRomDesc[] = {
	{ "Sexy Invaders (Japan).fds",          131000, 0x413e49da, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_sexyinvaders, fds_sexyinvaders, fds_fdsbios)
STD_ROM_FN(fds_sexyinvaders)

struct BurnDriver BurnDrvfds_sexyinvaders = {
	"fds_sexyinvaders", NULL, "fds_fdsbios", NULL, "1990",
	"Sexy Invaders (Japan)\0", NULL, "Super Pig", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_SHOOT, 0,
	NESGetZipName, fds_sexyinvadersRomInfo, fds_sexyinvadersRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Silviana - Ai Ippai no Little Angel (Japan)
static struct BurnRomInfo fds_silvijRomDesc[] = {
	{ "Silviana - Ai Ippai no Little Angel (Japan).fds",          131016, 0x4d721d90, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_silvij, fds_silvij, fds_fdsbios)
STD_ROM_FN(fds_silvij)

struct BurnDriver BurnDrvfds_silvij = {
	"fds_silvij", "fds_silvi", "fds_fdsbios", NULL, "1988",
	"Silviana - Ai Ippai no Little Angel (Japan)\0", NULL, "Pack-In-Video", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_FDS, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, fds_silvijRomInfo, fds_silvijRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Silviana - Ai Ippai no Little Angel (Hack, English)
// https://www.romhacking.net/translations/616/
static struct BurnRomInfo fds_silviRomDesc[] = {
	{ "Silviana - Ai Ippai no Little Angel (T-Eng).fds",          131000, 0xc5b1bff7, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_silvi, fds_silvi, fds_fdsbios)
STD_ROM_FN(fds_silvi)

struct BurnDriver BurnDrvfds_silvi = {
	"fds_silvi", NULL, "fds_fdsbios", NULL, "2002",
	"Silviana - Ai Ippai no Little Angel (Hack, English)\0", NULL, "Mute", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_FDS, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, fds_silviRomInfo, fds_silviRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Smash Ping Pong (Japan)
static struct BurnRomInfo fds_smashpingpongRomDesc[] = {
	{ "Smash Ping Pong (Japan).fds",          131016, 0xcc1eb0dc, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_smashpingpong, fds_smashpingpong, fds_fdsbios)
STD_ROM_FN(fds_smashpingpong)

struct BurnDriver BurnDrvfds_smashpingpong = {
	"fds_smashpingpong", NULL, "fds_fdsbios", NULL, "1987",
	"Smash Ping Pong (Japan)\0", NULL, "Nintendo - Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_SPORTSMISC, 0,
	NESGetZipName, fds_smashpingpongRomInfo, fds_smashpingpongRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Solomon no Kagi (Japan)
static struct BurnRomInfo fds_solomonnokagiRomDesc[] = {
	{ "Solomon no Kagi (Japan).fds",          65500, 0x5e298400, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_solomonnokagi, fds_solomonnokagi, fds_fdsbios)
STD_ROM_FN(fds_solomonnokagi)

struct BurnDriver BurnDrvfds_solomonnokagi = {
	"fds_solomonnokagi", NULL, "fds_fdsbios", NULL, "1987",
	"Solomon no Kagi (Japan)\0", NULL, "Tecmo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_PLATFORM | GBF_PUZZLE, 0,
	NESGetZipName, fds_solomonnokagiRomInfo, fds_solomonnokagiRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Boy Allan (Japan)
static struct BurnRomInfo fds_superboyallanRomDesc[] = {
	{ "Super Boy Allan (Japan).fds",          131016, 0xfdc53496, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_superboyallan, fds_superboyallan, fds_fdsbios)
STD_ROM_FN(fds_superboyallan)

struct BurnDriver BurnDrvfds_superboyallan = {
	"fds_superboyallan", NULL, "fds_fdsbios", NULL, "1987",
	"Super Boy Allan (Japan)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_ACTION | GBF_PUZZLE, 0,
	NESGetZipName, fds_superboyallanRomInfo, fds_superboyallanRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Lode Runner (Japan)
static struct BurnRomInfo fds_superlodrunRomDesc[] = {
	{ "Super Lode Runner (Japan).fds",          131000, 0xe66f4682, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_superlodrun, fds_superlodrun, fds_fdsbios)
STD_ROM_FN(fds_superlodrun)

struct BurnDriver BurnDrvfds_superlodrun = {
	"fds_superlodrun", NULL, "fds_fdsbios", NULL, "1987",
	"Super Lode Runner (Japan)\0", NULL, "Irem", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_ACTION, 0,
	NESGetZipName, fds_superlodrunRomInfo, fds_superlodrunRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Lode Runner II (Japan)
static struct BurnRomInfo fds_superlodruniiRomDesc[] = {
	{ "Super Lode Runner II (Japan).fds",          131000, 0x758888f4, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_superlodrunii, fds_superlodrunii, fds_fdsbios)
STD_ROM_FN(fds_superlodrunii)

struct BurnDriver BurnDrvfds_superlodrunii = {
	"fds_superlodrunii", NULL, "fds_fdsbios", NULL, "1987",
	"Super Lode Runner II (Japan)\0", NULL, "Irem", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_ACTION, 0,
	NESGetZipName, fds_superlodruniiRomInfo, fds_superlodruniiRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Mario Brothers (Japan)
static struct BurnRomInfo fds_supermarbroRomDesc[] = {
	{ "Super Mario Brothers (Japan).fds",          65500, 0xe0890cf2, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_supermarbro, fds_supermarbro, fds_fdsbios)
STD_ROM_FN(fds_supermarbro)

struct BurnDriver BurnDrvfds_supermarbro = {
	"fds_supermarbro", NULL, "fds_fdsbios", NULL, "1986",
	"Super Mario Brothers (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_PLATFORM, 0,
	NESGetZipName, fds_supermarbroRomInfo, fds_supermarbroRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Mario Brothers 2 (Japan)
static struct BurnRomInfo fds_supermarbro2RomDesc[] = {
	{ "Super Mario Brothers 2 (Japan).fds",          131016, 0x443ed7b3, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_supermarbro2, fds_supermarbro2, fds_fdsbios)
STD_ROM_FN(fds_supermarbro2)

struct BurnDriver BurnDrvfds_supermarbro2 = {
	"fds_supermarbro2", NULL, "fds_fdsbios", NULL, "1986",
	"Super Mario Brothers 2 (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_PLATFORM, 0,
	NESGetZipName, fds_supermarbro2RomInfo, fds_supermarbro2RomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Mario Brothers 2 (Japan) (DV 2)
static struct BurnRomInfo fds_supermarbro2eRomDesc[] = {
	{ "Super Mario Bros 2 (J)(En)(DV 2)(1986)(Nintendo).fds",          65500, 0x5c419ee8, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_supermarbro2e, fds_supermarbro2e, fds_fdsbios)
STD_ROM_FN(fds_supermarbro2e)

struct BurnDriver BurnDrvfds_supermarbro2e = {
	"fds_supermarbro2e", "fds_supermarbro2", "fds_fdsbios", NULL, "1986",
	"Super Mario Brothers 2 (Japan) (DV 2)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_FDS, GBF_PLATFORM, 0,
	NESGetZipName, fds_supermarbro2eRomInfo, fds_supermarbro2eRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Mario Brothers 2 (Hack, Bugs Fix)
// https://www.romhacking.net/hacks/8299/
static struct BurnRomInfo fds_supermarbro2fixRomDesc[] = {
	{ "Super Mario Bros 2 (Disk Revision 3)(2023)(ShaneM).fds",          65516, 0x73d374ad, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_supermarbro2fix, fds_supermarbro2fix, fds_fdsbios)
STD_ROM_FN(fds_supermarbro2fix)

struct BurnDriver BurnDrvfds_supermarbro2fix = {
	"fds_supermarbro2fix", "fds_supermarbro2", "fds_fdsbios", NULL, "2023",
	"Super Mario Brothers 2 (Hack, Bugs Fix)\0", NULL, "ShaneM", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_FDS, GBF_PLATFORM, 0,
	NESGetZipName, fds_supermarbro2fixRomInfo, fds_supermarbro2fixRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tama & Friends - 3 Choume Daibouken (Japan)
static struct BurnRomInfo fds_tamafriRomDesc[] = {
	{ "Tama & Friends - 3 Choume Daibouken (Japan).fds",          131016, 0x8751a949, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_tamafri, fds_tamafri, fds_fdsbios)
STD_ROM_FN(fds_tamafri)

struct BurnDriver BurnDrvfds_tamafri = {
	"fds_tamafri", NULL, "fds_fdsbios", NULL, "1989",
	"Tama & Friends - 3 Choume Daibouken (Japan)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_PLATFORM, 0,
	NESGetZipName, fds_tamafriRomInfo, fds_tamafriRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tennis (Japan)
static struct BurnRomInfo fds_tennisRomDesc[] = {
	{ "Tennis (Japan).fds",          65516, 0x136c64ed, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_tennis, fds_tennis, fds_fdsbios)
STD_ROM_FN(fds_tennis)

struct BurnDriver BurnDrvfds_tennis = {
	"fds_tennis", NULL, "fds_fdsbios", NULL, "1986",
	"Tennis (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_SPORTSMISC, 0,
	NESGetZipName, fds_tennisRomInfo, fds_tennisRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tobidase Daisakusen (Japan)
static struct BurnRomInfo fds_tobiddaiRomDesc[] = {
	{ "Tobidase Daisakusen (Japan).fds",          131016, 0x95546107, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_tobiddai, fds_tobiddai, fds_fdsbios)
STD_ROM_FN(fds_tobiddai)

struct BurnDriver BurnDrvfds_tobiddai = {
	"fds_tobiddai", NULL, "fds_fdsbios", NULL, "1987",
	"Tobidase Daisakusen (Japan)\0", NULL, "Square", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_ACTION, 0,
	NESGetZipName, fds_tobiddaiRomInfo, fds_tobiddaiRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Topple Zip (Japan)
static struct BurnRomInfo fds_topplezipRomDesc[] = {
	{ "Topple Zip (Japan).fds",          131016, 0x7bf73c75, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_topplezip, fds_topplezip, fds_fdsbios)
STD_ROM_FN(fds_topplezip)

struct BurnDriver BurnDrvfds_topplezip = {
	"fds_topplezip", NULL, "fds_fdsbios", NULL, "1987",
	"Topple Zip (Japan)\0", NULL, "Bothtec", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_VERSHOOT, 0,
	NESGetZipName, fds_topplezipRomInfo, fds_topplezipRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo fds_transRomDesc[] = {
	{ "Transformers - The Headmasters (Japan).fds",          131016, 0x8bd904cd, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_trans, fds_trans, fds_fdsbios)
STD_ROM_FN(fds_trans)

struct BurnDriver BurnDrvfds_trans = {
	"fds_trans", NULL, "fds_fdsbios", NULL, "1987",
	"Transformers - The Headmasters (Japan)\0", NULL, "Takara", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_HORSHOOT, 0,
	NESGetZipName, fds_transRomInfo, fds_transRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo fds_twinbeeRomDesc[] = {
	{ "TwinBee (Japan).fds",          65500, 0x517be396, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_twinbee, fds_twinbee, fds_fdsbios)
STD_ROM_FN(fds_twinbee)

struct BurnDriver BurnDrvfds_twinbee = {
	"fds_twinbee", NULL, "fds_fdsbios", NULL, "1988",
	"TwinBee (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_VERSHOOT, 0,
	NESGetZipName, fds_twinbeeRomInfo, fds_twinbeeRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo fds_ultraRomDesc[] = {
	{ "Ultraman - Kaijuu Teikoku no Gyakushuu (Japan).fds",          131016, 0x2ab0c9bd, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_ultra, fds_ultra, fds_fdsbios)
STD_ROM_FN(fds_ultra)

struct BurnDriver BurnDrvfds_ultra = {
	"fds_ultra", NULL, "fds_fdsbios", NULL, "1986",
	"Ultraman - Kaijuu Teikoku no Gyakushuu (Japan)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_PLATFORM | GBF_SCRFIGHT, 0,
	NESGetZipName, fds_ultraRomInfo, fds_ultraRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo fds_ultra2RomDesc[] = {
	{ "Ultraman 2 - Shutsugeki Katoku Tai (Japan).fds",          131016, 0x4010e726, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_ultra2, fds_ultra2, fds_fdsbios)
STD_ROM_FN(fds_ultra2)

struct BurnDriver BurnDrvfds_ultra2 = {
	"fds_ultra2", NULL, "fds_fdsbios", NULL, "1987",
	"Ultraman 2 - Shutsugeki Katoku Tai (Japan)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_ACTION, 0,
	NESGetZipName, fds_ultra2RomInfo, fds_ultra2RomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo fds_ultracluRomDesc[] = {
	{ "Ultraman Club - Chikyuu Dakkan Sakusen (Japan).fds",          131000, 0xfd150e81, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_ultraclu, fds_ultraclu, fds_fdsbios)
STD_ROM_FN(fds_ultraclu)

struct BurnDriver BurnDrvfds_ultraclu = {
	"fds_ultraclu", NULL, "fds_fdsbios", NULL, "1988",
	"Ultraman Club - Chikyuu Dakkan Sakusen (Japan)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_ACTION | GBF_RPG, 0,
	NESGetZipName, fds_ultracluRomInfo, fds_ultracluRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo fds_volleyballRomDesc[] = {
	{ "Volleyball (Japan).fds",          65516, 0x0533c149, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_volleyball, fds_volleyball, fds_fdsbios)
STD_ROM_FN(fds_volleyball)

struct BurnDriver BurnDrvfds_volleyball = {
	"fds_volleyball", NULL, "fds_fdsbios", NULL, "1986",
	"Volleyball (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_SPORTSMISC, 0,
	NESGetZipName, fds_volleyballRomInfo, fds_volleyballRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo fds_vsexcitebikeRomDesc[] = {
	{ "Vs. Excitebike (Japan).fds",          131016, 0xb8a7c0a9, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_vsexcitebike, fds_vsexcitebike, fds_fdsbios)
STD_ROM_FN(fds_vsexcitebike)

struct BurnDriver BurnDrvfds_vsexcitebike = {
	"fds_vsexcitebike", NULL, "fds_fdsbios", NULL, "1988",
	"Vs. Excitebike (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_ACTION, 0,
	NESGetZipName, fds_vsexcitebikeRomInfo, fds_vsexcitebikeRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo fds_wakusatogaiRomDesc[] = {
	{ "Wakusei Aton Gaiden (Japan).fds",          131016, 0x94a825fa, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_wakusatogai, fds_wakusatogai, fds_fdsbios)
STD_ROM_FN(fds_wakusatogai)

struct BurnDriver BurnDrvfds_wakusatogai = {
	"fds_wakusatogai", NULL, "fds_fdsbios", NULL, "1990",
	"Wakusei Aton Gaiden (Japan)\0", NULL, "Kokuzeichou", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_VERSHOOT, 0,
	NESGetZipName, fds_wakusatogaiRomInfo, fds_wakusatogaiRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wardner no Mori (Japan)
static struct BurnRomInfo fds_wardnernomoriRomDesc[] = {
	{ "Wardner no Mori (Japan).fds",          131016, 0xb5a04f7e, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_wardnernomori, fds_wardnernomori, fds_fdsbios)
STD_ROM_FN(fds_wardnernomori)

struct BurnDriver BurnDrvfds_wardnernomori = {
	"fds_wardnernomori", NULL, "fds_fdsbios", NULL, "1988",
	"Wardner no Mori (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_PLATFORM, 0,
	NESGetZipName, fds_wardnernomoriRomInfo, fds_wardnernomoriRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Winter Games (Japan)
static struct BurnRomInfo fds_wintergamesRomDesc[] = {
	{ "Winter Games (Japan).fds",          131000, 0x6ab5e1d6, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_wintergames, fds_wintergames, fds_fdsbios)
STD_ROM_FN(fds_wintergames)

struct BurnDriver BurnDrvfds_wintergames = {
	"fds_wintergames", NULL, "fds_fdsbios", NULL, "1987",
	"Winter Games (Japan)\0", NULL, "Pony Canyon", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_SPORTSMISC, 0,
	NESGetZipName, fds_wintergamesRomInfo, fds_wintergamesRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wrecking Crew (Japan)
static struct BurnRomInfo fds_wreckingcrewRomDesc[] = {
	{ "Wrecking Crew (Japan).fds",          65516, 0xf341f135, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_wreckingcrew, fds_wreckingcrew, fds_fdsbios)
STD_ROM_FN(fds_wreckingcrew)

struct BurnDriver BurnDrvfds_wreckingcrew = {
	"fds_wreckingcrew", NULL, "fds_fdsbios", NULL, "1988",
	"Wrecking Crew (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_PLATFORM, 0,
	NESGetZipName, fds_wreckingcrewRomInfo, fds_wreckingcrewRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Youkai Yashiki (Japan)
static struct BurnRomInfo fds_youkaiyashikijRomDesc[] = {
	{ "Youkai Yashiki (Japan).fds",          131016, 0xa888c6df, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_youkaiyashikij, fds_youkaiyashikij, fds_fdsbios)
STD_ROM_FN(fds_youkaiyashikij)

struct BurnDriver BurnDrvfds_youkaiyashikij = {
	"fds_youkaiyashikij", "fds_youkaiyashiki", "fds_fdsbios", NULL, "1987",
	"Youkai Yashiki (Japan)\0", NULL, "Irem", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_FDS, GBF_PLATFORM, 0,
	NESGetZipName, fds_youkaiyashikijRomInfo, fds_youkaiyashikijRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Youkai Yashiki ~ Ghost Manor (Hack, English)
// https://www.romhacking.net/translations/1308/
static struct BurnRomInfo fds_youkaiyashikiRomDesc[] = {
	{ "Youkai Yashiki (T-Eng).fds",          131000, 0x546589ab, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_youkaiyashiki, fds_youkaiyashiki, fds_fdsbios)
STD_ROM_FN(fds_youkaiyashiki)

struct BurnDriver BurnDrvfds_youkaiyashiki = {
	"fds_youkaiyashiki", NULL, "fds_fdsbios", NULL, "2008",
	"Youkai Yashiki ~ Ghost Manor (Hack, English)\0", NULL, "KingMike's Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_FDS, GBF_PLATFORM, 0,
	NESGetZipName, fds_youkaiyashikiRomInfo, fds_youkaiyashikiRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Yuu Maze (Japan)
static struct BurnRomInfo fds_yuumazeRomDesc[] = {
	{ "Yuu Maze (Japan).fds",          131016, 0xde297106, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_yuumaze, fds_yuumaze, fds_fdsbios)
STD_ROM_FN(fds_yuumaze)

struct BurnDriver BurnDrvfds_yuumaze = {
	"fds_yuumaze", NULL, "fds_fdsbios", NULL, "1988",
	"Yuu Maze (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_FDS, GBF_MAZE | GBF_ACTION, 0,
	NESGetZipName, fds_yuumazeRomInfo, fds_yuumazeRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Zanac (Japan)
static struct BurnRomInfo fds_zanacRomDesc[] = {
	{ "Zanac (Japan).fds",          65516, 0xdaa74bc4, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_zanac, fds_zanac, fds_fdsbios)
STD_ROM_FN(fds_zanac)

struct BurnDriver BurnDrvfds_zanac = {
	"fds_zanac", NULL, "fds_fdsbios", NULL, "1986",
	"Zanac (Japan)\0", NULL, "Pony Canyon", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_FDS, GBF_VERSHOOT, 0,
	NESGetZipName, fds_zanacRomInfo, fds_zanacRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Zelda no Densetsu - The Hyrule Fantasy (Japan)
static struct BurnRomInfo fds_zeldanodenjRomDesc[] = {
	{ "Zelda no Densetsu - The Hyrule Fantasy (Japan).fds",          131016, 0x3fbdddcd, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_zeldanodenj, fds_zeldanodenj, fds_fdsbios)
STD_ROM_FN(fds_zeldanodenj)

struct BurnDriver BurnDrvfds_zeldanodenj = {
	"fds_zeldanodenj", "fds_zeldanoden", "fds_fdsbios", NULL, "1986",
	"Zelda no Densetsu - The Hyrule Fantasy (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_FDS, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, fds_zeldanodenjRomInfo, fds_zeldanodenjRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Zelda no Densetsu - The Hyrule Fantasy (Hack, English v1.1)
// https://www.romhacking.net/translations/2958/
static struct BurnRomInfo fds_zeldanodenRomDesc[] = {
	{ "Zelda no Densetsu - The Hyrule Fantasy (T-Eng).fds",          131016, 0xee11aa63, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_zeldanoden, fds_zeldanoden, fds_fdsbios)
STD_ROM_FN(fds_zeldanoden)

struct BurnDriver BurnDrvfds_zeldanoden = {
	"fds_zeldanoden", NULL, "fds_fdsbios", NULL, "2016",
	"Zelda no Densetsu - The Hyrule Fantasy (Hack, English v1.1)\0", NULL, "Jordiway73", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_FDS, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, fds_zeldanodenRomInfo, fds_zeldanodenRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};


// FDS END ---------------------------------------------------------------


// CPU TESTS
/*
#define WINNERS_DONT_USE_DRUGS 0
#if WINNERS_DONT_USE_DRUGS

static struct BurnRomInfo nestestRomDesc[] = {
	{ "nestest.nes",          24592, 0x9e179d92, BRF_ESS | BRF_PRG },
};


STD_ROM_PICK(nestest)
STD_ROM_FN(nestest)

struct BurnDriver BurnDrvnestest = {
	"nes_nestest", NULL, NULL, NULL, "1986",
	"nestest\0", NULL, "Kevtris", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING , 2, HARDWARE_NES, GBF_SHOOT,0 ,
	NESGetZipName, nestestRomInfo, nestestRomName,NULL,NULL,NULL,NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};


// PPU Tests

static struct BurnRomInfo nes_fullnespaletteRomDesc[] = {
	{ "full_nes_palette.nes",          16400, 0x273aeace, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_fullnespalette)
STD_ROM_FN(nes_fullnespalette)

struct BurnDriver BurnDrvnes_fullnespalette = {
	"nes_fullnespalette", NULL, NULL, NULL, "1989?",
	"full_nes_palette\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_fullnespaletteRomInfo, nes_fullnespaletteRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_fullRomDesc[] = {
	{ "full_nes_palette2.nes",          16400, 0x85784e11, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_full)
STD_ROM_FN(nes_full)

struct BurnDriver BurnDrvnes_full = {
	"nes_full", NULL, NULL, NULL, "1989?",
	"full nes palette (Blargg)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_fullRomInfo, nes_fullRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo bpaltestRomDesc[] = {
	{ "palette_ram.nes",          16400, 0x5d447e3c, BRF_ESS | BRF_PRG },
};


STD_ROM_PICK(bpaltest)
STD_ROM_FN(bpaltest)

struct BurnDriver BurnDrvbpaltest = {
	"nes_blarggppu", NULL, NULL, NULL, "1986",
	"Blargg pal ram test\0", NULL, "Blargg", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING , 2, HARDWARE_NES, GBF_SHOOT,0 ,
	NESGetZipName, bpaltestRomInfo, bpaltestRomName,NULL,NULL,NULL,NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo bpalpowertestRomDesc[] = {
	{ "power_up_palette.nes",          16400, 0x156f41f0, BRF_ESS | BRF_PRG },
};


STD_ROM_PICK(bpalpowertest)
STD_ROM_FN(bpalpowertest)

struct BurnDriver BurnDrvbpalpowertest = {
	"nes_blarggppu", NULL, NULL, NULL, "1986",
	"Blargg pal power on test\0", NULL, "Blargg", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING , 2, HARDWARE_NES, GBF_SHOOT,0 ,
	NESGetZipName, bpalpowertestRomInfo, bpalpowertestRomName,NULL,NULL,NULL,NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo bspriteramRomDesc[] = {
	{ "sprite_ram.nes",          16400, 0xd8d42111, BRF_ESS | BRF_PRG },
};


STD_ROM_PICK(bspriteram)
STD_ROM_FN(bspriteram)

struct BurnDriver BurnDrvbspriteram = {
	"nes_blarggppu", NULL, NULL, NULL, "1986",
	"Blargg sprite ram\0", NULL, "Blargg", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING , 2, HARDWARE_NES, GBF_SHOOT,0 ,
	NESGetZipName, bspriteramRomInfo, bspriteramRomName,NULL,NULL,NULL,NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo bvblRomDesc[] = {
	{ "vbl_clear_time.nes",          16400, 0x1e381801, BRF_ESS | BRF_PRG },
};


STD_ROM_PICK(bvbl)
STD_ROM_FN(bvbl)

struct BurnDriver BurnDrvbvbl = {
	"nes_blarggppu", NULL, NULL, NULL, "1986",
	"VBL test\0", NULL, "Blargg", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING , 2, HARDWARE_NES, GBF_SHOOT,0 ,
	NESGetZipName,bvblRomInfo, bvblRomName,NULL,NULL,NULL,NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo bvramRomDesc[] = {
	{ "vram_access.nes",          16400, 0xee115c9a, BRF_ESS | BRF_PRG },
};


STD_ROM_PICK(bvram)
STD_ROM_FN(bvram)

struct BurnDriver BurnDrvbbvram = {
	"nes_blarggppu", NULL, NULL, NULL, "1986",
	"VRAM test\0", NULL, "Blargg", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING , 2, HARDWARE_NES, GBF_SHOOT,0 ,
	NESGetZipName,bvramRomInfo, bvramRomName,NULL,NULL,NULL,NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};


static struct BurnRomInfo bsprite1RomDesc[] = {
	{ "01.basics.nes",          16400, 0xee115c9a, BRF_ESS | BRF_PRG },
};


STD_ROM_PICK(bsprite1)
STD_ROM_FN(bsprite1)

struct BurnDriver BurnDrvbsprite1 = {
	"nes_bsprites", NULL, NULL, NULL, "1986",
	"sprite test 1\0", NULL, "Blargg", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING , 2, HARDWARE_NES, GBF_SHOOT,0 ,
	NESGetZipName,bsprite1RomInfo, bsprite1RomName,NULL,NULL,NULL,NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo bsprite2RomDesc[] = {
	{ "02.alignment.nes",          16400, 0xee115c9a, BRF_ESS | BRF_PRG },
};


STD_ROM_PICK(bsprite2)
STD_ROM_FN(bsprite2)

struct BurnDriver BurnDrvbsprite2 = {
	"nes_bsprites", NULL, NULL, NULL, "1986",
	"sprite test 2\0", NULL, "Blargg", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING , 2, HARDWARE_NES, GBF_SHOOT,0 ,
	NESGetZipName,bsprite2RomInfo, bsprite2RomName,NULL,NULL,NULL,NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo bsprite3RomDesc[] = {
	{ "03.corners.nes",          16400, 0xee115c9a, BRF_ESS | BRF_PRG },
};


STD_ROM_PICK(bsprite3)
STD_ROM_FN(bsprite3)

struct BurnDriver BurnDrvbsprite3 = {
	"nes_bsprites", NULL, NULL, NULL, "1986",
	"sprite test 3\0", NULL, "Blargg", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING , 2, HARDWARE_NES, GBF_SHOOT,0 ,
	NESGetZipName,bsprite3RomInfo, bsprite3RomName,NULL,NULL,NULL,NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};


static struct BurnRomInfo bsprite4RomDesc[] = {
	{ "04.flip.nes",          16400, 0xee115c9a, BRF_ESS | BRF_PRG },
};


STD_ROM_PICK(bsprite4)
STD_ROM_FN(bsprite4)

struct BurnDriver BurnDrvbsprite4 = {
	"nes_bsprites", NULL, NULL, NULL, "1986",
	"sprite test 4\0", NULL, "Blargg", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING , 2, HARDWARE_NES, GBF_SHOOT,0 ,
	NESGetZipName,bsprite4RomInfo, bsprite4RomName,NULL,NULL,NULL,NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo bsprite5RomDesc[] = {
	{ "05.left_clip.nes",          16400, 0xee115c9a, BRF_ESS | BRF_PRG },
};


STD_ROM_PICK(bsprite5)
STD_ROM_FN(bsprite5)

struct BurnDriver BurnDrvbsprite5 = {
	"nes_bsprites", NULL, NULL, NULL, "1986",
	"sprite test 5\0", NULL, "Blargg", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING , 2, HARDWARE_NES, GBF_SHOOT,0 ,
	NESGetZipName,bsprite5RomInfo, bsprite5RomName,NULL,NULL,NULL,NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo bsprite6RomDesc[] = {
	{ "06.right_edge.nes",          16400, 0xee115c9a, BRF_ESS | BRF_PRG },
};


STD_ROM_PICK(bsprite6)
STD_ROM_FN(bsprite6)

struct BurnDriver BurnDrvbsprite6 = {
	"nes_bsprites", NULL, NULL, NULL, "1986",
	"sprite test 6\0", NULL, "Blargg", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING , 2, HARDWARE_NES, GBF_SHOOT,0 ,
	NESGetZipName,bsprite6RomInfo, bsprite6RomName,NULL,NULL,NULL,NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo bcputimeRomDesc[] = {
	{ "cpu_timing_test.nes",          16400, 0x161bc1fe, BRF_ESS | BRF_PRG },
};


STD_ROM_PICK(bcputime)
STD_ROM_FN(bcputime)

struct BurnDriver BurnDrvbcputime = {
	"nes_bcputime", NULL, NULL, NULL, "1986",
	"bcputime\0", NULL, "Blargg", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING , 2, HARDWARE_NES, GBF_SHOOT,0 ,
	NESGetZipName,bcputimeRomInfo, bcputimeRomName,NULL,NULL,NULL,NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo bcpuallRomDesc[] = {
	{ "all_instrs.nes",          262160, 0xA4400963, BRF_ESS | BRF_PRG },
};


STD_ROM_PICK(bcpuall)
STD_ROM_FN(bcpuall)

struct BurnDriver BurnDrvbcpuall = {
	"nes_bcputime", NULL, NULL, NULL, "1986",
	"cpu all instructions\0", NULL, "Blargg", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING , 2, HARDWARE_NES, GBF_SHOOT,0 ,
	NESGetZipName,bcpuallRomInfo,bcpuallRomName,NULL,NULL,NULL,NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_ruderRomDesc[] = {
	{ "ruder (HB).nes",          24592, 0x4c5c6008, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ruder)
STD_ROM_FN(nes_ruder)

struct BurnDriver BurnDrvnes_ruder = {
	"nes_ruder", NULL, NULL, NULL, "1989?",
	"Zapper ruder (test) (HB)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_ruderRomInfo, nes_ruderRomName, NULL, NULL, NULL, NULL, NESZapperInputInfo, NESZapperDIPInfo,
	NESZapperInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_allpadsRomDesc[] = {
	{ "allpads.nes",          32784, 0x9180a163, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_allpads)
STD_ROM_FN(nes_allpads)

struct BurnDriver BurnDrvnes_allpads = {
	"nes_allpads", NULL, NULL, NULL, "2016",
	"allpads\0", NULL, "tepples", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_allpadsRomInfo, nes_allpadsRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NESHori4pInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_apudinknoiseRomDesc[] = {
	{ "apu_dink_noise.nes",          32784, 0xb19c71f8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_apudinknoise)
STD_ROM_FN(nes_apudinknoise)

struct BurnDriver BurnDrvnes_apudinknoise = {
	"nes_apudinknoise", NULL, NULL, NULL, "1989?",
	"apu_dink_noise\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_apudinknoiseRomInfo, nes_apudinknoiseRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

#endif
*/

// ---------------------
// VS. NES/Famicom games
// ---------------------

static struct BurnRomInfo nes_vsrbibbalRomDesc[] = {
	{ "VS. Atari RBI Baseball (1987)(Atari Games).nes",          98320, 0xac95e2c9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vsrbibbal)
STD_ROM_FN(nes_vsrbibbal)

struct BurnDriver BurnDrvnes_vsrbibbal = {
	"vsrbibbal", NULL, NULL, NULL, "1987",
	"VS. Atari RBI Baseball\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_NVS, GBF_SPORTSMISC, 0,
	NULL, nes_vsrbibbalRomInfo, nes_vsrbibbalRomName, NULL, NULL, NULL, NULL, NESVSInputInfo, NESVSDIPInfo,
	NESReversedInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_vsbattlecityRomDesc[] = {
	{ "VS. Battle City (1985)(Namco).nes",          49168, 0x750048c0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vsbattlecity)
STD_ROM_FN(nes_vsbattlecity)

struct BurnDriver BurnDrvnes_vsbattlecity = {
	"vsbattlecity", NULL, NULL, NULL, "1985",
	"VS. Battle City\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_NVS, GBF_MAZE | GBF_SHOOT, 0,
	NULL, nes_vsbattlecityRomInfo, nes_vsbattlecityRomName, NULL, NULL, NULL, NULL, NESVSInputInfo, NESVSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_vscastlevaniaRomDesc[] = {
	{ "VS. Castlevania (1987)(Konami).nes",          131088, 0x584c758b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vscastlevania)
STD_ROM_FN(nes_vscastlevania)

struct BurnDriver BurnDrvnes_vscastlevania = {
	"vscastlevania", NULL, NULL, NULL, "1987",
	"VS. Castlevania\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 1, HARDWARE_NVS, GBF_PLATFORM, 0,
	NULL, nes_vscastlevaniaRomInfo, nes_vscastlevaniaRomName, NULL, NULL, NULL, NULL, NESVSInputInfo, NESVSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_vscluclulandRomDesc[] = {
	{ "VS. Clu Clu Land (1984)(Nintendo).nes",          49168, 0x8c68556d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vsclucluland)
STD_ROM_FN(nes_vsclucluland)

struct BurnDriver BurnDrvnes_vsclucluland = {
	"vsclucluland", NULL, NULL, NULL, "1984",
	"VS. Clu Clu Land\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_NVS, GBF_MAZE | GBF_ACTION, 0,
	NULL, nes_vscluclulandRomInfo, nes_vscluclulandRomName, NULL, NULL, NULL, NULL, NESVSInputInfo, NESVSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_vsdrmarioRomDesc[] = {
	{ "VS. Dr. Mario (1990)(Nintendo).nes",          98320, 0xce165ad2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vsdrmario)
STD_ROM_FN(nes_vsdrmario)

struct BurnDriver BurnDrvnes_vsdrmario = {
	"vsdrmario", NULL, NULL, NULL, "1990",
	"VS. Dr. Mario\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_NVS, GBF_PUZZLE, 0,
	NULL, nes_vsdrmarioRomInfo, nes_vsdrmarioRomName, NULL, NULL, NULL, NULL, NESVSInputInfo, NESVSDIPInfo,
	NESReversedInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_vsduckhuntRomDesc[] = {
	{ "VS. Duck Hunt (1984)(Nintendo).nes",          49168, 0xf08f6590, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vsduckhunt)
STD_ROM_FN(nes_vsduckhunt)

struct BurnDriver BurnDrvnes_vsduckhunt = {
	"vsduckhunt", NULL, NULL, NULL, "1984",
	"VS. Duck Hunt\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_NVS, GBF_SHOOT, 0,
	NULL, nes_vsduckhuntRomInfo, nes_vsduckhuntRomName, NULL, NULL, NULL, NULL, NESVSZapperInputInfo, NESVSZapperDIPInfo,
	NESZapperInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// VS. Excitebike
static struct BurnRomInfo nes_vsexcitebikeRomDesc[] = {
	{ "VS. Excitebike (1985)(Nintendo).nes",          49168, 0x0dc357ae, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vsexcitebike)
STD_ROM_FN(nes_vsexcitebike)

struct BurnDriver BurnDrvnes_vsexcitebike = {
	"vsexcitebike", NULL, NULL, NULL, "1985",
	"VS. Excitebike\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 1, HARDWARE_NVS, GBF_RACING, 0,
	NULL, nes_vsexcitebikeRomInfo, nes_vsexcitebikeRomName, NULL, NULL, NULL, NULL, NESVSInputInfo, NESVSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// VS. Freedom Force
static struct BurnRomInfo nes_vsfreedomforceRomDesc[] = {
	{ "VS. Freedom Force (1988)(Sunsoft).nes",          196624, 0xc9f3f439, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vsfreedomforce)
STD_ROM_FN(nes_vsfreedomforce)

struct BurnDriver BurnDrvnes_vsfreedomforce = {
	"vsfreedomforce", NULL, NULL, NULL, "1988",
	"VS. Freedom Force\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_NVS, GBF_SHOOT, 0,
	NULL, nes_vsfreedomforceRomInfo, nes_vsfreedomforceRomName, NULL, NULL, NULL, NULL, NESVSZapperInputInfo, NESVSZapperDIPInfo,
	NESZapperInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// VS. From Below (HB, v0.10)
static struct BurnRomInfo nes_vsfrombelowRomDesc[] = {
	{ "VS. From Below (HB, v0.10).nes",          40976, 0xd1616b88, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vsfrombelow)
STD_ROM_FN(nes_vsfrombelow)

struct BurnDriver BurnDrvnes_vsfrombelow = {
	"vsfrombelow", NULL, NULL, NULL, "2021",
	"VS. From Below (HB, v0.10)\0", NULL, "Goose2k", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NVS, GBF_PUZZLE, 0,
	NULL, nes_vsfrombelowRomInfo, nes_vsfrombelowRomName, NULL, NULL, NULL, NULL, NESVSInputInfo, NESVSFromBelowDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// VS. Goonies, The
static struct BurnRomInfo nes_vsgooniesRomDesc[] = {
	{ "VS. Goonies, The (1986)(Konami).nes",          131088, 0x5fefc97b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vsgoonies)
STD_ROM_FN(nes_vsgoonies)

struct BurnDriver BurnDrvnes_vsgoonies = {
	"vsgoonies", NULL, NULL, NULL, "1986",
	"VS. Goonies, The\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 1, HARDWARE_NVS, GBF_PLATFORM, 0,
	NULL, nes_vsgooniesRomInfo, nes_vsgooniesRomName, NULL, NULL, NULL, NULL, NESVSInputInfo, NESVSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// VS. Gradius
static struct BurnRomInfo nes_vsgradiusRomDesc[] = {
	{ "VS. Gradius (1986)(Konami).nes",          98320, 0x066ba9ab, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vsgradius)
STD_ROM_FN(nes_vsgradius)

struct BurnDriver BurnDrvnes_vsgradius = {
	"vsgradius", NULL, NULL, NULL, "1986",
	"VS. Gradius\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_NVS, GBF_HORSHOOT, 0,
	NULL, nes_vsgradiusRomInfo, nes_vsgradiusRomName, NULL, NULL, NULL, NULL, NESVSInputInfo, NESVSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_vsgumshoeRomDesc[] = {
	{ "VS. Gumshoe (1986)(Nintendo).nes",          65552, 0xee7be019, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vsgumshoe)
STD_ROM_FN(nes_vsgumshoe)

struct BurnDriver BurnDrvnes_vsgumshoe = {
	"vsgumshoe", NULL, NULL, NULL, "1986",
	"VS. Gumshoe\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 1, HARDWARE_NVS, GBF_SHOOT, 0,
	NULL, nes_vsgumshoeRomInfo, nes_vsgumshoeRomName, NULL, NULL, NULL, NULL, NESVSZapperInputInfo, NESVSZapperDIPInfo,
	NESZapperInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_vshogansalleyRomDesc[] = {
	{ "VS. Hogan's Alley (1985)(Nintendo).nes",          49168, 0x023bd2d5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vshogansalley)
STD_ROM_FN(nes_vshogansalley)

struct BurnDriver BurnDrvnes_vshogansalley = {
	"vshogansalley", NULL, NULL, NULL, "1985",
	"VS. Hogan's Alley\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_NVS, GBF_SHOOT, 0,
	NULL, nes_vshogansalleyRomInfo, nes_vshogansalleyRomName, NULL, NULL, NULL, NULL, NESVSZapperInputInfo, NESVSZapperDIPInfo,
	NESZapperInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_vsiceclimberRomDesc[] = {
	{ "VS. Ice Climber (1985)(Nintendo).nes",          49168, 0x6cb18497, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vsiceclimber)
STD_ROM_FN(nes_vsiceclimber)

struct BurnDriver BurnDrvnes_vsiceclimber = {
	"vsiceclimber", NULL, NULL, NULL, "1985",
	"VS. Ice Climber\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_NVS, GBF_ACTION, 0,
	NULL, nes_vsiceclimberRomInfo, nes_vsiceclimberRomName, NULL, NULL, NULL, NULL, NESVSInputInfo, NESVSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_vsmachriderRomDesc[] = {
	{ "VS. Mach Rider (1985)(Nintendo).nes",          49168, 0xdbdc31ba, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vsmachrider)
STD_ROM_FN(nes_vsmachrider)

struct BurnDriver BurnDrvnes_vsmachrider = {
	"vsmachrider", NULL, NULL, NULL, "1985",
	"VS. Mach Rider\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 1, HARDWARE_NVS, GBF_RACING, 0,
	NULL, nes_vsmachriderRomInfo, nes_vsmachriderRomName, NULL, NULL, NULL, NULL, NESVSInputInfo, NESVSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// VS. Mighty Bomb Jack
static struct BurnRomInfo nes_vsmightybombjackRomDesc[] = {
	{ "VS. Mighty Bomb Jack (1986)(Tecmo).nes",          40976, 0x483d5d6d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vsmightybombjack)
STD_ROM_FN(nes_vsmightybombjack)

struct BurnDriver BurnDrvnes_vsmightybombjack = {
	"vsmightybomjack", NULL, NULL, NULL, "1986",
	"VS. Mighty Bomb Jack\0", NULL, "Tecmo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_NVS, GBF_PLATFORM, 0,
	NULL, nes_vsmightybombjackRomInfo, nes_vsmightybombjackRomName, NULL, NULL, NULL, NULL, NESVSInputInfo, NESVSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// VS. Ninja Jajamaru-kun
static struct BurnRomInfo nes_vsninjajkunRomDesc[] = {
	{ "VS. Ninja Jajamaru-kun (1986)(Jaleco).nes",          49168, 0x1d489460, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vsninjajkun)
STD_ROM_FN(nes_vsninjajkun)

struct BurnDriver BurnDrvnes_vsninjajkun = {
	"vsninjajkun", NULL, NULL, NULL, "1986",
	"VS. Ninja Jajamaru-kun\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_NVS, GBF_ACTION, 0,
	NULL, nes_vsninjajkunRomInfo, nes_vsninjajkunRomName, NULL, NULL, NULL, NULL, NESVSInputInfo, NESVSDIPInfo,
	NESReversedInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// VS. Pinball
static struct BurnRomInfo nes_vspinballRomDesc[] = {
	{ "VS. Pinball (1984)(Nintendo).nes",          49168, 0xbe0baa9e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vspinball)
STD_ROM_FN(nes_vspinball)

struct BurnDriver BurnDrvnes_vspinball = {
	"vspinball", NULL, NULL, NULL, "1984",
	"VS. Pinball\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_NVS, GBF_PINBALL, 0,
	NULL, nes_vspinballRomInfo, nes_vspinballRomName, NULL, NULL, NULL, NULL, NESVSInputInfo, NESVSBit0HighDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// VS. Platoon
static struct BurnRomInfo nes_vsplatoonRomDesc[] = {
	{ "VS. Platoon (1988)(Sunsoft).nes",          262160, 0x4d9aa57f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vsplatoon)
STD_ROM_FN(nes_vsplatoon)

struct BurnDriver BurnDrvnes_vsplatoon = {
	"vsplatoon", NULL, NULL, NULL, "1988",
	"VS. Platoon\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 1, HARDWARE_NVS, GBF_SHOOT | GBF_SCRFIGHT, 0,
	NULL, nes_vsplatoonRomInfo, nes_vsplatoonRomName, NULL, NULL, NULL, NULL, NESVSInputInfo, NESVSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// VS. Raid on Bungling Bay
static struct BurnRomInfo nes_vsraidbbayRomDesc[] = {
	{ "VS. Raid on Bungling Bay (1985)(Broderbund).nes",          49168, 0x84ad422e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vsraidbbay)
STD_ROM_FN(nes_vsraidbbay)

struct BurnDriver BurnDrvnes_vsraidbbay = {
	"vsraidbbay", NULL, NULL, NULL, "1985",
	"VS. Raid on Bungling Bay\0", NULL, "Broderbund", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_NVS, GBF_SHOOT, 0,
	NULL, nes_vsraidbbayRomInfo, nes_vsraidbbayRomName, NULL, NULL, NULL, NULL, NESVSInputInfo, NESVSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// VS. Slalom
static struct BurnRomInfo nes_vsslalomRomDesc[] = {
	{ "VS. Slalom (1986)(Nintendo).nes",          40976, 0xf7953678, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vsslalom)
STD_ROM_FN(nes_vsslalom)

struct BurnDriver BurnDrvnes_vsslalom = {
	"vsslalom", NULL, NULL, NULL, "1986",
	"VS. Slalom\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_NVS, GBF_SPORTSMISC, 0,
	NULL, nes_vsslalomRomInfo, nes_vsslalomRomName, NULL, NULL, NULL, NULL, NESVSInputInfo, NESVSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// VS. Soccer
static struct BurnRomInfo nes_vssoccerRomDesc[] = {
	{ "VS. Soccer (1985)(Nintendo).nes",          49168, 0xb2fc5aaa, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vssoccer)
STD_ROM_FN(nes_vssoccer)

struct BurnDriver BurnDrvnes_vssoccer = {
	"vssoccer", NULL, NULL, NULL, "1985",
	"VS. Soccer\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_NVS, GBF_SPORTSFOOTBALL, 0,
	NULL, nes_vssoccerRomInfo, nes_vssoccerRomName, NULL, NULL, NULL, NULL, NESVSInputInfo, NESVSDIPInfo,
	NESReversedInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};


// VS. Star Luster
static struct BurnRomInfo nes_vsstarlusterRomDesc[] = {
	{ "VS. Star Luster (1985)(Namco).nes",          49168, 0x2e549bef, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vsstarluster)
STD_ROM_FN(nes_vsstarluster)

struct BurnDriver BurnDrvnes_vsstarluster = {
	"vsstarluster", NULL, NULL, NULL, "1985",
	"VS. Star Luster\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 1, HARDWARE_NVS, GBF_SIM | GBF_SHOOT, 0,
	NULL, nes_vsstarlusterRomInfo, nes_vsstarlusterRomName, NULL, NULL, NULL, NULL, NESVSInputInfo, NESVSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// VS. Stroke & Match Golf
static struct BurnRomInfo nes_vssmgolfRomDesc[] = {
	{ "VS. Stroke & Match Golf (1984)(Nintendo).nes",          49168, 0xaca28dce, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vssmgolf)
STD_ROM_FN(nes_vssmgolf)

struct BurnDriver BurnDrvnes_vssmgolf = {
	"vssmgolf", NULL, NULL, NULL, "1984",
	"VS. Stroke & Match Golf\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_NVS, GBF_SPORTSMISC, 0,
	NULL, nes_vssmgolfRomInfo, nes_vssmgolfRomName, NULL, NULL, NULL, NULL, NESVSInputInfo, NESVSBit0HighDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// VS. Stroke & Match Golf Ladies
static struct BurnRomInfo nes_vssmgolflaRomDesc[] = {
	{ "VS. Stroke & Match Golf Ladies (1984)(Nintendo).nes",          49168, 0x50c5c8a4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vssmgolfla)
STD_ROM_FN(nes_vssmgolfla)

struct BurnDriver BurnDrvnes_vssmgolfla = {
	"vssmgolfla", NULL, NULL, NULL, "1984",
	"VS. Stroke & Match Golf Ladies\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_NVS, GBF_SPORTSMISC, 0,
	NULL, nes_vssmgolflaRomInfo, nes_vssmgolflaRomName, NULL, NULL, NULL, NULL, NESVSInputInfo, NESVSBit0HighDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// VS. Super Mario Bros
static struct BurnRomInfo nes_vssmbRomDesc[] = {
	{ "VS. Super Mario Bros (1986)(Nintendo).nes",          49168, 0x7b8c1d89, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vssmb)
STD_ROM_FN(nes_vssmb)

struct BurnDriver BurnDrvnes_vssmb = {
	"vssmb", NULL, NULL, NULL, "1986",
	"VS. Super Mario Bros\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_NVS, GBF_PLATFORM, 0,
	NULL, nes_vssmbRomInfo, nes_vssmbRomName, NULL, NULL, NULL, NULL, NESVSInputInfo, NESVSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// VS. Super Sky Kid
static struct BurnRomInfo nes_vssuperskykidRomDesc[] = {
	{ "VS. Super Sky Kid (1986)(Namco).nes",          65552, 0xeb4452c9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vssuperskykid)
STD_ROM_FN(nes_vssuperskykid)

struct BurnDriver BurnDrvnes_vssuperskykid = {
	"vssuperskykid", NULL, NULL, NULL, "1986",
	"VS. Super Sky Kid\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_NVS, GBF_HORSHOOT, 0,
	NULL, nes_vssuperskykidRomInfo, nes_vssuperskykidRomName, NULL, NULL, NULL, NULL, NESVSInputInfo, NESVSDIPInfo,
	NESReversedInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// VS. Super Xevious - Gump no Nazo
static struct BurnRomInfo nes_vssuperxeviousRomDesc[] = {
	{ "VS. Super Xevious - Gump no Nazo (1986)(Namco).nes",          163856, 0x9f2251e4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vssuperxevious)
STD_ROM_FN(nes_vssuperxevious)

struct BurnDriver BurnDrvnes_vssuperxevious = {
	"vssuperxevious", NULL, NULL, NULL, "1986",
	"VS. Super Xevious - Gump no Nazo\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 1, HARDWARE_NVS, GBF_VERSHOOT, 0,
	NULL, nes_vssuperxeviousRomInfo, nes_vssuperxeviousRomName, NULL, NULL, NULL, NULL, NESVSInputInfo, NESVSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// VS. Tetris
static struct BurnRomInfo nes_vstetrisRomDesc[] = {
	{ "VS. Tetris (1988)(Atari Games).nes",          40976, 0x131afe42, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vstetris)
STD_ROM_FN(nes_vstetris)

struct BurnDriver BurnDrvnes_vstetris = {
	"vstetris", NULL, NULL, NULL, "1988",
	"VS. Tetris\0", NULL, "Atari Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_NVS, GBF_PUZZLE, 0,
	NULL, nes_vstetrisRomInfo, nes_vstetrisRomName, NULL, NULL, NULL, NULL, NESVSInputInfo, NESVSDIPInfo,
	NESReversedInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// VS. TKO Boxing
static struct BurnRomInfo nes_vstkoboxingRomDesc[] = {
	{ "VS. TKO Boxing (1987)(Data East).nes",          131088, 0xd81d33da, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vstkoboxing)
STD_ROM_FN(nes_vstkoboxing)

struct BurnDriver BurnDrvnes_vstkoboxing = {
	"vstkoboxing", NULL, NULL, NULL, "1987",
	"VS. TKO Boxing\0", NULL, "Data East", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 2, HARDWARE_NVS, GBF_VSFIGHT, 0,
	NULL, nes_vstkoboxingRomInfo, nes_vstkoboxingRomName, NULL, NULL, NULL, NULL, NESVSInputInfo, NESVSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// VS. Top Gun
static struct BurnRomInfo nes_vstopgunRomDesc[] = {
	{ "VS. Top Gun (1987)(Konami).nes",          131088, 0xa64c6e99, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vstopgun)
STD_ROM_FN(nes_vstopgun)

struct BurnDriver BurnDrvnes_vstopgun = {
	"vstopgun", NULL, NULL, NULL, "1987",
	"VS. Top Gun\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HISCORE_SUPPORTED, 1, HARDWARE_NVS, GBF_SIM | GBF_SHOOT, 0,
	NULL, nes_vstopgunRomInfo, nes_vstopgunRomName, NULL, NULL, NULL, NULL, NESVSInputInfo, NESVSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};


// -------------------------------
// Non Homebrew (Unlicensed) Games
// -------------------------------


static INT32 topriderInit()
{
	INT32 rc = NESInit();

	if (!rc) {
		// Top Rider size / crc: 163856, 0xca1a395a
		// Patch in standard controller -dink feb.25, 2021
		// Game Genie code: IUEOKOAL
		// lda $494
		// ora $311
		// and #$10
		//*bne 99c5 ; start pressed, next screen
		// jsr 9f68 ; check if code entered on controller #2
		// bcs 99c2 ; yes? start game with normal controller in port #1
		// ...
		//*d0 38  bne 99c5 -> d0 35  bne 99c2

		Cart.PRGRom[0x1998c] = 0x35;
	}

	return rc;
}

static struct BurnRomInfo nes_xiaomaliRomDesc[] = {
	{ "Xiao Ma Li (Unl).nes",          24592, 0xc8f9a5ab, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_xiaomali)
STD_ROM_FN(nes_xiaomali)

struct BurnDriver BurnDrvnes_xiaomali = {
	"nes_xiaomali", NULL, NULL, NULL, "1989-90",
	"Xiao Ma Li (Unl)\0", NULL, "Nei-Hu Electronics", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	0, 2, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_xiaomaliRomInfo, nes_xiaomaliRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_janggunuiadeulRomDesc[] = {
	{ "Janggun-ui Adeul (Korea) (Unl).nes",          655376, 0x54171ca4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_janggunuiadeul)
STD_ROM_FN(nes_janggunuiadeul)

struct BurnDriver BurnDrvnes_janggunuiadeul = {
	"nes_janggunuiadeul", NULL, NULL, NULL, "1992",
	"Janggun-ui Adeul (Korea) (Unl)\0", NULL, "Daou", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_janggunuiadeulRomInfo, nes_janggunuiadeulRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Mario All Stars NES (Hack)
static struct BurnRomInfo nes_supermarallstanesRomDesc[] = {
	{ "Super Mario All Stars NES (Hack).nes",          2097168, 0xbe155d3e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_supermarallstanes)
STD_ROM_FN(nes_supermarallstanes)

struct BurnDriver BurnDrvnes_supermarallstanes = {
	"nes_supermarioallst", NULL, NULL, NULL, "2020",
	"Super Mario All Stars NES (Hack)\0", NULL, "infidelity", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_supermarallstanesRomInfo, nes_supermarallstanesRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Mario Bros. Christmas Edition (Hack)
static struct BurnRomInfo nes_smbchrediRomDesc[] = {
	{ "Super Mario Bros. Christmas Edition (Hack).nes",          73744, 0xb293a7c4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_smbchredi)
STD_ROM_FN(nes_smbchredi)

struct BurnDriver BurnDrvnes_smbchredi = {
	"nes_smbchredi", "nes_smb", NULL, NULL, "2020",
	"Super Mario Bros. Christmas Edition (Hack)\0", NULL, "U Retro", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_smbchrediRomInfo, nes_smbchrediRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Mario Bros. Enhanced (Hack)
// https://mail.romhacking.net/hacks/6922/
static struct BurnRomInfo nes_smbenRomDesc[] = {
	{ "Super Mario Bros Enhanced (2022)(NesInvent).nes",          40976, 0xb1e5b547, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_smben)
STD_ROM_FN(nes_smben)

struct BurnDriver BurnDrvnes_smben = {
	"nes_smben", "nes_smb", NULL, NULL, "2022",
	"Super Mario Bros. Enhanced (Hack)\0", NULL, "NesInvent", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_smbenRomInfo, nes_smbenRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Mario Bros. Ende's SMB (Hack)
static struct BurnRomInfo nes_smbendssmbha1RomDesc[] = {
	{ "Super Mario Bros. Ende's SMB Hack 1 (Hack).nes",          40976, 0x1eeab4b1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_smbendssmbha1)
STD_ROM_FN(nes_smbendssmbha1)

struct BurnDriver BurnDrvnes_smbendssmbha1 = {
	"nes_smbendssmbha1", "nes_smb", NULL, NULL, "2004",
	"Super Mario Bros. Ende's SMB (Hack)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_smbendssmbha1RomInfo, nes_smbendssmbha1RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_bloodjurRomDesc[] = {
	{ "Blood of Jurassic (1997)(gd-98).nes",          262160, 0x76ea1e9f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bloodjur)
STD_ROM_FN(nes_bloodjur)

struct BurnDriver BurnDrvnes_bloodjur = {
	"nes_bloodjur", NULL, NULL, NULL, "1997",
	"Blood of Jurassic (Unl)\0", NULL, "Shanghai PS&T", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_bloodjurRomInfo, nes_bloodjurRomName, NULL, NULL, NULL, NULL, NESZapperInputInfo, NESZapperDIPInfo,
	NESZapperInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_somariRomDesc[] = {
	{ "Somari (Unl).nes",          524304, 0x51589daf, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_somari)
STD_ROM_FN(nes_somari)

struct BurnDriver BurnDrvnes_somari = {
	"nes_somari", NULL, NULL, NULL, "1994",
	"Somari (Unl)\0", NULL, "Hummer Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_somariRomInfo, nes_somariRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Sonic Improvement vol.2
// http://www.romhacking.net/hacks/5026/
static struct BurnRomInfo nes_sonicRomDesc[] = {
	{ "Sonic the Hedgehog (Hack).nes",          786448, 0xb9ebd682, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sonic)
STD_ROM_FN(nes_sonic)

struct BurnDriver BurnDrvnes_sonic = {
	"nes_sonic", "nes_somari", NULL, NULL, "2020",
	"Sonic the Hedgehog (Hack)\0", NULL, "Terwilf", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_sonicRomInfo, nes_sonicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bowsette 2 (Hack, Red version)
// https://www.romhacking.net/hacks/4326/

static struct BurnRomInfo nes_bowsette2RomDesc[] = {
	{ "Bowsette 2 (Hack).nes",          262160, 0x94390680, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bowsette2)
STD_ROM_FN(nes_bowsette2)

struct BurnDriver BurnDrvnes_bowsette2 = {
	"nes_bowsette2", "nes_smb2", NULL, NULL, "2019",
	"Bowsette 2 (Hack, Red version)\0", NULL, "Zynk Oxhyde", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_bowsette2RomInfo, nes_bowsette2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Mario Bros. 2 - Wacky Quest (Hack)
// https://www.romhacking.net/hacks/6920/

static struct BurnRomInfo nes_smb2wqRomDesc[] = {
	{ "Super Mario Bros. 2 - Wacky Quest (2022)(ray8).nes",          262160, 0x30af8965, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_smb2wq)
STD_ROM_FN(nes_smb2wq)

struct BurnDriver BurnDrvnes_smb2wq = {
	"nes_smb2wq", "nes_smb2", NULL, NULL, "2022",
	"Super Mario Bros. 2 - Wacky Quest (Hack)\0", NULL, "ray8", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_smb2wqRomInfo, nes_smb2wqRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Mario Unlimited Deluxe
// http://www.romhacking.net/hacks/5546/
static struct BurnRomInfo nes_smbunldlxRomDesc[] = {
	{ "Super Mario Unlimited Deluxe (Hack).nes",          196624, 0x716c9eb4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_smbunldlx)
STD_ROM_FN(nes_smbunldlx)

struct BurnDriver BurnDrvnes_smbunldlx = {
	"nes_smbunldlx", "nes_smb", NULL, NULL, "2020",
	"Super Mario Unlimited Deluxe (Hack)\0", NULL, "Frantik", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_smbunldlxRomInfo, nes_smbunldlxRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Little Samson
// Restoration Hack by SCD @ https://www.romhacking.net/hacks/5413/
// Pleasant Shot Sound hack by Nesrocks @ https://www.romhacking.net/hacks/5189/

static struct BurnRomInfo nes_littlesamsonhRomDesc[] = {
	{ "Little Samson (Hack).nes",          393232, 0x2178190e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_littlesamsonh)
STD_ROM_FN(nes_littlesamsonh)

struct BurnDriver BurnDrvnes_littlesamsonh = {
	"nes_littlesamsonh", "nes_littlesamson", NULL, NULL, "2020",
	"Little Samson (Restoration & Sound Hack)\0", NULL, "SCD - Nesrocks", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_littlesamsonhRomInfo, nes_littlesamsonhRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Aliens - Alien 2 (Fix Hack)
// Hack by lancuster
// https://www.romhacking.net/hacks/3790/
static struct BurnRomInfo fds_aliensfixRomDesc[] = {
	{ "Aliens - Alien 2 (Prototype)(Fix Hack).fds",          131016, 0x0d487b19, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_aliensfix, fds_aliensfix, fds_fdsbios)
STD_ROM_FN(fds_aliensfix)

struct BurnDriver BurnDrvfds_aliensfix = {
	"fds_aliensfix", NULL, "fds_fdsbios", NULL, "2017",
	"Aliens - Alien 2 (Fix Hack)\0", NULL, "lancuster", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_FDS, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, fds_aliensfixRomInfo, fds_aliensfixRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Aliens - Alien 2 (Japan) (Prototype)
static struct BurnRomInfo fds_aliensRomDesc[] = {
	{ "Aliens - Alien 2 (J) (Prototype).fds",          131000, 0x2b779ee3, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_aliens, fds_aliens, fds_fdsbios)
STD_ROM_FN(fds_aliens)

struct BurnDriver BurnDrvfds_aliens = {
	"fds_aliens", "fds_aliensfix", "fds_fdsbios", NULL, "1987",
	"Aliens - Alien 2 (Japan) (Prototype)\0", NULL, "Square", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_PROTOTYPE, 1, HARDWARE_FDS, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, fds_aliensRomInfo, fds_aliensRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bubble Bath Babes (USA) (Unl)
static struct BurnRomInfo nes_bbbabesRomDesc[] = {
	{ "Bubble Bath Babes (USA) (Unl).nes",          98320, 0xf36edcc5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bbbabes)
STD_ROM_FN(nes_bbbabes)

struct BurnDriver BurnDrvnes_bbbabes = {
	"nes_bbbabes", NULL, NULL, NULL, "1991",
	"Bubble Bath Babes (USA) (Unl)\0", NULL, "Panesian", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_bbbabesRomInfo, nes_bbbabesRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Jungle Book, The (Brightness fix)
// Hacked by Ilya Indigo
// https://www.romhacking.net/hacks/5323/

static struct BurnRomInfo nes_junglebookthebRomDesc[] = {
	{ "jungle book, the (2020)(brightness fix).nes",          262160, 0x1c9a2869, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_junglebooktheb)
STD_ROM_FN(nes_junglebooktheb)

struct BurnDriver BurnDrvnes_junglebooktheb = {
	"nes_junglebooktheb", "nes_junglebookthe", NULL, NULL, "2020",
	"Jungle Book, The (Brightness fix)\0", NULL, "Ilya Indigo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_junglebookthebRomInfo, nes_junglebookthebRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Royal Pals (Hack)
// Hacked by QUXNLADY
// https://www.romhacking.net/hacks/5320/

static struct BurnRomInfo nes_srpRomDesc[] = {
	{ "super royal pals (2020)(QUXNLADY).nes",          40976, 0x62797e6e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_srp)
STD_ROM_FN(nes_srp)

struct BurnDriver BurnDrvnes_srp = {
	"nes_srp", "nes_smb", NULL, NULL, "2020",
	"Super Royal Pals (Hack)\0", NULL, "QUXNLADY", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_srpRomInfo, nes_srpRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Metal Storm Re-Release (Mapper 268)
static struct BurnRomInfo nes_metalstormrrRomDesc[] = {
	{ "Metal Storm (2019).nes",          524304, 0x33af86d9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_metalstormrr)
STD_ROM_FN(nes_metalstormrr)

struct BurnDriver BurnDrvnes_metalstormrr = {
	"nes_metalstormrr", "nes_metalstorm", NULL, NULL, "2019",
	"Metal Storm (Re-Release)\0", NULL, "Irem - Retro-bit", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_metalstormrrRomInfo, nes_metalstormrrRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Happily Ever After (USA) (Prototype)
static struct BurnRomInfo nes_happilyeaRomDesc[] = {
	{ "Happily Ever After (USA) (Prototype).nes",          262160, 0x57f5c01d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_happilyea)
STD_ROM_FN(nes_happilyea)

struct BurnDriver BurnDrvnes_happilyea = {
	"nes_happilyea", NULL, NULL, NULL, "1991",
	"Happily Ever After (USA) (Prototype)\0", NULL, "SOFEL", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_PROTOTYPE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_happilyeaRomInfo, nes_happilyeaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_magickidsdorpRomDesc[] = {
	{ "Magical Kid's Doropie (Prototype).nes",          262160, 0x84209fee, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_magickidsdorp)
STD_ROM_FN(nes_magickidsdorp)

struct BurnDriver BurnDrvnes_magickidsdorp = {
	"nes_magickidsdorp", "nes_krioncon", NULL, NULL, "1990",
	"Magical Kid's Doropie (Prototype)\0", NULL, "Vic Tokai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_PROTOTYPE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_magickidsdorpRomInfo, nes_magickidsdorpRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// ----------------------------------
// Chinese bootlegs/translation hacks
// ----------------------------------

// 1942 (Hack, Chinese)
// https://www.nesbbs.com/bbs/thread-49846-1-1.html
static struct BurnRomInfo nes_1942cRomDesc[] = {
	{ "1942 (T-Chi).nes",          81936, 0x555741fc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_1942c)
STD_ROM_FN(nes_1942c)

struct BurnDriver BurnDrvnes_1942c = {
	"nes_1942c", "nes_1942", NULL, NULL, "2020",
	"1942 (Hack, Chinese)\0", NULL, "6502", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_1942cRomInfo, nes_1942cRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Akumajou Densetsu (Hack, Chinese v2.3)
// https://www.nesbbs.com/bbs/thread-46102-1-1.html
static struct BurnRomInfo nes_akumadencRomDesc[] = {
	{ "Akumajou Densetsu (T-Chi, v2.3).nes",          524304, 0xb810b79c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_akumadenc)
STD_ROM_FN(nes_akumadenc)

struct BurnDriver BurnDrvnes_akumadenc = {
	"nes_akumadenc", "nes_castliii", NULL, NULL, "2018",
	"Akumajou Densetsu (Hack, Chinese v2.3)\0", NULL, "HHNM Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_akumadencRomInfo, nes_akumadencRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Astyanax (Hack, Chinese v1.1)
// https://www.ppxclub.com/forum.php?mod=viewthread&tid=705238
static struct BurnRomInfo nes_astyanaxcRomDesc[] = {
	{ "Astyanax (T-Chi, v1.1).nes",          524304, 0x1517f03a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_astyanaxc)
STD_ROM_FN(nes_astyanaxc)

struct BurnDriver BurnDrvnes_astyanaxc = {
	"nes_astyanaxc", "nes_astyanax", NULL, NULL, "2021",
	"Astyanax (Hack, Chinese v1.1)\0", NULL, "Ni You De Wu Cai Yu", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_astyanaxcRomInfo, nes_astyanaxcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// AV Mahjong Club (Hack, Chinese) (Unl)
// https://www.nesbbs.com/bbs/thread-45883-1-1.html
static struct BurnRomInfo nes_avmahjongclubcRomDesc[] = {
	{ "AV Mahjong Club (T-Chi) (Unl).nes",          262160, 0x663870dd, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_avmahjongclubc)
STD_ROM_FN(nes_avmahjongclubc)

struct BurnDriver BurnDrvnes_avmahjongclubc = {
	"nes_avmahjongclubc", NULL, NULL, NULL, "2018",
	"AV Mahjong Club (Hack, Chinese) (Unl)\0", NULL, "HHNM Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_MAHJONG | GBF_ADV, 0,
	NESGetZipName, nes_avmahjongclubcRomInfo, nes_avmahjongclubcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Batman - The Video Game (Hack, Chinese)
// https://www.nesbbs.com/bbs/thread-48898-1-1.html
static struct BurnRomInfo nes_batmavidgamcRomDesc[] = {
	{ "Batman - The Video Game (T-Chi).nes",          393232, 0x4b2de665, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_batmavidgamc)
STD_ROM_FN(nes_batmavidgamc)

struct BurnDriver BurnDrvnes_batmavidgamc = {
	"nes_batmavidgamc", "nes_batmavidgam", NULL, NULL, "2020",
	"Batman - The Video Game (Hack, Chinese)\0", NULL, "HHNM Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_batmavidgamcRomInfo, nes_batmavidgamcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bio Hazard (China) (Unl)
static struct BurnRomInfo nes_biohazardcRomDesc[] = {
	{ "Bio Hazard (China).nes",          1048592, 0xb4c8012d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_biohazardc)
STD_ROM_FN(nes_biohazardc)

struct BurnDriver BurnDrvnes_biohazardc = {
	"nes_biohazardc", "nes_biohazard", NULL, NULL, "2003",
	"Bio Hazard (China) (Unl)\0", NULL, "Waixing", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_biohazardcRomInfo, nes_biohazardcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bio Hazard (Hack, English)
static struct BurnRomInfo nes_biohazardRomDesc[] = {
	{ "Bio Hazard (T-Eng).nes",          1048592, 0x4dffd969, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_biohazard)
STD_ROM_FN(nes_biohazard)

struct BurnDriver BurnDrvnes_biohazard = {
	"nes_biohazard", NULL, NULL, NULL, "2018",
	"Bio Hazard (Hack, English)\0", NULL, "pacnsacdave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_biohazardRomInfo, nes_biohazardRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bucky O'Hare (Hack, Chinese)
// https://www.nesbbs.com/bbs/thread-44657-1-1.html [Logo by ZARD]
static struct BurnRomInfo nes_buckyoharecRomDesc[] = {
	{ "Bucky O'Hare (T-Chi).nes",          426000, 0xfaa6e27c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_buckyoharec)
STD_ROM_FN(nes_buckyoharec)

struct BurnDriver BurnDrvnes_buckyoharec = {
	"nes_buckyoharec", "nes_buckyohare", NULL, NULL, "2018",
	"Bucky O'Hare (Hack, Chinese)\0", NULL, "Axi", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_buckyoharecRomInfo, nes_buckyoharecRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Captain America and the Avengers (Hack, Chinese)
// https://www.ppxclub.com/forum.php?mod=viewthread&tid=712633
static struct BurnRomInfo nes_captaameandavecRomDesc[] = {
	{ "Captain America and the Avengers (T-Chi).nes",          393232, 0xcfdf0dc5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_captaameandavec)
STD_ROM_FN(nes_captaameandavec)

struct BurnDriver BurnDrvnes_captaameandavec = {
	"nes_captaameandavec", "nes_captaameandave", NULL, NULL, "2022",
	"Captain America and the Avengers (Hack, Chinese)\0", NULL, "LSP Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_captaameandavecRomInfo, nes_captaameandavecRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Chiki Chiki Machine Mou Race (Hack, Chinese)
// https://www.nesbbs.com/bbs/thread-46582-1-1.html
static struct BurnRomInfo nes_chikichimacmouracRomDesc[] = {
	{ "Chiki Chiki Machine Mou Race (T-Chi).nes",          393232, 0x37e57151, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_chikichimacmourac)
STD_ROM_FN(nes_chikichimacmourac)

struct BurnDriver BurnDrvnes_chikichimacmourac = {
	"nes_chikichimacmourac", "nes_wackyraces", NULL, NULL, "2018",
	"Chiki Chiki Machine Mou Race (Hack, Chinese)\0", NULL, "Nonamed Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_chikichimacmouracRomInfo, nes_chikichimacmouracRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// China Rabbit Baby (China) (Unl)
static struct BurnRomInfo nes_chinarabbabRomDesc[] = {
	{ "China Rabbit Baby (Unl).nes",          524304, 0x6ab0db42, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_chinarabbab)
STD_ROM_FN(nes_chinarabbab)

struct BurnDriver BurnDrvnes_chinarabbab = {
	"nes_chinarabbab", NULL, NULL, NULL, "1996",
	"China Rabbit Baby (China) (Unl)\0", NULL, "J.Y. Company", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_chinarabbabRomInfo, nes_chinarabbabRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Chip 'n Dale - Rescue Rangers (Hack, Chinese v1.1)
// https://www.nesbbs.com/bbs/thread-34058-1-1.html
static struct BurnRomInfo nes_chipndalresrascRomDesc[] = {
	{ "Chip 'n Dale - Rescue Rangers (T-Chi, v1.1).nes",          393232, 0x1c63b350, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_chipndalresrasc)
STD_ROM_FN(nes_chipndalresrasc)

struct BurnDriver BurnDrvnes_chipndalresrasc = {
	"nes_chipndalresrasc", "nes_chipndalresra", NULL, NULL, "2015",
	"Chip 'n Dale - Rescue Rangers (Hack, Chinese v1.1)\0", NULL, "HHNM Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_chipndalresrascRomInfo, nes_chipndalresrascRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Chip 'n Dale - Rescue Rangers 2 (Hack, Chinese v1.13)
// https://www.nesbbs.com/bbs/thread-33949-1-1.html
static struct BurnRomInfo nes_chipndalresra2scRomDesc[] = {
	{ "Chip 'n Dale - Rescue Rangers 2 (T-Chi, v1.13).nes",          393232, 0x4acc32ba, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_chipndalresra2sc)
STD_ROM_FN(nes_chipndalresra2sc)

struct BurnDriver BurnDrvnes_chipndalresra2sc = {
	"nes_chipndalresra2sc", "nes_chipndalresra2", NULL, NULL, "2015",
	"Chip 'n Dale - Rescue Rangers 2 (Hack, Chinese v1.13)\0", NULL, "HHNM Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_chipndalresra2scRomInfo, nes_chipndalresra2scRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Contra Force (2nd option) (Hack, Chinese)
// Translation by Tan Xiao Feng Sheng
static struct BurnRomInfo nes_contraforcecRomDesc[] = {
	{ "Contra Force (T-Chi).nes",          524304, 0xcf2a15fb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_contraforcec)
STD_ROM_FN(nes_contraforcec)

struct BurnDriver BurnDrvnes_contraforcec = {
	"nes_contraforcec", "nes_contraforce", NULL, NULL, "2018",
	"Contra Force (2nd option) (Hack, Chinese)\0", NULL, "Tan Xiao Feng Sheng", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_contraforcecRomInfo, nes_contraforcecRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Don Doko Don 2 (Hack, Chinese)
// https://www.nesbbs.com/bbs/thread-50857-1-1.html
static struct BurnRomInfo nes_dondokodon2cRomDesc[] = {
	{ "Don Doko Don 2 (T-Chi).nes",          393232, 0x64bab6de, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dondokodon2c)
STD_ROM_FN(nes_dondokodon2c)

struct BurnDriver BurnDrvnes_dondokodon2c = {
	"nes_dondokodon2c", "nes_dondokodon2", NULL, NULL, "2020",
	"Don Doko Don 2 (Hack, Chinese)\0", NULL, "Advance Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_dondokodon2cRomInfo, nes_dondokodon2cRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Double Dragon III - The Sacred Stones (Hack, Chinese)
// https://www.ppxclub.com/forum.php?mod=viewthread&tid=711718
static struct BurnRomInfo nes_doubldraiiiscRomDesc[] = {
	{ "Double Dragon III - The Sacred Stones (T-Chi).nes",          262160, 0x4b992f63, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_doubldraiiisc)
STD_ROM_FN(nes_doubldraiiisc)

struct BurnDriver BurnDrvnes_doubldraiiisc = {
	"nes_doubldraiiisc", "nes_doubldraiii", NULL, NULL, "2022",
	"Double Dragon III - The Sacred Stones (Hack, Chinese)\0", NULL, "asiwish", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_doubldraiiiscRomInfo, nes_doubldraiiiscRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Downtown - Nekketsu Koushinkyoku - Soreyuke Daiundoukai (Hack, Chinese)
// https://www.ppxclub.com/forum.php?mod=viewthread&tid=710703
static struct BurnRomInfo nes_downtnekkousordacRomDesc[] = {
	{ "Downtown - Nekketsu Koushinkyoku - Soreyuke Daiundoukai (T-Chi).nes",          483344, 0xd1728e58, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_downtnekkousordac)
STD_ROM_FN(nes_downtnekkousordac)

struct BurnDriver BurnDrvnes_downtnekkousordac = {
	"nes_downtnekkousordac", "nes_downtnekkousorda", NULL, NULL, "2022",
	"Downtown - Nekketsu Koushinkyoku - Soreyuke Daiundoukai (Hack, Chinese)\0", NULL, "NOKOH", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_downtnekkousordacRomInfo, nes_downtnekkousordacRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NESHori4pInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Downtown - Nekketsu Monogatari (Hack, Chinese)
// https://www.ppxclub.com/forum.php?mod=viewthread&tid=711718
static struct BurnRomInfo nes_downtnekmoncRomDesc[] = {
	{ "Downtown - Nekketsu Monogatari (T-Chi).nes",          262160, 0x60a9ee52, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_downtnekmonc)
STD_ROM_FN(nes_downtnekmonc)

struct BurnDriver BurnDrvnes_downtnekmonc = {
	"nes_downtnekmonc", "nes_downtnekmon", NULL, NULL, "2022",
	"Downtown - Nekketsu Monogatari (Hack, Chinese)\0", NULL, "asiwish", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_downtnekmoncRomInfo, nes_downtnekmoncRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Knife (China) (Unl)
static struct BurnRomInfo nes_dragonknifecRomDesc[] = {
	{ "Dragon Knife (Chinese).nes",          524304, 0xeb5dbb86, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragonknifec)
STD_ROM_FN(nes_dragonknifec)

struct BurnDriver BurnDrvnes_dragonknifec = {
	"nes_dragonknifec", "nes_dragonknife", NULL, NULL, "1993",
	"Dragon Knife (China) (Unl)\0", NULL, "Waixing", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_dragonknifecRomInfo, nes_dragonknifecRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Knife (Hack, English)
// https://www.romhacking.net/translations/2196/
static struct BurnRomInfo nes_dragonknifeRomDesc[] = {
	{ "Dragon Knife (T-Eng).nes",          524304, 0x142f21a6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragonknife)
STD_ROM_FN(nes_dragonknife)

struct BurnDriver BurnDrvnes_dragonknife = {
	"nes_dragonknife", NULL, NULL, NULL, "2014",
	"Dragon Knife (Hack, English)\0", NULL, "pacnsacdave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_dragonknifeRomInfo, nes_dragonknifeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Fester's Quest (Hack, Chinese)
// https://www.nesbbs.com/bbs/thread-51920-1-1.html
static struct BurnRomInfo nes_festersquestcRomDesc[] = {
	{ "Fester's Quest (T-Chi).nes",          393232, 0x56a5335e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_festersquestc)
STD_ROM_FN(nes_festersquestc)

struct BurnDriver BurnDrvnes_festersquestc = {
	"nes_festersquestc", "nes_festersquest", NULL, NULL, "2021",
	"Fester's Quest (Hack, Chinese)\0", NULL, "DMG Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_ADV, 0,
	NESGetZipName, nes_festersquestcRomInfo, nes_festersquestcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Final Mission (Hack, Chinese)
// https://www.ppxclub.com/forum.php?mod=viewthread&tid=708048
static struct BurnRomInfo nes_finalmissionjcRomDesc[] = {
	{ "Final Mission (T-Chi).nes",          393232, 0x9e25f63f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_finalmissionjc)
STD_ROM_FN(nes_finalmissionjc)

struct BurnDriver BurnDrvnes_finalmissionjc = {
	"nes_finalmissionjc", "nes_scat", NULL, NULL, "2021",
	"Final Mission (Hack, Chinese)\0", NULL, "Ni You De Wu Cai Yu", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_finalmissionjcRomInfo, nes_finalmissionjcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Fire Emblem - Ankoku Ryuu to Hikari no Tsurugi (Hack, Chinese)
// Modified by ÌìÏÂµÚÆß, ½ªÎ¬µÚ¶þ, ZARD/ÅÓÏÈÉú, º®Ñ©Ê¹Õß
// https://www.nesbbs.com/bbs/thread-53027-1-1.html
static struct BurnRomInfo nes_fireembcRomDesc[] = {
	{ "Fire Emblem - Ankoku Ryuu to Hikari no Tsurugi (T-Chi).nes",          655376, 0xa3126533, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_fireembc)
STD_ROM_FN(nes_fireembc)

struct BurnDriver BurnDrvnes_fireembc = {
	"nes_fireembc", "nes_fireemb", NULL, NULL, "2022",
	"Fire Emblem - Ankoku Ryuu to Hikari no Tsurugi (Hack, Chinese)\0", NULL, "Han Xue Shi Zhe", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_STRATEGY | GBF_RPG, 0,
	NESGetZipName, nes_fireembcRomInfo, nes_fireembcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Fire Emblem Gaiden (Hack, Chinese v2.0)
// Modified by ÌìÏÂµÚÆß, ½ªÎ¬µÚ¶þ, º®Ñ©Ê¹Õß
// https://www.nesbbs.com/bbs/thread-51529-1-1.html
static struct BurnRomInfo nes_fireembgaicRomDesc[] = {
	{ "Fire Emblem Gaiden (T-Chi, v2.0).nes",          663568, 0x1df6fb24, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_fireembgaic)
STD_ROM_FN(nes_fireembgaic)

struct BurnDriver BurnDrvnes_fireembgaic = {
	"nes_fireembgaic", "nes_fireembgai", NULL, NULL, "2021",
	"Fire Emblem Gaiden (Hack, Chinese v2.0)\0", NULL, "Han Xue Shi Zhe", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_STRATEGY | GBF_RPG, 0,
	NESGetZipName, nes_fireembgaicRomInfo, nes_fireembgaicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Flintstones, The - The Rescue of Dino & Hoppy (Hack, Chinese)
// https://www.nesbbs.com/bbs/thread-53671-1-1.html
static struct BurnRomInfo nes_flintresdinhopcRomDesc[] = {
	{ "Flintstones, The - The Rescue of Dino & Hoppy (T-Chi).nes",          655376, 0x773ffd89, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_flintresdinhopc)
STD_ROM_FN(nes_flintresdinhopc)

struct BurnDriver BurnDrvnes_flintresdinhopc = {
	"nes_flintresdinhopc", "nes_flintresdinhop", NULL, NULL, "2022",
	"Flintstones, The - The Rescue of Dino & Hoppy (Hack, Chinese)\0", NULL, "HHNM Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_flintresdinhopcRomInfo, nes_flintresdinhopcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Genuine Monkey (China) (Unl)
static struct BurnRomInfo nes_genuinemonkeycRomDesc[] = {
	{ "Genuine Monkey (China).nes",          524304, 0xc2ad9c76, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_genuinemonkeyc)
STD_ROM_FN(nes_genuinemonkeyc)

struct BurnDriver BurnDrvnes_genuinemonkeyc = {
	"nes_genuinemonkeyc", "nes_genuinemonkey", NULL, NULL, "1999",
	"Genuine Monkey (China) (Unl)\0", NULL, "Waixing", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_genuinemonkeycRomInfo, nes_genuinemonkeycRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Genuine Monkey (Hack, English)
static struct BurnRomInfo nes_genuinemonkeyRomDesc[] = {
	{ "Genuine Monkey (T-Eng).nes",          524304, 0x66f20682, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_genuinemonkey)
STD_ROM_FN(nes_genuinemonkey)

struct BurnDriver BurnDrvnes_genuinemonkey = {
	"nes_genuinemonkey", NULL, NULL, NULL, "2017",
	"Genuine Monkey (Hack, English)\0", NULL, "pacnsacdave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_genuinemonkeyRomInfo, nes_genuinemonkeyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gimmick! (Hack, Chinese)
// https://www.nesbbs.com/bbs/thread-52222-1-2.html
static struct BurnRomInfo nes_gimmickcRomDesc[] = {
	{ "Gimmick! (T-Chi).nes",          524304, 0xa442efa6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gimmickc)
STD_ROM_FN(nes_gimmickc)

struct BurnDriver BurnDrvnes_gimmickc = {
	"nes_gimmickc", "nes_gimmick", NULL, NULL, "2021",
	"Gimmick! (Hack, Chinese)\0", NULL, "Lei Jing Ling", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_gimmickcRomInfo, nes_gimmickcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Golgo 13 - Daiisshou - Kamigami no Tasogare (T-Chi)
// https://www.nesbbs.com/bbs/thread-51921-1-1.html
static struct BurnRomInfo nes_golgo13scRomDesc[] = {
	{ "Golgo 13 - Daiisshou - Kamigami no Tasogare (T-Chi).nes",          524304, 0x9671760e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_golgo13sc)
STD_ROM_FN(nes_golgo13sc)

struct BurnDriver BurnDrvnes_golgo13sc = {
	"nes_golgo13sc", "nes_golgo13", NULL, NULL, "2021",
	"Golgo 13 - Daiisshou - Kamigami no Tasogare (T-Chi)\0", NULL, "DMG Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_golgo13scRomInfo, nes_golgo13scRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gomoku Narabe Renju (Hack, Chinese)
// https://tieba.baidu.com/p/7443334447
static struct BurnRomInfo nes_gomokucRomDesc[] = {
	{ "Gomoku Narabe Renju (T-Chi).nes",          24592, 0xbccf3f36, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gomokuc)
STD_ROM_FN(nes_gomokuc)

struct BurnDriver BurnDrvnes_gomokuc = {
	"nes_gomokuc", "nes_gomoku", NULL, NULL, "2020",
	"Gomoku Narabe Renju (Hack, Chinese)\0", NULL, "Yan Yu Mao Mao", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_BOARD, 0,
	NESGetZipName, nes_gomokucRomInfo, nes_gomokucRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gyruss (Hack, Chinese)
// https://www.ppxclub.com/forum.php?mod=viewthread&tid=710703
static struct BurnRomInfo nes_gyrusscRomDesc[] = {
	{ "Gyruss (T-Chi).nes",          188432, 0xb82b4f29, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gyrussc)
STD_ROM_FN(nes_gyrussc)

struct BurnDriver BurnDrvnes_gyrussc = {
	"nes_gyrussc", "nes_gyruss", NULL, NULL, "2022",
	"Gyruss (Hack, Chinese)\0", NULL, "NOKOH", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_gyrusscRomInfo, nes_gyrusscRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Jackal (Hack, Chinese v1.1)
// https://www.nesbbs.com/bbs/thread-49033-1-1.html
static struct BurnRomInfo nes_jackalcRomDesc[] = {
	{ "Jackal (T-Chi, v1.1).nes",          262160, 0x0eca3358, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jackalc)
STD_ROM_FN(nes_jackalc)

struct BurnDriver BurnDrvnes_jackalc = {
	"nes_jackalc", "nes_jackal", NULL, NULL, "2020",
	"Jackal (Hack, Chinese v1.1)\0", NULL, "Lei Jing Ling", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 4, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_jackalcRomInfo, nes_jackalcRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NESHori4pInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Jackal - Endless Mission (v1.2) 20210313
// Modified by HHNM Team - ZENG GE / Ôø¸ç
// https://www.nesbbs.com/bbs/thread-51662-1-1.html
static struct BurnRomInfo nes_jackalemRomDesc[] = {
	{ "Jackal - Endless Mission (v1.2).nes",          262160, 0x833c6bc4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jackalem)
STD_ROM_FN(nes_jackalem)

struct BurnDriver BurnDrvnes_jackalem = {
	"nes_jackalem", "nes_jackal", NULL, NULL, "2021",
	"Jackal - Endless Mission (v1.2)\0", NULL, "HHNM Team - ZENG GE", "Miscellaneous",
	L"Jackal - Endless Mission (v1.2)\0\u8d64\u8272\u8981\u585e - \u65e0\u5c3d\u7684\u4efb\u52a1 (v1.2)", NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_jackalemRomInfo, nes_jackalemRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kage no Densetsu (Hack, Chinese)
// https://www.ppxclub.com/forum.php?mod=viewthread&tid=710703
static struct BurnRomInfo nes_kagenodensetsucRomDesc[] = {
	{ "Kage no Densetsu (T-Chi).nes",          106512, 0x170884af, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kagenodensetsuc)
STD_ROM_FN(nes_kagenodensetsuc)

struct BurnDriver BurnDrvnes_kagenodensetsuc = {
	"nes_kagenodensetsuc", "nes_legenkag", NULL, NULL, "2022",
	"Kage no Densetsu (Hack, Chinese)\0", NULL, "NOKOH", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_kagenodensetsucRomInfo, nes_kagenodensetsucRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kick Master (Hack, Chinese)
// https://www.ppxclub.com/forum.php?mod=viewthread&tid=711509
static struct BurnRomInfo nes_kickmastercRomDesc[] = {
	{ "Kick Master (T-Chi).nes",          393232, 0x85f44191, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kickmasterc)
STD_ROM_FN(nes_kickmasterc)

struct BurnDriver BurnDrvnes_kickmasterc = {
	"nes_kickmasterc", "nes_kickmaster", NULL, NULL, "2022",
	"Kick Master (Hack, Chinese)\0", NULL, "Ninsonytendog & Managus", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_kickmastercRomInfo, nes_kickmastercRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kirby's Adventure (Hack, Chinese)
// https://www.nesbbs.com/bbs/thread-50985-1-1.html
static struct BurnRomInfo nes_kirbysadvcRomDesc[] = {
	{ "Kirby's Adventure (T-Chi).nes",          1048592, 0x0efa7d0f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kirbysadvc)
STD_ROM_FN(nes_kirbysadvc)

struct BurnDriver BurnDrvnes_kirbysadvc = {
	"nes_kirbysadvc", "nes_kirbysadv", NULL, NULL, "2020",
	"Kirby's Adventure (Hack, Chinese)\0", NULL, "DMG Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_kirbysadvcRomInfo, nes_kirbysadvcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kung Fu (Hack, Chinese)
static struct BurnRomInfo nes_kungfucRomDesc[] = {
	{ "Kung Fu (T-Chi).nes",          24592, 0x480a29b7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kungfuc)
STD_ROM_FN(nes_kungfuc)

struct BurnDriver BurnDrvnes_kungfuc = {
	"nes_kungfuc", "nes_kungfu", NULL, NULL, "2010",
	"Kung Fu (Hack, Chinese)\0", NULL, "Jiu Ban", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_kungfucRomInfo, nes_kungfucRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kyouryuu Sentai Juuranger (Hack, Chinese)
// https://www.ppxclub.com/forum.php?mod=viewthread&tid=718391
static struct BurnRomInfo nes_kyoursenjuucRomDesc[] = {
	{ "Kyouryuu Sentai Juuranger (T-Chi).nes",          393232, 0x2cebf5e7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kyoursenjuuc)
STD_ROM_FN(nes_kyoursenjuuc)

struct BurnDriver BurnDrvnes_kyoursenjuuc = {
	"nes_kyoursenjuuc", "nes_kyoursenjuu", NULL, NULL, "2023",
	"Kyouryuu Sentai Juuranger (Hack, Chinese)\0", NULL, "LSP Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_RUNGUN | GBF_MINIGAMES, 0,
	NESGetZipName, nes_kyoursenjuucRomInfo, nes_kyoursenjuucRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Little Magic (Hack, Chinese, MS Team 2nd Rev)
// MS Team 2nd Rev - 20071214
// http://fcpic.nesbbs.com/0zt/ms/Rom.asp?page=3
static struct BurnRomInfo nes_littlemagiccRomDesc[] = {
	{ "Little Magic (T-Chi, MS Team 2nd Rev).nes",          524304, 0xb0c1cd73, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_littlemagicc)
STD_ROM_FN(nes_littlemagicc)

struct BurnDriver BurnDrvnes_littlemagicc = {
	"nes_littlemagicc", "nes_littlemagic", NULL, NULL, "2007",
	"Little Magic (Hack, Chinese, MS Team 2nd Rev)\0", NULL, "Waixing", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_littlemagiccRomInfo, nes_littlemagiccRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Little Nemo - The Dream Master (Hack, Chinese)
// https://www.nesbbs.com/bbs/thread-43984-1-1.html [Logo by ZARD]
static struct BurnRomInfo nes_littlnemcRomDesc[] = {
	{ "Little Nemo - The Dream Master (T-Chi).nes",          327696, 0x841cbcd1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_littlnemc)
STD_ROM_FN(nes_littlnemc)

struct BurnDriver BurnDrvnes_littlnemc = {
	"nes_littlnemc", "nes_littlnem", NULL, NULL, "2017",
	"Little Nemo - The Dream Master (Hack, Chinese)\0", NULL, "Ice Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_littlnemcRomInfo, nes_littlnemcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lupin Sansei - Pandora no Isan (Hack, Chinese)
// https://www.ppxclub.com/forum.php?mod=viewthread&tid=705303&fromuid=17888
static struct BurnRomInfo nes_lupinsanscRomDesc[] = {
	{ "Lupin Sansei - Pandora no Isan (T-Chi).nes",          524304, 0x1fd2e927, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lupinsansc)
STD_ROM_FN(nes_lupinsansc)

struct BurnDriver BurnDrvnes_lupinsansc = {
	"nes_lupinsansc", "nes_lupinsan", NULL, NULL, "2021",
	"Lupin Sansei - Pandora no Isan (Hack, Chinese)\0", NULL, "Ni You De Wu Cai Yu", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_lupinsanscRomInfo, nes_lupinsanscRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Makaimura (Hack, Chinese)
// https://www.ppxclub.com/forum.php?mod=viewthread&tid=702939
static struct BurnRomInfo nes_makaimuracRomDesc[] = {
	{ "Makaimura (T-Chi).nes",          131088, 0x415d7c05, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_makaimurac)
STD_ROM_FN(nes_makaimurac)

struct BurnDriver BurnDrvnes_makaimurac = {
	"nes_makaimurac", "nes_ghostsngoblins", NULL, NULL, "2020",
	"Makaimura (Hack, Chinese)\0", NULL, "Advance Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_makaimuracRomInfo, nes_makaimuracRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mappy (Hack, Chinese v2.0)
// https://www.nesbbs.com/bbs/thread-43662-1-1.html
static struct BurnRomInfo nes_mappycRomDesc[] = {
	{ "Mappy (T-Chi, v2.0).nes",          40976, 0x7c922692, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mappyc)
STD_ROM_FN(nes_mappyc)

struct BurnDriver BurnDrvnes_mappyc = {
	"nes_mappyc", "nes_mappy", NULL, NULL, "2017",
	"Mappy (Hack, Chinese v2.0)\0", NULL, "Jiu Ban", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_ACTION | GBF_PLATFORM, 0,
	NESGetZipName, nes_mappycRomInfo, nes_mappycRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Matendouji (Hack, Chinese)
// https://www.ppxclub.com/forum.php?mod=viewthread&tid=713661
static struct BurnRomInfo nes_matendoujicRomDesc[] = {
	{ "Matendouji (T-Chi).nes",          524304, 0x919e863f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_matendoujic)
STD_ROM_FN(nes_matendoujic)

struct BurnDriver BurnDrvnes_matendoujic = {
	"nes_matendoujic", "nes_matendouji", NULL, NULL, "2022",
	"Matendouji (Hack, Chinese)\0", NULL, "Ni You De Wu Cai Yu", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_matendoujicRomInfo, nes_matendoujicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Metal Gear (Hack, Chinese)
// https://www.nesbbs.com/bbs/thread-31084-1-1.html
// https://www.nesbbs.com/bbs/thread-52305-1-1.html [mirroring fix]
static struct BurnRomInfo nes_metalgearscRomDesc[] = {
	{ "Metal Gear (T-Chi).nes",          262160, 0x3e2e5276, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_metalgearsc)
STD_ROM_FN(nes_metalgearsc)

struct BurnDriver BurnDrvnes_metalgearsc = {
	"nes_metalgearsc", "nes_metalgear", NULL, NULL, "2015",
	"Metal Gear (Hack, Chinese)\0", NULL, "Axi", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_ADV, 0,
	NESGetZipName, nes_metalgearscRomInfo, nes_metalgearscRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mission Impossible (Hack, Chinese)
// https://www.ppxclub.com/forum.php?mod=viewthread&tid=711906
static struct BurnRomInfo nes_missiimpcRomDesc[] = {
	{ "Mission Impossible (T-Chi).nes",          524304, 0xf930b169, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_missiimpc)
STD_ROM_FN(nes_missiimpc)

struct BurnDriver BurnDrvnes_missiimpc = {
	"nes_missiimpc", "nes_missiimp", NULL, NULL, "2022",
	"Mission Impossible (Hack, Chinese)\0", NULL, "LSP Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_ADV, 0,
	NESGetZipName, nes_missiimpcRomInfo, nes_missiimpcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ninja Crusaders - Ryuuga (Hack, Chinese)
// https://www.nesbbs.com/bbs/thread-48213-1-1.html
static struct BurnRomInfo nes_ninjacrusaderscRomDesc[] = {
	{ "Ninja Crusaders - Ryuuga (T-Chi).nes",          262160, 0x05fac5d5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ninjacrusadersc)
STD_ROM_FN(nes_ninjacrusadersc)

struct BurnDriver BurnDrvnes_ninjacrusadersc = {
	"nes_ninjacrusadersc", "nes_ninjacrusaders", NULL, NULL, "2019",
	"Ninja Crusaders - Ryuuga (Hack, Chinese) \0", NULL, "HHNM Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_ninjacrusaderscRomInfo, nes_ninjacrusaderscRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Power Blade (Hack, Chinese)
// https://www.ppxclub.com/forum.php?mod=viewthread&tid=717589
static struct BurnRomInfo nes_powerbladecRomDesc[] = {
	{ "Power Blade (T-Chi, v1.0).nes",          393232, 0xa368fcee, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_powerbladec)
STD_ROM_FN(nes_powerbladec)

struct BurnDriver BurnDrvnes_powerbladec = {
	"nes_powerbladec", "nes_powerblade", NULL, NULL, "2022",
	"Power Blade (Hack, Chinese)\0", NULL, "Ni You De Wu Cai Yu", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_powerbladecRomInfo, nes_powerbladecRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Power Blade 2 (Hack, Chinese)
// https://www.ppxclub.com/forum.php?mod=viewthread&tid=718809
static struct BurnRomInfo nes_powerblade2cRomDesc[] = {
	{ "Power Blade 2 (T-Chi).nes",          524304, 0x4cd7666a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_powerblade2c)
STD_ROM_FN(nes_powerblade2c)

struct BurnDriver BurnDrvnes_powerblade2c = {
	"nes_powerblade2c", "nes_powerblade2", NULL, NULL, "2023",
	"Power Blade 2 (Hack, Chinese)\0", NULL, "Ni You De Wu Cai Yu", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_powerblade2cRomInfo, nes_powerblade2cRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Qi Wang - Chinese Chess (China, MGC-001)
static struct BurnRomInfo nes_qiwanRomDesc[] = {
	{ "Qi Wang - Chinese Chess (China, MGC-001).nes",          98320, 0x5eef4729, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_qiwan)
STD_ROM_FN(nes_qiwan)

struct BurnDriver BurnDrvnes_qiwan = {
	"nes_qiwan", NULL, NULL, NULL, "199?",
	"Qi Wang - Chinese Chess (China, MGC-001)\0", NULL, "TXC Corp.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_STRATEGY | GBF_BOARD, 0,
	NESGetZipName, nes_qiwanRomInfo, nes_qiwanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rad Racer (Hack, Chinese)
static struct BurnRomInfo nes_radracercRomDesc[] = {
	{ "Rad Racer (T-Chi).nes",          131088, 0x13cfd9ca, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_radracerc)
STD_ROM_FN(nes_radracerc)

struct BurnDriver BurnDrvnes_radracerc = {
	"nes_radracerc", "nes_radracer", NULL, NULL, "2010",
	"Rad Racer (Hack, Chinese)\0", NULL, "Jiu Ban", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_radracercRomInfo, nes_radracercRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rad Racer II (Hack, Chinese)
static struct BurnRomInfo nes_radraceriicRomDesc[] = {
	{ "Rad Racer II (T-Chi).nes",          131088, 0x1d7e1802, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_radraceriic)
STD_ROM_FN(nes_radraceriic)

struct BurnDriver BurnDrvnes_radraceriic = {
	"nes_radraceriic", "nes_radracerii", NULL, NULL, "2010",
	"Rad Racer II (Hack, Chinese)\0", NULL, "Jiu Ban", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_radraceriicRomInfo, nes_radraceriicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Road Fighter (Hack, Chinese v1.2)
static struct BurnRomInfo nes_roadfightercRomDesc[] = {
	{ "Road Fighter (T-Chi, v1.2).nes",          24592, 0xb5d69e4c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_roadfighterc)
STD_ROM_FN(nes_roadfighterc)

struct BurnDriver BurnDrvnes_roadfighterc = {
	"nes_roadfighterc", "nes_roadfighter", NULL, NULL, "2009",
	"Road Fighter (Hack, Chinese v1.2)\0", NULL, "Jiu Ban", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_roadfightercRomInfo, nes_roadfightercRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// RoboCop (Hack, Chinese)
// https://www.ppxclub.com/forum.php?mod=viewthread&tid=718366
static struct BurnRomInfo nes_robocopscRomDesc[] = {
	{ "RoboCop (T-Chi).nes",          393232, 0xa568590b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_robocopsc)
STD_ROM_FN(nes_robocopsc)

struct BurnDriver BurnDrvnes_robocopsc = {
	"nes_robocopsc", "nes_robocop", NULL, NULL, "2023",
	"RoboCop (Hack, Chinese)\0", NULL, "LSP Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_robocopscRomInfo, nes_robocopscRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rockman 3 - Dr. Wily no Saigo! (Hack, Chinese)
// Modified by NOKOH
// https://www.ppxclub.com/forum.php?mod=viewthread&tid=719402
static struct BurnRomInfo nes_rockm3cRomDesc[] = {
	{ "Rockman 3 - Dr. Wily no Saigo! (T-Chi).nes",          786448, 0x8125b0a4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rockm3c)
STD_ROM_FN(nes_rockm3c)

struct BurnDriver BurnDrvnes_rockm3c = {
	"nes_rockm3c", "nes_megaman3", NULL, NULL, "2023",
	"Rockman 3 - Dr. Wily no Saigo! (Hack, Chinese)\0", NULL, "NOKOH", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_rockm3cRomInfo, nes_rockm3cRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Saint Saiya - Tian Ma Huan Xiang (China)
static struct BurnRomInfo nes_saintsaitiamahuxiRomDesc[] = {
	{ "Saint Saiya - Tian Ma Huan Xiang (China).nes",          2097168, 0x31f810f2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_saintsaitiamahuxi)
STD_ROM_FN(nes_saintsaitiamahuxi)

struct BurnDriver BurnDrvnes_saintsaitiamahuxi = {
	"nes_saintsaitiamahuxi", NULL, NULL, NULL, "200?",
	"Saint Saiya - Tian Ma Huan Xiang (China)\0", NULL, "<unknown>", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_saintsaitiamahuxiRomInfo, nes_saintsaitiamahuxiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Saint Seiya - Ougon Densetsu (Hack, Chinese v2.0)
// https://www.nesbbs.com/bbs/thread-45841-1-1.html
static struct BurnRomInfo nes_saintseiyaodcRomDesc[] = {
	{ "Saint Seiya - Ougon Densetsu (T-Chi, v2.0).nes",          1310736, 0xf7df4b56, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_saintseiyaodc)
STD_ROM_FN(nes_saintseiyaodc)

struct BurnDriver BurnDrvnes_saintseiyaodc = {
	"nes_saintseiyaodc", "nes_saintseiougden", NULL, NULL, "2018",
	"Saint Seiya - Ougon Densetsu (Hack, Chinese v2.0)\0", NULL, "HHNM Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_RPG, 0,
	NESGetZipName, nes_saintseiyaodcRomInfo, nes_saintseiyaodcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Saint Seiya - Ougon Densetsu Kanketsu Hen (Hack, Chinese)
// https://www.nesbbs.com/bbs/thread-40836-1-1.html
static struct BurnRomInfo nes_saintseiyaodkhcRomDesc[] = {
	{ "Saint Seiya - Ougon Densetsu Kanketsu Hen (T-Chi).nes",          524304, 0xb1651b70, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_saintseiyaodkhc)
STD_ROM_FN(nes_saintseiyaodkhc)

struct BurnDriver BurnDrvnes_saintseiyaodkhc = {
	"nes_saintseiyaodkhc", "nes_saintseiougdenkahen", NULL, NULL, "2017",
	"Saint Seiya - Ougon Densetsu Kanketsu Hen (Hack, Chinese)\0", NULL, "HHNM Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_RPG, 0,
	NESGetZipName, nes_saintseiyaodkhcRomInfo, nes_saintseiyaodkhcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Sangokushi II - Haou no Tairiku (Hack, Chinese)
// https://www.nesbbs.com/bbs/thread-52813-1-1.html
static struct BurnRomInfo nes_sangokushiiihanoucRomDesc[] = {
	{ "Sangokushi II - Haou no Tairiku (T-Chi).nes",          524304, 0x611d79ff, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sangokushiiihanouc)
STD_ROM_FN(nes_sangokushiiihanouc)

struct BurnDriver BurnDrvnes_sangokushiiihanouc = {
	"nes_sangokushiiihanouc", "nes_sangokushiiihanou", NULL, NULL, "2017",
	"Sangokushi II - Haou no Tairiku (Hack, Chinese)\0", NULL, "Unkown", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_sangokushiiihanoucRomInfo, nes_sangokushiiihanoucRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Shin Samurai Spirits 2 - Haoumaru Jigoku Hen (China) (Unl)
static struct BurnRomInfo nes_shinsamspi2RomDesc[] = {
	{ "Shin Samurai Spirits 2 - Haoumaru Jigoku Hen (China).nes",          655376, 0x3398afe5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_shinsamspi2)
STD_ROM_FN(nes_shinsamspi2)

struct BurnDriver BurnDrvnes_shinsamspi2 = {
	"nes_shinsamspi2", NULL, NULL, NULL, "1996",
	"Shin Samurai Spirits 2 - Haoumaru Jigoku Hen (China) (Unl)\0", NULL, "J.Y. Company", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_shinsamspi2RomInfo, nes_shinsamspi2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Side Pocket (Hack, Chinese v2)
// https://www.nesbbs.com/bbs/thread-49290-1-1.html [Logo by ZARD]
static struct BurnRomInfo nes_sidepocketcRomDesc[] = {
	{ "Side Pocket (T-Chi, v2).nes",          188432, 0xe34da569, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sidepocketc)
STD_ROM_FN(nes_sidepocketc)

struct BurnDriver BurnDrvnes_sidepocketc = {
	"nes_sidepocketc", "nes_sidepocket", NULL, NULL, "2020",
	"Side Pocket (Hack, Chinese v2)\0", NULL, "Xing Kong", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_sidepocketcRomInfo, nes_sidepocketcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Son Son (Hack, Chinese)
// https://www.ppxclub.com/forum.php?mod=viewthread&tid=710703
static struct BurnRomInfo nes_sonsoncRomDesc[] = {
	{ "Son Son (T-Chi).nes",          81936, 0xe05a2451, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sonsonc)
STD_ROM_FN(nes_sonsonc)

struct BurnDriver BurnDrvnes_sonsonc = {
	"nes_sonsonc", "nes_sonson", NULL, NULL, "2022",
	"Son Son (Hack, Chinese)\0", NULL, "NOKOH", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_sonsoncRomInfo, nes_sonsoncRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Spider-Man - Return of the Sinister Six (Hack, Chinese)
// https://www.ppxclub.com/forum.php?mod=viewthread&tid=708048
static struct BurnRomInfo nes_spidemancRomDesc[] = {
	{ "Spider-Man - Return of the Sinister Six (T-Chi).nes",          393232, 0xa116d626, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_spidemanc)
STD_ROM_FN(nes_spidemanc)

struct BurnDriver BurnDrvnes_spidemanc = {
	"nes_spidemanc", "nes_spideman", NULL, NULL, "2021",
	"Spider-Man - Return of the Sinister Six (Hack, Chinese)\0", NULL, "Ni You De Wu Cai Yu", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_spidemancRomInfo, nes_spidemancRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Takahashi Meijin no Bouken-jima IV (Hack, Chinese)
// https://www.ppxclub.com/forum.php?mod=viewthread&tid=710779
static struct BurnRomInfo nes_takameivicRomDesc[] = {
	{ "Takahashi Meijin no Bouken-jima IV (T-Chi).nes",          524304, 0x5d164133, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_takameivic)
STD_ROM_FN(nes_takameivic)

struct BurnDriver BurnDrvnes_takameivic = {
	"nes_takameivic", "nes_advenisliv", NULL, NULL, "2022",
	"Takahashi Meijin no Bouken-jima IV (Hack, Chinese)\0", NULL, "NOKOH", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_takameivicRomInfo, nes_takameivicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Teenage Mutant Ninja Turtles - Tournament Fighters (Hack, Chinese)
// https://www.ppxclub.com/forum.php?mod=viewthread&tid=710779
static struct BurnRomInfo nes_tmnttoufigscRomDesc[] = {
	{ "Teenage Mutant Ninja Turtles - Tournament Fighters (T-Chi).nes",          294928, 0x51ac1eb7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tmnttoufigsc)
STD_ROM_FN(nes_tmnttoufigsc)

struct BurnDriver BurnDrvnes_tmnttoufigsc = {
	"nes_tmnttoufigsc", "nes_tmnttoufig", NULL, NULL, "2022",
	"Teenage Mutant Ninja Turtles - Tournament Fighters (Hack, Chinese)\0", NULL, "NOKOH", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_tmnttoufigscRomInfo, nes_tmnttoufigscRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Teenage Mutant Ninja Turtles II - The Arcade Game (Hack, Chinese)
// Modified by NOKOH
// https://www.ppxclub.com/forum.php?mod=viewthread&tid=720874
static struct BurnRomInfo nes_tmntiiarcgamtcRomDesc[] = {
	{ "Teenage Mutant Ninja Turtles II - The Arcade Game (T-Chi).nes",          786448, 0x35e378fc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tmntiiarcgamtc)
STD_ROM_FN(nes_tmntiiarcgamtc)

struct BurnDriver BurnDrvnes_tmntiiarcgamtc = {
	"nes_tmntiiarcgamtc", "nes_tmntiiarcgam", NULL, NULL, "2023",
	"Teenage Mutant Ninja Turtles II - The Arcade Game (Hack, Chinese)\0", NULL, "NOKOH", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_tmntiiarcgamtcRomInfo, nes_tmntiiarcgamtcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tekken 2 (Unl)
static struct BurnRomInfo nes_tekken2RomDesc[] = {
	{ "Tekken 2 (Unl).nes",          655376, 0x9a51e26c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tekken2)
STD_ROM_FN(nes_tekken2)

struct BurnDriver BurnDrvnes_tekken2 = {
	"nes_tekken2", NULL, NULL, NULL, "1996",
	"Tekken 2 (Unl)\0", NULL, "J.Y. Company", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_tekken2RomInfo, nes_tekken2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tekken 3 (Unl)
static struct BurnRomInfo nes_tekken3RomDesc[] = {
	{ "Tekken 3 (Unl).nes",          393232, 0xc61358ab, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tekken3)
STD_ROM_FN(nes_tekken3)

struct BurnDriver BurnDrvnes_tekken3 = {
	"nes_tekken3", NULL, NULL, NULL, "1996",
	"Tekken 3 (Unl)\0", NULL, "J.Y. Company", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_tekken3RomInfo, nes_tekken3RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tiny Toon Adventures (Hack, Chinese)
// https://www.ppxclub.com/forum.php?mod=viewthread&tid=709671&fromuid=17888
static struct BurnRomInfo nes_tinytooadvscRomDesc[] = {
	{ "Tiny Toon Adventures (T-Chi).nes",          344080, 0xfbf2bb98, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tinytooadvsc)
STD_ROM_FN(nes_tinytooadvsc)

struct BurnDriver BurnDrvnes_tinytooadvsc = {
	"nes_tinytooadvsc", "nes_tinytooadv", NULL, NULL, "2022",
	"Tiny Toon Adventures (Hack, Chinese)\0", NULL, "Ni You De Wu Cai Yu", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_tinytooadvscRomInfo, nes_tinytooadvscRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tokkyuu Shirei Solbrain (Hack, Chinese)
// https://www.ppxclub.com/forum.php?mod=viewthread&tid=705238
static struct BurnRomInfo nes_tokkyshisolcRomDesc[] = {
	{ "Tokkyuu Shirei Solbrain (T-Chi).nes",          524304, 0xe006a59f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tokkyshisolc)
STD_ROM_FN(nes_tokkyshisolc)

struct BurnDriver BurnDrvnes_tokkyshisolc = {
	"nes_tokkyshisolc", "nes_shatterhand", NULL, NULL, "2021",
	"Tokkyuu Shirei Solbrain (Hack, Chinese)\0", NULL, "Ni You De Wu Cai Yu", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_tokkyshisolcRomInfo, nes_tokkyshisolcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wai Wai World 2 - SOS!! Paseri Jou (Hack, Chinese v1.1)
// https://www.nesbbs.com/bbs/thread-53323-1-1.html
static struct BurnRomInfo nes_waiwaiwor2cRomDesc[] = {
	{ "Wai Wai World 2 - SOS!! Paseri Jou (T-Chi, v1.1).nes",          786448, 0xb03f3551, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_waiwaiwor2c)
STD_ROM_FN(nes_waiwaiwor2c)

struct BurnDriver BurnDrvnes_waiwaiwor2c = {
	"nes_waiwaiwor2c", "nes_waiwaiwor2", NULL, NULL, "2022",
	"Wai Wai World 2 - SOS!! Paseri Jou (Hack, Chinese v1.1)\0", NULL, "DMG Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_waiwaiwor2cRomInfo, nes_waiwaiwor2cRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wanpaku Duck Yume Bouken (Hack, Chinese v1.1)
// https://www.nesbbs.com/bbs/thread-51129-1-1.html
static struct BurnRomInfo nes_wanpakuduckcRomDesc[] = {
	{ "Wanpaku Duck Yume Bouken (T-Chi, v1.1).nes",          196624, 0x7c952f46, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_wanpakuduckc)
STD_ROM_FN(nes_wanpakuduckc)

struct BurnDriver BurnDrvnes_wanpakuduckc = {
	"nes_wanpakuduckc", "nes_ducktales", NULL, NULL, "2021",
	"Wanpaku Duck Yume Bouken (Hack, Chinese v1.1)\0", NULL, "Advance Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_wanpakuduckcRomInfo, nes_wanpakuduckcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// World of Warcraft - Demon Hunter (China) (Unl)
static struct BurnRomInfo nes_worldwarcRomDesc[] = {
	{ "World of Warcraft - Demon Hunter (China).nes",          1048592, 0xc9644f6c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_worldwarc)
STD_ROM_FN(nes_worldwarc)

struct BurnDriver BurnDrvnes_worldwarc = {
	"nes_worldwarc", "nes_worldwar", NULL, NULL, "2008",
	"World of Warcraft - Demon Hunter (China) (Unl)\0", NULL, "ShenZhen Nanjing Technology", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_worldwarcRomInfo, nes_worldwarcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// World of Warcraft - Demon Hunter (Hack, English)
static struct BurnRomInfo nes_worldwarRomDesc[] = {
	{ "World of Warcraft - Demon Hunter (T-Eng).nes",          1048592, 0x45593e64, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_worldwar)
STD_ROM_FN(nes_worldwar)

struct BurnDriver BurnDrvnes_worldwar = {
	"nes_worldwar", NULL, NULL, NULL, "2020",
	"World of Warcraft - Demon Hunter (Hack, English)\0", NULL, "pacnsacdave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_worldwarRomInfo, nes_worldwarRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Xiao Hong Mao - Little Red Hood (China) (Unl)
static struct BurnRomInfo nes_xiaohonmaoRomDesc[] = {
	{ "Xiao Hong Mao - Little Red Hood (Ch).nes",          40976, 0xeb6df8e3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_xiaohonmao)
STD_ROM_FN(nes_xiaohonmao)

struct BurnDriver BurnDrvnes_xiaohonmao = {
	"nes_xiaohonmao", NULL, NULL, NULL, "1989",
	"Xiao Hong Mao - Little Red Hood (China) (Unl)\0", NULL, "Joy Van", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_xiaohonmaoRomInfo, nes_xiaohonmaoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Zelda no Densetsu - The Hyrule Fantasy (Hack, Chinese) - (FDS to NES)
// https://www.ppxclub.com/forum.php?mod=viewthread&tid=711227
static struct BurnRomInfo nes_zeldanodencRomDesc[] = {
	{ "Zelda no Densetsu - The Hyrule Fantasy (T-Chi).nes",          131088, 0x4522aa89, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_zeldanodenc)
STD_ROM_FN(nes_zeldanodenc)

struct BurnDriver BurnDrvnes_zeldanodenc = {
	"nes_zeldanodenc", "nes_legenzel", NULL, NULL, "2022",
	"Zelda no Densetsu - The Hyrule Fantasy (Hack, Chinese)\0", "FDS to NES Hack", "NOKOH", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_zeldanodencRomInfo, nes_zeldanodencRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Zen - Intergalactic Ninja (Hack, Chinese)
// https://www.ppxclub.com/forum.php?mod=viewthread&tid=711394
/* It is recommended to use overclocking to reduce the flicker generated during screen switching */
static struct BurnRomInfo nes_zencRomDesc[] = {
	{ "Zen - Intergalactic Ninja (T-Chi).nes",          524304, 0xb8e36aee, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_zenc)
STD_ROM_FN(nes_zenc)

struct BurnDriver BurnDrvnes_zenc = {
	"nes_zenc", "nes_zen", NULL, NULL, "2022",
	"Zen - Intergalactic Ninja (Hack, Chinese)\0", NULL, "Ni You De Wu Cai Yu", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_zencRomInfo, nes_zencRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Darkwing Duck (Hack, Chinese)
// https://www.nesbbs.com/bbs/thread-50681-1-1.html
static struct BurnRomInfo nes_darkwingduckcRomDesc[] = {
	{ "Darkwing Duck (T-Chi).nes",          393232, 0x585f3500, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_darkwingduckc)
STD_ROM_FN(nes_darkwingduckc)

struct BurnDriver BurnDrvnes_darkwingduckc = {
	"nes_darkwingduckc", "nes_darkwingduck", NULL, NULL, "2020",
	"Darkwing Duck (Hack, Chinese)\0", NULL, "HHNM Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_darkwingduckcRomInfo, nes_darkwingduckcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Guardic Gaiden (Hack, Chinese v1.1)
// https://www.nesbbs.com/bbs/thread-42503-1-1.html
static struct BurnRomInfo nes_guardicgaidencRomDesc[] = {
	{ "Guardic Gaiden (T-Chi, v1.1).nes",          262160, 0x77df8d83, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_guardicgaidenc)
STD_ROM_FN(nes_guardicgaidenc)

struct BurnDriver BurnDrvnes_guardicgaidenc = {
	"nes_guardicgaidenc", "nes_guardleg", NULL, NULL, "2017",
	"Guardic Gaiden (Hack, Chinese v1.1)\0", NULL, "HHNM Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_SHOOT | GBF_ADV, 0,
	NESGetZipName, nes_guardicgaidencRomInfo, nes_guardicgaidencRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ninja Ryuuken Den III - Yomi no Hakobune (Hack, Chinese)
// Translation by TPU
static struct BurnRomInfo nes_ninjaryudeniiicRomDesc[] = {
	{ "Ninja Ryuuken Den III - Yomi no Hakobune (T-Chi).nes",          344080, 0xba865119, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ninjaryudeniiic)
STD_ROM_FN(nes_ninjaryudeniiic)

struct BurnDriver BurnDrvnes_ninjaryudeniiic = {
	"nes_ninjaryudeniiic", "nes_ninjagaiiii", NULL, NULL, "2002",
	"Ninja Ryuuken Den III - Yomi no Hakobune (Hack, Chinese)\0", NULL, "TPU", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, nes_ninjaryudeniiicRomInfo, nes_ninjaryudeniiicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ninja Ryuuken Den II - Ankoku no Jashin Ken (Hack, Chinese)
// Translation by TPU
static struct BurnRomInfo nes_ninjaryudeniicRomDesc[] = {
	{ "Ninja Ryuuken Den II - Ankoku no Jashin Ken (T-Chi).nes",          335888, 0xf7d5d63b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ninjaryudeniic)
STD_ROM_FN(nes_ninjaryudeniic)

struct BurnDriver BurnDrvnes_ninjaryudeniic = {
	"nes_ninjaryudeniic", "nes_ninjagaiii", NULL, NULL, "200?",
	"Ninja Ryuuken Den II - Ankoku no Jashin Ken (Hack, Chinese)\0", NULL, "TPU", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, nes_ninjaryudeniicRomInfo, nes_ninjaryudeniicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ninja Ryuuken Den (Hack, Chinese)
// Translation by FlameCyclone
static struct BurnRomInfo nes_ninjaryudencRomDesc[] = {
	{ "Ninja Ryuuken Den (T-Chi).nes",          524304, 0x7724d3d0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ninjaryudenc)
STD_ROM_FN(nes_ninjaryudenc)

struct BurnDriver BurnDrvnes_ninjaryudenc = {
	"nes_ninjaryudenc", "nes_ninjagaiden", NULL, NULL, "2017",
	"Ninja Ryuuken Den (Hack, Chinese)\0", NULL, "FlameCyclone", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, nes_ninjaryudencRomInfo, nes_ninjaryudencRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ningen Heiki - Dead Fox (Hack, Chinese v2.0)
// Translation by Xing Kong
static struct BurnRomInfo nes_deadfoxcRomDesc[] = {
	{ "Ningen Heiki - Dead Fox (T-Chi, v2.0).nes",          303120, 0x3cf5df56, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_deadfoxc)
STD_ROM_FN(nes_deadfoxc)

struct BurnDriver BurnDrvnes_deadfoxc = {
	"nes_deadfoxc", "nes_codenam", NULL, NULL, "2010",
	"Ningen Heiki - Dead Fox (Hack, Chinese v2.0)\0", NULL, "Xing Kong", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_deadfoxcRomInfo, nes_deadfoxcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kage (Hack, Chinese)
// https://www.ppxclub.com/forum.php?mod=viewthread&tid=706290
static struct BurnRomInfo nes_kagecRomDesc[] = {
	{ "Kage (T-Chi).nes",          270352, 0x2ff63b35, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kagec)
STD_ROM_FN(nes_kagec)

struct BurnDriver BurnDrvnes_kagec = {
	"nes_kagec", "nes_shadonin", NULL, NULL, "2021",
	"Kage (Hack, Chinese)\0", NULL, "Ni You De Wu Cai Yu", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, nes_kagecRomInfo, nes_kagecRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Mario Bros. 3 (Hack, Chinese)
// https://www.ppxclub.com/forum.php?mod=viewthread&tid=710779
static struct BurnRomInfo nes_smb3cRomDesc[] = {
	{ "Super Mario Bros. 3 (T-Chi).nes",          458768, 0xe39b725d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_smb3c)
STD_ROM_FN(nes_smb3c)

struct BurnDriver BurnDrvnes_smb3c = {
	"nes_smb3c", "nes_smb3", NULL, NULL, "2016",
	"Super Mario Bros. 3 (Hack, Chinese)\0", NULL, "NOKOH", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_smb3cRomInfo, nes_smb3cRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Akumajou Dracula (Hack, Chinese)
// Translation by Fo Yi Team - Xi Xue Nan Jue
static struct BurnRomInfo nes_akumajoudraculacRomDesc[] = {
	{ "Akumajou Dracula (T-Chi).nes",          131088, 0xdc749e67, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_akumajoudraculac)
STD_ROM_FN(nes_akumajoudraculac)

struct BurnDriver BurnDrvnes_akumajoudraculac = {
	"nes_akumajoudraculac", "nes_castlevania", NULL, NULL, "199?",
	"Akumajou Dracula (Hack, Chinese)\0", NULL, "Fo Yi Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_akumajoudraculacRomInfo, nes_akumajoudraculacRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Castlevania - The Holy Relics (Hack)
// Modified by Optomon, Setz, Tessa Montoya, Dr. Mario, Boneless Ivar
// https://www.romhacking.net/hacks/3759/ - 20171201
static struct BurnRomInfo nes_castlevaniahrRomDesc[] = {
	{ "Castlevania - The Holy Relics (Hack).nes",          131088, 0x8603cbbb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_castlevaniahr)
STD_ROM_FN(nes_castlevaniahr)

struct BurnDriver BurnDrvnes_castlevaniahr = {
	"nes_castlevaniahr", "nes_castlevania", NULL, NULL, "2017",
	"Castlevania - The Holy Relics (Hack)\0", NULL, "Optomon", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_castlevaniahrRomInfo, nes_castlevaniahrRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Castlevania - Chorus of Mysteries (Hack, v1.1)
// Modified by Dr. Mario, Optomon
// https://www.romhacking.net/hacks/263/ - 20070618
static struct BurnRomInfo nes_castlevaniacomRomDesc[] = {
	{ "Castlevania - Chorus of Mysteries (v1.1, Hack).nes",          131088, 0xbad05634, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_castlevaniacom)
STD_ROM_FN(nes_castlevaniacom)

struct BurnDriver BurnDrvnes_castlevaniacom = {
	"nes_castlevaniacom", "nes_castlevania", NULL, NULL, "2007",
	"Castlevania - Chorus of Mysteries (Hack, v1.1)\0", NULL, "Optomon & Dr. Mario", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_castlevaniacomRomInfo, nes_castlevaniacomRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Castlevania - The Last Tear (Hack, v4.0)
// Modified by Sky Flare
// https://mail.romhacking.net/hacks/7215/ - 20230915
static struct BurnRomInfo nes_castlevanialtRomDesc[] = {
	{ "Castlevania - The Last Tear v4.0 (2023)(Sky Flare).nes",          131088, 0x8ce018f9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_castlevanialt)
STD_ROM_FN(nes_castlevanialt)

struct BurnDriver BurnDrvnes_castlevanialt = {
	"nes_castlevanialt", "nes_castlevania", NULL, NULL, "2023",
	"Castlevania - The Last Tear (Hack, v4.0)\0", NULL, "Sky Flare", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_castlevanialtRomInfo, nes_castlevanialtRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Contra (Hack, Chinese)
// Translation by FlameCyclone
static struct BurnRomInfo nes_contracRomDesc[] = {
	{ "Contra (T-Chi).nes",          393232, 0x2a39628d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_contrac)
STD_ROM_FN(nes_contrac)

struct BurnDriver BurnDrvnes_contrac = {
	"nes_contrac", "nes_contra", NULL, NULL, "2017",
	"Contra (T-Chi)\0", NULL, "FlameCyclone", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_contracRomInfo, nes_contracRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wai Wai World (Hack, Chinese)
// https://www.ppxclub.com/forum.php?mod=viewthread&tid=710779
static struct BurnRomInfo nes_waiwaiworldcRomDesc[] = {
	{ "Wai Wai World (T-Chi).nes",          524304, 0x7fe5c9f1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_waiwaiworldc)
STD_ROM_FN(nes_waiwaiworldc)

struct BurnDriver BurnDrvnes_waiwaiworldc = {
	"nes_waiwaiworldc", "nes_waiwaiworld", NULL, NULL, "2022",
	"Wai Wai World (Hack, Chinese)\0", NULL, "NOKOH", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_waiwaiworldcRomInfo, nes_waiwaiworldcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Saiyuuki World (Hack, Chinese v1.04)
// https://www.nesbbs.com/bbs/thread-34610-1-1.html
static struct BurnRomInfo nes_saiyuukiworldcRomDesc[] = {
	{ "Saiyuuki World (T-Chi, v1.04).nes",          262160, 0x6e66cf6f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_saiyuukiworldc)
STD_ROM_FN(nes_saiyuukiworldc)

struct BurnDriver BurnDrvnes_saiyuukiworldc = {
	"nes_saiyuukiworldc", "nes_saiyuukiworld", NULL, NULL, "2016",
	"Saiyuuki World (Hack, Chinese v1.04)\0", NULL, "HHNM Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_saiyuukiworldcRomInfo, nes_saiyuukiworldcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mad City (Hack, Chinese v2)
// Translation by Tan Xiao Feng Sheng
static struct BurnRomInfo nes_madcitycRomDesc[] = {
	{ "Mad City (T-Chi, v2).nes",          393232, 0x3b2ad28b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_madcityc)
STD_ROM_FN(nes_madcityc)

struct BurnDriver BurnDrvnes_madcityc = {
	"nes_madcityc", "nes_advenbaybil", NULL, NULL, "2018",
	"Mad City (Hack, Chinese v2)\0", NULL, "Tan Xiao Feng Sheng", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_SHOOT, 0,
	NESGetZipName, nes_madcitycRomInfo, nes_madcitycRomName, NULL, NULL, NULL, NULL, NESZapperInputInfo, NESZapperDIPInfo,
	NESZapperInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gun Nac (Hack, Chinese)
static struct BurnRomInfo nes_gunnaccRomDesc[] = {
	{ "Gun Nac (T-Chi).nes",          393232, 0x3c63f85a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gunnacc)
STD_ROM_FN(nes_gunnacc)

struct BurnDriver BurnDrvnes_gunnacc = {
	"nes_gunnacc", "nes_gunnac", NULL, NULL, "2013",
	"Gun Nac (Hack, Chinese)\0", NULL, "Jiu Ban", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_gunnaccRomInfo, nes_gunnaccRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mitsume ga Tooru (Hack, Chinese v3)
// https://www.ppxclub.com/forum.php?mod=viewthread&tid=710666
static struct BurnRomInfo nes_mitsumegatoorucRomDesc[] = {
	{ "Mitsume ga Tooru (T-Chi, v3).nes",          393232, 0x5087a64d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mitsumegatooruc)
STD_ROM_FN(nes_mitsumegatooruc)

struct BurnDriver BurnDrvnes_mitsumegatooruc = {
	"nes_mitsumegatooruc", "nes_mitsumegatooru", NULL, NULL, "2022",
	"Mitsume ga Tooru (Hack, Chinese v3)\0", NULL, "Ni You De Wu Cai Yu", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_mitsumegatoorucRomInfo, nes_mitsumegatoorucRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Salamander (Hack, Chinese v1.2)
// https://www.nesbbs.com/bbs/thread-49514-1-1.html
static struct BurnRomInfo nes_salamandercRomDesc[] = {
	{ "Salamander (T-Chi, v1.2).nes",          393232, 0xfbe84b97, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_salamanderc)
STD_ROM_FN(nes_salamanderc)

struct BurnDriver BurnDrvnes_salamanderc = {
	"nes_salamanderc", "nes_salamander", NULL, NULL, "2020",
	"Salamander (Hack, Chinese v1.2)\0", NULL, "Lei Jing Ling", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_HORSHOOT | GBF_VERSHOOT, 0,
	NESGetZipName, nes_salamandercRomInfo, nes_salamandercRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gun-Dec (Hack, Chinese)
// https://www.nesbbs.com/bbs/thread-47884-1-1.html
static struct BurnRomInfo nes_gundeccRomDesc[] = {
	{ "Gun-Dec (T-Chi).nes",          393232, 0x647eccfa, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gundecc)
STD_ROM_FN(nes_gundecc)

struct BurnDriver BurnDrvnes_gundecc = {
	"nes_gundecc", "nes_vice", NULL, NULL, "2019",
	"Gun-Dec (Hack, Chinese)\0", NULL, "HHNM Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_SHOOT | GBF_PLATFORM, 0,
	NESGetZipName, nes_gundeccRomInfo, nes_gundeccRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Teenage Mutant Ninja Turtles (Hack, Chinese v1.1)
// Modified by MEZARANSU, ½ªÎ¬µÚ¶þ, ÂÞÔÆ
// https://www.nesbbs.com/bbs/thread-49880-1-1.html
static struct BurnRomInfo nes_tmntcRomDesc[] = {
	{ "Teenage Mutant Ninja Turtles (T-Chi, v1.1).nes",          393232, 0xa02316dc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tmntc)
STD_ROM_FN(nes_tmntc)

struct BurnDriver BurnDrvnes_tmntc = {
	"nes_tmntc", "nes_tmnt", NULL, NULL, "2021",
	"Teenage Mutant Ninja Turtles (Hack, Chinese v1.1)\0", NULL, "MEZARANSU", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_tmntcRomInfo, nes_tmntcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Chinese II - Dragon Kid (Hack, Chinese v1.4)
// https://www.nesbbs.com/bbs/thread-46648-1-1.html
static struct BurnRomInfo nes_superchiiRomDesc[] = {
	{ "Super Chinese II - Dragon Kid (T-Chi, v1.4).nes",          524304, 0xa9e92ef3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_superchii)
STD_ROM_FN(nes_superchii)

struct BurnDriver BurnDrvnes_superchii = {
	"nes_superchii", "nes_littlninbro", NULL, NULL, "2019",
	"Super Chinese II - Dragon Kid (Hack, Chinese v1.4)\0", NULL, "HHNM Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_RUNGUN | GBF_RPG, 0,
	NESGetZipName, nes_superchiiRomInfo, nes_superchiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Majou Densetsu II - Daimashikyou Galious (Hack, Chinese v2.2)
// https://www.nesbbs.com/bbs/thread-45465-1-2.html
static struct BurnRomInfo nes_majoudeniicRomDesc[] = {
	{ "Majou Densetsu II - Daimashikyou Galious (T-Chi, v2.2).nes",          262160, 0xa032170a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_majoudeniic)
STD_ROM_FN(nes_majoudeniic)

struct BurnDriver BurnDrvnes_majoudeniic = {
	"nes_majoudeniic", "nes_majoudenii", NULL, NULL, "2018",
	"Majou Densetsu II - Daimashikyou Galious (Hack, Chinese v2.2)\0", NULL, "HHNM Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_majoudeniicRomInfo, nes_majoudeniicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Silk Worm (Hack, Chinese v1.1)
// https://www.nesbbs.com/bbs/thread-48769-1-2.html
static struct BurnRomInfo nes_silkwormcRomDesc[] = {
	{ "Silk Worm (T-Chi, v1.1).nes",          393232, 0x3d53c8ad, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_silkwormc)
STD_ROM_FN(nes_silkwormc)

struct BurnDriver BurnDrvnes_silkwormc = {
	"nes_silkwormc", "nes_silkworm", NULL, NULL, "2020",
	"Silk Worm (Hack, Chinese v1.1)\0", NULL, "HHNM Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_silkwormcRomInfo, nes_silkwormcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Argos no Senshi (Hack, Chinese v1.11)
// https://www.nesbbs.com/bbs/thread-34446-1-1.html
static struct BurnRomInfo nes_argosnosenshicRomDesc[] = {
	{ "Argos no Senshi (T-Chi, v1.11).nes",          262160, 0xa1a22c10, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_argosnosenshic)
STD_ROM_FN(nes_argosnosenshic)

struct BurnDriver BurnDrvnes_argosnosenshic = {
	"nes_argosnosenshic", "nes_rygar", NULL, NULL, "2016",
	"Argos no Senshi (Hack, Chinese v1.11)\0", NULL, "HHNM Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_argosnosenshicRomInfo, nes_argosnosenshicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Contra (Hack, Chinese)
// http://flamecyclone.ysepan.com/
static struct BurnRomInfo nes_supercontracRomDesc[] = {
	{ "Super Contra (T-Chi).nes",          393232, 0x8ccbab43, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_supercontrac)
STD_ROM_FN(nes_supercontrac)

struct BurnDriver BurnDrvnes_supercontrac = {
	"nes_supercontrac", "nes_superc", NULL, NULL, "2018",
	"Super Contra (Hack, Chinese)\0", NULL, "FlameCyclone", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_supercontracRomInfo, nes_supercontracRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hebereke (Hack, Chinese)
// https://www.nesbbs.com/bbs/thread-53253-1-1.html
static struct BurnRomInfo nes_heberekecRomDesc[] = {
	{ "Hebereke (T-Chi).nes",          393232, 0x0691129d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_heberekec)
STD_ROM_FN(nes_heberekec)

struct BurnDriver BurnDrvnes_heberekecc= {
	"nes_heberekec", "nes_ufouria", NULL, NULL, "2022",
	"Hebereke (Hack, Chinese)\0", NULL, "HHNM Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_heberekecRomInfo, nes_heberekecRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gun.Smoke (Hack, Chinese)
// http://www.dmgrom.com/cnpage.html
static struct BurnRomInfo nes_gunsmokecRomDesc[] = {
	{ "Gun.Smoke (T-Chi).nes",          163856, 0x4e0b7a7d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gunsmokec)
STD_ROM_FN(nes_gunsmokec)

struct BurnDriver BurnDrvnes_gunsmokec = {
	"nes_gunsmokec", "nes_gunsmoke", NULL, NULL, "2019",
	"Gun.Smoke (Hack, Chinese)\0", NULL, "DMG Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_gunsmokecRomInfo, nes_gunsmokecRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mappy Kids (Hack, Chinese v1.1)
// https://www.nesbbs.com/bbs/thread-48358-1-1.html
static struct BurnRomInfo nes_mappykidscRomDesc[] = {
	{ "Mappy Kids (T-Chi, v1.1).nes",          524304, 0x159bc653, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mappykidsc)
STD_ROM_FN(nes_mappykidsc)

struct BurnDriver BurnDrvnes_mappykidsc = {
	"nes_mappykidsc", "nes_mappykids", NULL, NULL, "2019",
	"Mappy Kids (Hack, Chinese v1.1)\0", NULL, "Lei Jing Ling", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_mappykidscRomInfo, nes_mappykidscRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Daiku no Gen-san 2 - Akage no Dan no Gyakushuu (Hack, Chinese)
// https://www.nesbbs.com/bbs/thread-47859-1-1.html
static struct BurnRomInfo nes_daikunogensan2cRomDesc[] = {
	{ "Daiku no Gen-san 2 - Akage no Dan no Gyakushuu (T-Chi).nes",          524304, 0x66c08cd8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_daikunogensan2c)
STD_ROM_FN(nes_daikunogensan2c)

struct BurnDriver BurnDrvnes_daikunogensan2c = {
	"nes_daikunogensan2c", "nes_daikunogensan2", NULL, NULL, "2019",
	"Daiku no Gen-san 2 - Akage no Dan no Gyakushuu (Hack, Chinese)\0", NULL, "Advance Team & DMG Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_daikunogensan2cRomInfo, nes_daikunogensan2cRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Saiyuuki World 2 - Tenjoukai no Majin (Hack, Chinese)
// https://www.nesbbs.com/bbs/thread-48369-1-1.html
static struct BurnRomInfo nes_saiyuwor2cRomDesc[] = {
	{ "Saiyuuki World 2 - Tenjoukai no Majin (T-Chi).nes",          262160, 0x784fc411, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_saiyuwor2c)
STD_ROM_FN(nes_saiyuwor2c)

struct BurnDriver BurnDrvnes_saiyuwor2c = {
	"nes_saiyuwor2c", "nes_whompem", NULL, NULL, "2019",
	"Saiyuuki World 2 - Tenjoukai no Majin (Hack, Chinese)\0", NULL, "nineswords", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_saiyuwor2cRomInfo, nes_saiyuwor2cRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// DuckTales 2 (Hack, Chinese v1.2)
// https://www.nesbbs.com/bbs/thread-47555-1-1.html
static struct BurnRomInfo nes_ducktales2cRomDesc[] = {
	{ "DuckTales 2 (T-Chi, v1.2).nes",          262160, 0x26815134, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ducktales2c)
STD_ROM_FN(nes_ducktales2c)

struct BurnDriver BurnDrvnes_ducktales2c = {
	"nes_ducktales2c", "nes_ducktales2", NULL, NULL, "2021",
	"DuckTales 2 (Hack, Chinese v1.2)\0", NULL, "DMG Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_ducktales2cRomInfo, nes_ducktales2cRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Daiku no Gen-san (Hack, Chinese)
// https://www.nesbbs.com/bbs/thread-47118-1-1.html
static struct BurnRomInfo nes_daikunogensancRomDesc[] = {
	{ "Daiku no Gen-san (T-Chi).nes",          393232, 0xf0543c45, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_daikunogensanc)
STD_ROM_FN(nes_daikunogensanc)

struct BurnDriver BurnDrvnes_daikunogensanc = {
	"nes_daikunogensanc", "nes_daikunogensan", NULL, NULL, "2019",
	"Daiku no Gen-san (Hack, Chinese)\0", NULL, "DMG Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_daikunogensancRomInfo, nes_daikunogensancRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Jigoku Gokuraku Maru (Hack, Chinese)
// https://www.nesbbs.com/bbs/thread-48502-1-1.html
static struct BurnRomInfo nes_jigokgokmarcRomDesc[] = {
	{ "Jigoku Gokuraku Maru (T-Chi).nes",          393232, 0x375bf357, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jigokgokmarc)
STD_ROM_FN(nes_jigokgokmarc)

struct BurnDriver BurnDrvnes_jigokgokmarc = {
	"nes_jigokgokmarc", "nes_kabuki", NULL, NULL, "2019",
	"Jigoku Gokuraku Maru (Hack, Chinese)\0", NULL, "DMG Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_jigokgokmarcRomInfo, nes_jigokgokmarcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Legend of Zelda - Triforce of the Gods (China)
static struct BurnRomInfo nes_triforcegcRomDesc[] = {
	{ "Legend of Zelda - Triforce of the Gods (China).nes",          2097168, 0x3a1b4502, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_triforcegc)
STD_ROM_FN(nes_triforcegc)

struct BurnDriver BurnDrvnes_triforcegc = {
	"nes_triforcegc", "nes_triforceg", NULL, NULL, "2004",
	"Legend of Zelda - Triforce of the Gods (China)\0", NULL, "Waixing", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_triforcegcRomInfo, nes_triforcegcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Legend of Zelda - Triforce of the Gods (Hack, English)
static struct BurnRomInfo nes_triforcegRomDesc[] = {
	{ "Legend of Zelda - Triforce of the Gods (T-Eng).nes",          2097168, 0x0be2d8fd, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_triforceg)
STD_ROM_FN(nes_triforceg)

struct BurnDriver BurnDrvnes_triforceg = {
	"nes_triforceg", NULL, NULL, NULL, "2018",
	"Legend of Zelda - Triforce of the Gods (Hack, English)\0", NULL, "pacnsacdave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_triforcegRomInfo, nes_triforcegRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Snow Brothers (Hack, Chinese v1.1)
// https://www.nesbbs.com/bbs/thread-53262-1-1.html
static struct BurnRomInfo nes_snowbrothersscRomDesc[] = {
	{ "Snow Brothers (T-Chi, v1.1).nes",          393232, 0xdac8e3dc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_snowbrotherssc)
STD_ROM_FN(nes_snowbrotherssc)

struct BurnDriver BurnDrvnes_snowbrotherssc = {
	"nes_snowbrotherssc", "nes_snowbrothers", NULL, NULL, "2022",
	"Snow Brothers (Hack, Chinese v1.1)\0", NULL, "LSP Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_snowbrothersscRomInfo, nes_snowbrothersscRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// --------------------------
// Spanish Translations Hacks
// --------------------------

// Addams Family, The - Pugsley's Scavenger Hunt (Hack, Spanish v1.1)
// https://www.romhacking.net/
static struct BurnRomInfo nes_addamfampugsschucRomDesc[] = {
	{ "addams family, the - pugsley's scavenger hunt (usa) - castellano v1.1.nes",          262160, 0x54bbec54, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_addamfampugsschuc)
STD_ROM_FN(nes_addamfampugsschuc)

struct BurnDriver BurnDrvnes_addamfampugsschuc = {
	"nes_addamfampugsschuc", "nes_addamfampugsschu", NULL, NULL, "2020",
	"Addams Family, The - Pugsley's Scavenger Hunt (Hack, Spanish v1.1)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_addamfampugsschucRomInfo, nes_addamfampugsschucRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Addams Family, The (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_addamfamcRomDesc[] = {
	{ "addams family, the (usa) - castellano v1.0.nes",          262160, 0x6bd3e973, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_addamfamc)
STD_ROM_FN(nes_addamfamc)

struct BurnDriver BurnDrvnes_addamfamc = {
	"nes_addamfamc", "nes_addamfam", NULL, NULL, "2020",
	"Addams Family, The (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_addamfamcRomInfo, nes_addamfamcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Adventure Island (Hack, Spanish v2.0)
// https://www.romhacking.net/translations/2907/
static struct BurnRomInfo nes_adventureislandcRomDesc[] = {
	{ "Adventure Island T-Spa v2.0 (2023)(Wave).nes",          65552, 0xcec6e76b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_adventureislandc)
STD_ROM_FN(nes_adventureislandc)

struct BurnDriver BurnDrvnes_adventureislandc = {
	"nes_adventureislandc", "nes_adventureisland", NULL, NULL, "2023",
	"Adventure Island (Hack, Spanish v2.0)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_adventureislandcRomInfo, nes_adventureislandcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Adventure Island II (Hack, Spanish)
// https://www.romhacking.net/translations/2908/
static struct BurnRomInfo nes_advenisliicRomDesc[] = {
	{ "Adventure Island II T-Spa (2017)(Wave).nes",          262160, 0x92f21250, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_advenisliic)
STD_ROM_FN(nes_advenisliic)

struct BurnDriver BurnDrvnes_advenisliic = {
	"nes_advenisliic", "nes_advenislii", NULL, NULL, "2017",
	"Adventure Island II (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_advenisliicRomInfo, nes_advenisliicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Adventure Island 3 (Hack, Spanish v1.1)
// https://www.romhacking.net/translations/2920/
static struct BurnRomInfo nes_advenisl3cRomDesc[] = {
	{ "Adventure Island 3 T-Spa v1.1 (2017)(Wave).nes",          262160, 0x31c3056e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_advenisl3c)
STD_ROM_FN(nes_advenisl3c)

struct BurnDriver BurnDrvnes_advenisl3c = {
	"nes_advenisl3c", "nes_advenisl3", NULL, NULL, "2017",
	"Adventure Island 3 (Hack, Spanish v1.1)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_advenisl3cRomInfo, nes_advenisl3cRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Alien 3 (Hack, Spanish v1.1)
// https://www.romhacking.net/
static struct BurnRomInfo nes_alien3cRomDesc[] = {
	{ "alien 3 (usa) - castellano v1.1.nes",          262160, 0xd16b91b7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_alien3c)
STD_ROM_FN(nes_alien3c)

struct BurnDriver BurnDrvnes_alien3c = {
	"nes_alien3c", "nes_alien3", NULL, NULL, "2020",
	"Alien 3 (Hack, Spanish v1.1)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_alien3cRomInfo, nes_alien3cRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Advanced Dungeons & Dragons - Dragon Strike (Hack, Spanish)
// https://www.romhacking.net/translations/4930/
static struct BurnRomInfo nes_advdddscRomDesc[] = {
	{ "advanced dungeons & dragons - dragon strike (usa) - castellano v1.0.nes",          524304, 0x22cfb91d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_advdddsc)
STD_ROM_FN(nes_advdddsc)

struct BurnDriver BurnDrvnes_advdddsc = {
	"nes_advdddsc", "nes_advddds", NULL, NULL, "2019",
	"Advanced Dungeons & Dragons - Dragon Strike (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_advdddscRomInfo, nes_advdddscRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Advanced Dungeons & Dragons - Dragons of Flame (Hack, Spanish)
// https://www.romhacking.net/translations/6889/
static struct BurnRomInfo nes_advdddfsRomDesc[] = {
	{ "Advanced Dungeons & Dragons - Dragons of Flame T-Spa (2023)(Wave).nes",          262160, 0x9e431abb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_advdddfs)
STD_ROM_FN(nes_advdddfs)

struct BurnDriver BurnDrvnes_advdddfs = {
	"nes_advdddfs", "nes_advdddf", NULL, NULL, "2023",
	"Advanced Dungeons & Dragons - Dragons of Flame (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_advdddfsRomInfo, nes_advdddfsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Advanced Dungeons & Dragons - Heroes of the Lance (Hack, Spanish)
// https://www.romhacking.net/translations/4818/
static struct BurnRomInfo nes_advddhlcRomDesc[] = {
	{ "advanced dungeons & dragons - heroes of the lance (usa) - castellano v1.0.nes",          262160, 0x365f9624, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_advddhlc)
STD_ROM_FN(nes_advddhlc)

struct BurnDriver BurnDrvnes_advddhlc = {
	"nes_advddhlc", "nes_advddhl", NULL, NULL, "2019",
	"Advanced Dungeons & Dragons - Heroes of the Lance (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_advddhlcRomInfo, nes_advddhlcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Battle of Olympus, The (Hack, Spanish v1.1)
// https://www.romhacking.net/
static struct BurnRomInfo nes_battlolycRomDesc[] = {
	{ "battle of olympus, the (europe) - castellano v1.1.nes",          131088, 0xab9d1a2e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_battlolyc)
STD_ROM_FN(nes_battlolyc)

struct BurnDriver BurnDrvnes_battlolyc = {
	"nes_battlolyc", "nes_battloly", NULL, NULL, "2018",
	"Battle of Olympus, The (Hack, Spanish v1.1)\0", NULL, "dmlan2000", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_battlolycRomInfo, nes_battlolycRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Battleship (Hack, Spanish)
// https://www.romhacking.net/translations/4208/
static struct BurnRomInfo nes_battleshipcRomDesc[] = {
	{ "battleship (usa) - castellano v1.0.nes",          65552, 0xcf1ee9d6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_battleshipc)
STD_ROM_FN(nes_battleshipc)

struct BurnDriver BurnDrvnes_battleshipc = {
	"nes_battleshipc", "nes_battleship", NULL, NULL, "2019",
	"Battleship (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_STRATEGY | GBF_BOARD, 0,
	NESGetZipName, nes_battleshipcRomInfo, nes_battleshipcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};							

// Bionic Commando (Hack, Spanish v1.03)
// https://www.romhacking.net/
static struct BurnRomInfo nes_bioniccommandocRomDesc[] = {
	{ "bionic commando (japan) - castellano v1.03.nes",          262160, 0xec5f3e79, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bioniccommandoc)
STD_ROM_FN(nes_bioniccommandoc)

struct BurnDriver BurnDrvnes_bioniccommandoc = {
	"nes_bioniccommandoc", "nes_bioniccommando", NULL, NULL, "2013",
	"Bionic Commando (Hack, Spanish v1.03)\0", NULL, "TheFireRed", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_bioniccommandocRomInfo, nes_bioniccommandocRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Blaster Master (Hack, Spanish)
// https://www.romhacking.net/translations/4003/
static struct BurnRomInfo nes_blastermastercRomDesc[] = {
	{ "Blaster Master T-Spa v1.0 (2018)(Wave).nes",          262160, 0xb63123db, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_blastermasterc)
STD_ROM_FN(nes_blastermasterc)

struct BurnDriver BurnDrvnes_blastermasterc = {
	"nes_blastermasterc", "nes_blastermaster", NULL, NULL, "2018",
	"Blaster Master (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_blastermastercRomInfo, nes_blastermastercRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bram Stoker's Dracula (Hack, Spanish v2.0)
// https://www.romhacking.net/translations/2827/
static struct BurnRomInfo nes_bramstosdracRomDesc[] = {
	{ "Bram Stoker's Dracula T-Spa v2.0 (2022)(Wave).nes",          262160, 0xfcbd5a32, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bramstosdrac)
STD_ROM_FN(nes_bramstosdrac)

struct BurnDriver BurnDrvnes_bramstosdrac = {
	"nes_bramstosdrac", "nes_bramstosdra", NULL, NULL, "2022",
	"Bram Stoker's Dracula (Hack, Spanish v2.0)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_bramstosdracRomInfo, nes_bramstosdracRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Captain Tsubasa Vol. II - Super Striker (Hack, Spanish)
// https://www.romhacking.net/translations/2072/
static struct BurnRomInfo nes_captatsuvoliicRomDesc[] = {
	{ "captain tsubasa vol. ii - super striker (japan) - castellano v1.0.nes",          393233, 0x49c692c5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_captatsuvoliic)
STD_ROM_FN(nes_captatsuvoliic)

struct BurnDriver BurnDrvnes_captatsuvoliic = {
	"nes_captatsuvoliic", "nes_captatsuvolii", NULL, NULL, "2013",
	"Captain Tsubasa Vol. II - Super Striker (Hack, Spanish)\0", NULL, "pepodmc", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_SPORTSMISC | GBF_RPG, 0,
	NESGetZipName, nes_captatsuvoliicRomInfo, nes_captatsuvoliicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Castlevania (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_castlevaniacRomDesc[] = {
	{ "castlevania (usa) - castellano 1.0.nes",          131088, 0xde2e6b55, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_castlevaniac)
STD_ROM_FN(nes_castlevaniac)

struct BurnDriver BurnDrvnes_castlevaniac = {
	"nes_castlevaniac", "nes_castlevania", NULL, NULL, "2012",
	"Castlevania (Hack, Spanish)\0", NULL, "Julian L.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_castlevaniacRomInfo, nes_castlevaniacRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Castlevania II - Simon's Quest (Hack, Spanish v2.0)
// https://www.romhacking.net/
static struct BurnRomInfo nes_castliicRomDesc[] = {
	{ "castlevania ii - simon's quest (usa) - castellano v2.0.nes",          262160, 0x38d393a9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_castliic)
STD_ROM_FN(nes_castliic)

struct BurnDriver BurnDrvnes_castliic = {
	"nes_castliic", "nes_castlii", NULL, NULL, "2013",
	"Castlevania II - Simon's Quest (Hack, Spanish v2.0)\0", NULL, "Julian L.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_RPG, 0,
	NESGetZipName, nes_castliicRomInfo, nes_castliicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Akumajou Densetsu (Hack, Spanish v1.1)
// https://www.romhacking.net/
static struct BurnRomInfo nes_akumadenjcRomDesc[] = {
	{ "akumajou densetsu (japan) - castellano v1.1.nes",          393232, 0x33ead706, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_akumadenjc)
STD_ROM_FN(nes_akumadenjc)

struct BurnDriver BurnDrvnes_akumadenjc = {
	"nes_akumadenjc", "nes_castliii", NULL, NULL, "2017",
	"Akumajou Densetsu (Hack, Spanish v1.1)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_akumadenjcRomInfo, nes_akumadenjcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Saint Seiya - Ougon Densetsu (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_saintseiougdencRomDesc[] = {
	{ "saint seiya - ougon densetsu - castellano v1.0.nes.nes",          262160, 0x2abdcc86, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_saintseiougdenc)
STD_ROM_FN(nes_saintseiougdenc)

struct BurnDriver BurnDrvnes_saintseiougdenc = {
	"nes_saintseiougdenc", "nes_saintseiougden", NULL, NULL, "2004",
	"Saint Seiya - Ougon Densetsu (Hack, Spanish)\0", NULL, "Juan", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_RPG, 0,
	NESGetZipName, nes_saintseiougdencRomInfo, nes_saintseiougdencRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Chip 'n Dale - Rescue Rangers (Hack, Spanish v0.9)
// https://www.romhacking.net/
static struct BurnRomInfo nes_chipndalresracRomDesc[] = {
	{ "chip 'n dale - rescue rangers (usa) - castellano v0.9.nes",          262160, 0x7c6aed46, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_chipndalresrac)
STD_ROM_FN(nes_chipndalresrac)

struct BurnDriver BurnDrvnes_chipndalresrac = {
	"nes_chipndalresrac", "nes_chipndalresra", NULL, NULL, "20??",
	"Chip 'n Dale - Rescue Rangers (Hack, Spanish v0.9)\0", NULL, "<unknown>", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_chipndalresracRomInfo, nes_chipndalresracRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Chip 'n Dale - Rescue Rangers 2 (Hack, Spanish v0.99)
// https://www.romhacking.net/
static struct BurnRomInfo nes_chipndalresra2cRomDesc[] = {
	{ "chip 'n dale - rescue rangers 2 (usa) - castellano v0.99.nes",          262160, 0xaa6e37e6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_chipndalresra2c)
STD_ROM_FN(nes_chipndalresra2c)

struct BurnDriver BurnDrvnes_chipndalresra2c = {
	"nes_chipndalresra2c", "nes_chipndalresra2", NULL, NULL, "2019",
	"Chip 'n Dale - Rescue Rangers 2 (Hack, Spanish v0.99)\0", NULL, "jackic", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_chipndalresra2cRomInfo, nes_chipndalresra2cRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Contra (Hack, Spanish)
// https://www.romhacking.net/translations/4947/
static struct BurnRomInfo nes_contracastRomDesc[] = {
	{ "contra (usa) - castellano v1.0.nes",          131088, 0x6a56fc08, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_contracast)
STD_ROM_FN(nes_contracast)

struct BurnDriver BurnDrvnes_contracast = {
	"nes_contracast", "nes_contra", NULL, NULL, "2019",
	"Contra (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_contracastRomInfo, nes_contracastRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Crystalis (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_crystaliscRomDesc[] = {
	{ "crystalis (usa) - castellano v1.0.nes",          393232, 0xb23c737c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_crystalisc)
STD_ROM_FN(nes_crystalisc)

struct BurnDriver BurnDrvnes_crystalisc = {
	"nes_crystalisc", "nes_crystalis", NULL, NULL, "2014",
	"Crystalis (Hack, Spanish)\0", NULL, "Teterilla", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_crystaliscRomInfo, nes_crystaliscRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Darkman (Hack, Spanish v2.0)
// https://www.romhacking.net/translations/2851/
static struct BurnRomInfo nes_darkmancRomDesc[] = {
	{ "Darkman T-Spa v2.0 (2022)(Wave).nes",          262160, 0xccee44b7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_darkmanc)
STD_ROM_FN(nes_darkmanc)

struct BurnDriver BurnDrvnes_darkmanc = {
	"nes_darkmanc", "nes_darkman", NULL, NULL, "2022",
	"Darkman (Hack, Spanish v2.0)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_darkmancRomInfo, nes_darkmancRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Die Hard (Hack, Spanish v1.1)
// https://www.romhacking.net/translations/4979/
static struct BurnRomInfo nes_diehardcRomDesc[] = {
	{ "die hard (usa) - castellano v1.1.nes",          262160, 0x602b9a29, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_diehardc)
STD_ROM_FN(nes_diehardc)

struct BurnDriver BurnDrvnes_diehardc = {
	"nes_diehardc", "nes_diehard", NULL, NULL, "2019",
	"Die Hard (Hack, Spanish v1.1)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_diehardcRomInfo, nes_diehardcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Disney's Aladdin (Hack, Spanish)
// https://www.romhacking.net/translations/3401/
static struct BurnRomInfo nes_aladdincRomDesc[] = {
	{ "disney's aladdin (europe) - castellano v1.0.nes",          262160, 0xb857fcf2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_aladdinc)
STD_ROM_FN(nes_aladdinc)

struct BurnDriver BurnDrvnes_aladdinc = {
	"nes_aladdinc", "nes_aladdin", NULL, NULL, "2018",
	"Disney's Aladdin (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_aladdincRomInfo, nes_aladdincRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Double Dragon (Hack, Spanish v1.1)
// https://www.romhacking.net/
static struct BurnRomInfo nes_doubledragoncRomDesc[] = {
	{ "double dragon (usa) - castellano v1.1.nes",          262160, 0xf5e19c32, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_doubledragonc)
STD_ROM_FN(nes_doubledragonc)

struct BurnDriver BurnDrvnes_doubledragonc = {
	"nes_doubledragonc", "nes_doubledragon", NULL, NULL, "2021",
	"Double Dragon (Hack, Spanish v1.1)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_doubledragoncRomInfo, nes_doubledragoncRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Double Dragon II - The Revenge (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_doubldraiicRomDesc[] = {
	{ "double dragon ii - the revenge (usa) (rev a) - castellano v1.0.nes",          262160, 0x67a0d781, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_doubldraiic)
STD_ROM_FN(nes_doubldraiic)

struct BurnDriver BurnDrvnes_doubldraiic = {
	"nes_doubldraiic", "nes_doubldraii", NULL, NULL, "2017",
	"Double Dragon II - The Revenge (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_doubldraiicRomInfo, nes_doubldraiicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Double Dragon III - The Sacred Stones (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_doubldraiiicRomDesc[] = {
	{ "double dragon iii - the sacred stones (usa) - castellano v1.0.nes",          262160, 0xaa40b251, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_doubldraiiic)
STD_ROM_FN(nes_doubldraiiic)

struct BurnDriver BurnDrvnes_doubldraiiic = {
	"nes_doubldraiiic", "nes_doubldraiii", NULL, NULL, "2018",
	"Double Dragon III - The Sacred Stones (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_doubldraiiicRomInfo, nes_doubldraiiicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Ball Z - Super Butouden 2 (Hack, Spanish v1.1)
// https://www.romhacking.net/
static struct BurnRomInfo nes_dragobalzsupbu2cRomDesc[] = {
	{ "dragon ball z - super butouden 2 (unl) - castellano v1.1.nes",          393232, 0x8e8ebd23, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragobalzsupbu2c)
STD_ROM_FN(nes_dragobalzsupbu2c)

struct BurnDriver BurnDrvnes_dragobalzsupbu2c = {
	"nes_dragobalzsupbu2c", "nes_dragobalzsupbu2", NULL, NULL, "2017",
	"Dragon Ball Z - Super Butouden 2 (Hack, Spanish v1.1)\0", NULL, "Terwilf", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_dragobalzsupbu2cRomInfo, nes_dragobalzsupbu2cRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Ball Z III - Ressen Jinzou Ningen (Hacl, Spanish v1.0a)
// https://www.romhacking.net/
static struct BurnRomInfo nes_dragobalziiirejinicRomDesc[] = {
	{ "dragon ball z iii - ressen jinzou ningen (japan) - castellano v1.0a.nes",          524304, 0xff1d3cf3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragobalziiirejinic)
STD_ROM_FN(nes_dragobalziiirejinic)

struct BurnDriver BurnDrvnes_dragobalziiirejinic = {
	"nes_dragobalziiirejinic", "nes_dragobalziiirejini", NULL, NULL, "2016",
	"Dragon Ball Z III - Ressen Jinzou Ningen (Hacl, Spanish v1.0a)\0", NULL, "TransGen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_STRATEGY | GBF_ADV, 0,
	NESGetZipName, nes_dragobalziiirejinicRomInfo, nes_dragobalziiirejinicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Buster (Hack, Spanish)
// https://www.romhacking.net/translations/5302/
static struct BurnRomInfo nes_dragonbustercRomDesc[] = {
	{ "dragon buster (japan) - castellano v1.0.nes",          163856, 0xe718a85d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragonbusterc)
STD_ROM_FN(nes_dragonbusterc)

struct BurnDriver BurnDrvnes_dragonbusterc = {
	"nes_dragonbusterc", "nes_dragonbuster", NULL, NULL, "2019",
	"Dragon Buster (Hack, Spanish)\0", NULL, "Max1323", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_dragonbustercRomInfo, nes_dragonbustercRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Buster II - Yami no Fuuin (Hack, Spanish)
// https://www.romhacking.net/translations/6792/
static struct BurnRomInfo nes_dragobusiisRomDesc[] = {
	{ "Dragon Buster II - Yami no Fuuin T-Spa (2023)(Max1323).nes",          196624, 0xc661de9e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragobusiis)
STD_ROM_FN(nes_dragobusiis)

struct BurnDriver BurnDrvnes_dragobusiis = {
	"nes_dragobusiis", "nes_dragobusii", NULL, NULL, "2023",
	"Dragon Buster II - Yami no Fuuin (Hack, Spanish)\0", NULL, "Max1323", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_ACTION | GBF_RPG, 0,
	NESGetZipName, nes_dragobusiisRomInfo, nes_dragobusiisRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Ninja (Hack, Spanish v1.1)
// https://www.romhacking.net/translations/7210/
static struct BurnRomInfo nes_dragninjasRomDesc[] = {
	{ "Dragon Ninja (T-Spa v1.1)(2024)(Koda).nes",          262160, 0xb45529fa, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragninjas)
STD_ROM_FN(nes_dragninjas)

struct BurnDriver BurnDrvnes_dragninjas = {
	"nes_dragninjas", "nes_baddudes", NULL, NULL, "2024",
	"Dragon Ninja (Hack, Spanish v1.1)\0", NULL, "Stardust Crusaders", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_dragninjasRomInfo, nes_dragninjasRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Warrior (Hack, Spanish)
// https://www.romhacking.net/translations/5285/
static struct BurnRomInfo nes_dragonwarriorcRomDesc[] = {
	{ "dragon warrior (usa) (rev a) - castellano v1.0.nes",          81936, 0x7442bd9f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragonwarriorc)
STD_ROM_FN(nes_dragonwarriorc)

struct BurnDriver BurnDrvnes_dragonwarriorc = {
	"nes_dragonwarriorc", "nes_dragonwarrior", NULL, NULL, "2019",
	"Dragon Warrior (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_dragonwarriorcRomInfo, nes_dragonwarriorcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Warrior III (Hack, Spanish v0.9)
// https://www.romhacking.net/translations/2684/
static struct BurnRomInfo nes_dragowariiicRomDesc[] = {
	{ "dragon warrior iii (usa) - castellano v0.9.nes",          524304, 0xc3d2f589, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragowariiic)
STD_ROM_FN(nes_dragowariiic)

struct BurnDriver BurnDrvnes_dragowariiic = {
	"nes_dragowariiic", "nes_dragowariii", NULL, NULL, "2017",
	"Dragon Warrior III (Hack, Spanish v0.9)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_dragowariiicRomInfo, nes_dragowariiicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Warrior IV (Hack, Spanish)
// https://www.romhacking.net/translations/1618/
static struct BurnRomInfo nes_dragowarivcRomDesc[] = {
	{ "dragon warrior iv (usa) - castellano v1.0.nes",          524304, 0xf5577473, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragowarivc)
STD_ROM_FN(nes_dragowarivc)

struct BurnDriver BurnDrvnes_dragowarivc = {
	"nes_dragowarivc", "nes_dragowariv", NULL, NULL, "2016",
	"Dragon Warrior IV (Hack, Spanish)\0", NULL, "Butz Klauser", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_dragowarivcRomInfo, nes_dragowarivcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon's Lair (Hack, Spanish)
// https://www.romhacking.net/translations/5273/
static struct BurnRomInfo nes_dragonslaircRomDesc[] = {
	{ "dragon's lair (usa) - castellano v1.0.nes",          131088, 0xdb3d2678, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragonslairc)
STD_ROM_FN(nes_dragonslairc)

struct BurnDriver BurnDrvnes_dragonslairc = {
	"nes_dragonslairc", "nes_dragonslair", NULL, NULL, "2019",
	"Dragon's Lair (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_dragonslaircRomInfo, nes_dragonslaircRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// DuckTales (Hack, Spanish v1.1)
// https://www.romhacking.net/
static struct BurnRomInfo nes_ducktalescRomDesc[] = {
	{ "duck tales (usa) - castellano v1.1.nes",          131088, 0xfcb58532, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ducktalesc)
STD_ROM_FN(nes_ducktalesc)

struct BurnDriver BurnDrvnes_ducktalesc = {
	"nes_ducktalesc", "nes_ducktales", NULL, NULL, "2017",
	"DuckTales (Hack, Spanish v1.1)\0", NULL, "Darkchaosblast", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_ducktalescRomInfo, nes_ducktalescRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// DuckTales 2 (Hack, Spanish v1.1)
// https://www.romhacking.net/
static struct BurnRomInfo nes_ducktales2castRomDesc[] = {
	{ "duck tales 2 (usa) - castellano v1.1.nes",          131088, 0x908c28ff, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ducktales2cast)
STD_ROM_FN(nes_ducktales2cast)

struct BurnDriver BurnDrvnes_ducktales2cast = {
	"nes_ducktales2cast", "nes_ducktales2", NULL, NULL, "2017",
	"DuckTales 2 (Hack, Spanish v1.1)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_ducktales2castRomInfo, nes_ducktales2castRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// EarthBound Zero (Hack, Spanish v2.2)
// https://www.romhacking.net/translations/1721/
static struct BurnRomInfo nes_earthboundcRomDesc[] = {
	{ "earthbound (usa) (proto) - castellano v2.2.nes",          524304, 0xd80e3217, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_earthboundc)
STD_ROM_FN(nes_earthboundc)

struct BurnDriver BurnDrvnes_earthboundc = {
	"nes_earthboundc", "nes_earthbound", NULL, NULL, "2016",
	"EarthBound Zero (Hack, Spanish v2.2)\0", NULL, "OAD", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_earthboundcRomInfo, nes_earthboundcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Elevator Action (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_elevatoractioncRomDesc[] = {
	{ "elevator action (usa) - castellano v1.0.nes",          40976, 0xcb844314, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_elevatoractionc)
STD_ROM_FN(nes_elevatoractionc)

struct BurnDriver BurnDrvnes_elevatoractionc = {
	"nes_elevatoractionc", "nes_elevatoraction", NULL, NULL, "2019",
	"Elevator Action (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_elevatoractioncRomInfo, nes_elevatoractioncRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Faxanadu (Hack, Spanish)
// https://www.romhacking.net/translations/6901/
static struct BurnRomInfo nes_faxanaducRomDesc[] = {
	{ "Faxanadu T-Spa v1.0 (2021)(Wave).nes",          262160, 0x4e31a801, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_faxanaduc)
STD_ROM_FN(nes_faxanaduc)

struct BurnDriver BurnDrvnes_faxanaduc = {
	"nes_faxanaduc", "nes_faxanadu", NULL, NULL, "2021",
	"Faxanadu (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_faxanaducRomInfo, nes_faxanaducRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Final Fantasy (Hack, Spanish)
// https://www.romhacking.net/translations/3419/
static struct BurnRomInfo nes_finalfantasycRomDesc[] = {
	{ "final fantasy (usa) - castellano v1.0.nes",          262160, 0x83a1074c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_finalfantasyc)
STD_ROM_FN(nes_finalfantasyc)

struct BurnDriver BurnDrvnes_finalfantasyc = {
	"nes_finalfantasyc", "nes_finalfantasy", NULL, NULL, "2002",
	"Final Fantasy (Hack, Spanish)\0", NULL, "Cunaaao", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_finalfantasycRomInfo, nes_finalfantasycRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Final Fantasy (Hack, Italian)
// https://www.romhacking.net/translations/5633/
static struct BurnRomInfo nes_finalfantasyiRomDesc[] = {
	{ "Final Fantasy T-Ita (2020)(FIUMI).nes",          262160, 0x74201d71, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_finalfantasyi)
STD_ROM_FN(nes_finalfantasyi)

struct BurnDriver BurnDrvnes_finalfantasyi = {
	"nes_finalfantasyi", "nes_finalfantasy", NULL, NULL, "2020",
	"Final Fantasy (Hack, Italian)\0", NULL, "FIUMI", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_finalfantasyiRomInfo, nes_finalfantasyiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Final Fantasy II (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_finalfantasyiicRomDesc[] = {
	{ "final fantasy ii (japan) (headered) - castellano v1.0.nes",          262160, 0x3fba77eb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_finalfantasyiic)
STD_ROM_FN(nes_finalfantasyiic)

struct BurnDriver BurnDrvnes_finalfantasyiic = {
	"nes_finalfantasyiic", "nes_finalfantasyii", NULL, NULL, "20XX?",
	"Final Fantasy II (Hack, Spanish)\0", NULL, "<unknown>", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_finalfantasyiicRomInfo, nes_finalfantasyiicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Final Fantasy III (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_finalfaniiicRomDesc[] = {
	{ "final fantasy iii (japan) - castellano v1.0.nes",          1048592, 0xb328a638, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_finalfaniiic)
STD_ROM_FN(nes_finalfaniiic)

struct BurnDriver BurnDrvnes_finalfaniiic = {
	"nes_finalfaniiic", "nes_finalfaniii", NULL, NULL, "2015",
	"Final Fantasy III (Hack, Spanish)\0", NULL, "Maeson", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_finalfaniiicRomInfo, nes_finalfaniiicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Friday the 13th (Hack, Spanish v1.1)
// https://www.romhacking.net/
static struct BurnRomInfo nes_fridaythe13thcRomDesc[] = {
	{ "friday the 13th (usa) - castellano v1.1.nes",          65552, 0xabecfd68, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_fridaythe13thc)
STD_ROM_FN(nes_fridaythe13thc)

struct BurnDriver BurnDrvnes_fridaythe13thc = {
	"nes_fridaythe13thc", "nes_fridaythe13th", NULL, NULL, "2017",
	"Friday the 13th (Hack, Spanish v1.1)\0", NULL, "JONNYVILLA2088", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_fridaythe13thcRomInfo, nes_fridaythe13thcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ganbare Goemon 2 (Hack, Spanish v0.99)
// https://www.romhacking.net/translations/3817/
static struct BurnRomInfo nes_ganbaregoemon2cRomDesc[] = {
	{ "ganbare goemon 2 (japan) - castellano v0.99.nes",          262160, 0xeca0d0e1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ganbaregoemon2c)
STD_ROM_FN(nes_ganbaregoemon2c)

struct BurnDriver BurnDrvnes_ganbaregoemon2c = {
	"nes_ganbaregoemon2c", "nes_ganbaregoemon2", NULL, NULL, "2021",
	"Ganbare Goemon 2 (Hack, Spanish v0.99)\0", NULL, "jackic", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_ACTION | GBF_RPG, 0,
	NESGetZipName, nes_ganbaregoemon2cRomInfo, nes_ganbaregoemon2cRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ganbare Goemon Gaiden 2 - Tenka no Zaihou (Hack, Spanish v0.98)
// https://www.romhacking.net/translations/3965/
static struct BurnRomInfo nes_ganbagoegai2cRomDesc[] = {
	{ "ganbare goemon gaiden 2 - tenka no zaihou (japan) - castellano v0.98.nes",          524304, 0xc2e96c08, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ganbagoegai2c)
STD_ROM_FN(nes_ganbagoegai2c)

struct BurnDriverD BurnDrvnes_ganbagoegai2c = {
	"nes_ganbagoegai2c", "nes_ganbagoegai2", NULL, NULL, "2020",
	"Ganbare Goemon Gaiden 2 - Tenka no Zaihou (Hack, Spanish v0.98)\0", NULL, "jackic", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_ganbagoegai2cRomInfo, nes_ganbagoegai2cRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ganbare Goemon! - Karakuri Douchuu (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_ganbagoecRomDesc[] = {
	{ "ganbare goemon! - karakuri douchuu (japan) - castellano v1.0.nes",          262160, 0xbf99d7e4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ganbagoec)
STD_ROM_FN(nes_ganbagoec)

struct BurnDriver BurnDrvnes_ganbagoec = {
	"nes_ganbagoec", "nes_ganbagoe", NULL, NULL, "2018",
	"Ganbare Goemon! - Karakuri Douchuu (Hack, Spanish)\0", NULL, "jackic", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_ganbagoecRomInfo, nes_ganbagoecRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Golgo 13 - Top Secret Episode (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_golgo13cRomDesc[] = {
	{ "golgo 13 - top secret episode (usa) - castellano v1.0.nes",          262160, 0x47cd6b0f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_golgo13c)
STD_ROM_FN(nes_golgo13c)

struct BurnDriver BurnDrvnes_golgo13c = {
	"nes_golgo13c", "nes_golgo13", NULL, NULL, "2021",
	"Golgo 13 - Top Secret Episode (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_golgo13cRomInfo, nes_golgo13cRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Goonies, The (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_gooniescRomDesc[] = {
	{ "goonies (japan) - castellano v1.0.nes",          49168, 0xb74b6dc4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gooniesc)
STD_ROM_FN(nes_gooniesc)

struct BurnDriver BurnDrvnes_gooniesc = {
	"nes_gooniesc", "nes_goonies", NULL, NULL, "2018",
	"Goonies, The (Hack, Spanish)\0", NULL, "Darkchaosblast", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_gooniescRomInfo, nes_gooniescRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Goonies II, The (Hack, Spanish v1.1)
// https://www.romhacking.net/
static struct BurnRomInfo nes_gooniesiithecRomDesc[] = {
	{ "goonies ii, the (usa) - castellano v1.1.nes",          131088, 0x6bc02b52, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gooniesiithec)
STD_ROM_FN(nes_gooniesiithec)

struct BurnDriver BurnDrvnes_gooniesiithec = {
	"nes_gooniesiithec", "nes_gooniesiithe", NULL, NULL, "2018",
	"Goonies II, The (Hack, Spanish v1.1)\0", NULL, "Darkchaosblast", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_gooniesiithecRomInfo, nes_gooniesiithecRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Glory of Heracles, The - Labors of the Divine Hero (Hack, Spanish v1.1)
// https://www.romhacking.net/translations/6443/
static struct BurnRomInfo nes_heraclessRomDesc[] = {
	{ "Glory of Heracles, The - Labors of the Divine Hero T-Spa v1.1 (2022)(Max1323).nes",          262160, 0xc7510b91, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_heracless)
STD_ROM_FN(nes_heracless)

struct BurnDriver BurnDrvnes_heracless = {
	"nes_heracless", "nes_heracles", NULL, NULL, "2022",
	"Glory of Heracles, The - Labors of the Divine Hero (Hack, Spanish v1.1)\0", NULL, "Max1323", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_heraclessRomInfo, nes_heraclessRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Glory of Heracles II, The - Titans' Downfall (Hack, Spanish)
// https://www.romhacking.net/translations/6813/
static struct BurnRomInfo nes_heracles2sRomDesc[] = {
	{ "Glory of Heracles II, The - Titans' Downfall T-Spa (2023)(Max1323).nes",          262160, 0xf7a6eb95, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_heracles2s)
STD_ROM_FN(nes_heracles2s)

struct BurnDriver BurnDrvnes_heracles2s = {
	"nes_heracles2s", "nes_heracles2", NULL, NULL, "2023",
	"Glory of Heracles II, The - Titans' Downfall (Hack, Spanish)\0", NULL, "Max1323", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_heracles2sRomInfo, nes_heracles2sRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hokuto no Ken 2 (Hack, Spanish v1.1)
// https://www.romhacking.net/translations/3922/
static struct BurnRomInfo nes_hokutonoken2cRomDesc[] = {
	{ "hokuto no ken 2 (japan) - castellano v1.1.nes",          131088, 0x3a3cd6df, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hokutonoken2c)
STD_ROM_FN(nes_hokutonoken2c)

struct BurnDriver BurnDrvnes_hokutonoken2c = {
	"nes_hokutonoken2c", "nes_hokutonoken2", NULL, NULL, "2018",
	"Hokuto no Ken 2 (Hack, Spanish v1.1)\0", NULL, "Jonathan", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE |  BDF_HACK, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_hokutonoken2cRomInfo, nes_hokutonoken2cRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hokuto no Ken 3 - Shin Seiki Souzou Seiken Restuden (Hack, Spanish)
// https://www.romhacking.net/translations/4391/
static struct BurnRomInfo nes_hokutonoken3cRomDesc[] = {
	{ "hokuto no ken 3 - shin seiki souzou seiken restuden (japan) - castellano v1.0.nes",          262160, 0x9e7cc5dc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hokutonoken3c)
STD_ROM_FN(nes_hokutonoken3c)

struct BurnDriver BurnDrvnes_hokutonoken3c = {
	"nes_hokutonoken3c", "nes_hokutonoken3", NULL, NULL, "2019",
	"Hokuto no Ken 3 - Shin Seiki Souzou Seiken Restuden (Hack, Spanish)\0", NULL, "RMGlitch", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_hokutonoken3cRomInfo, nes_hokutonoken3cRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hydlide (Hack, Spanish)
// https://www.romhacking.net/translations/4342/
static struct BurnRomInfo nes_hydlidecRomDesc[] = {
	{ "hydlide (usa) - castellano v1.0.nes",          40976, 0x9b4f06c0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hydlidec)
STD_ROM_FN(nes_hydlidec)

struct BurnDriver BurnDrvnes_hydlidec = {
	"nes_hydlidec", "nes_hydlide", NULL, NULL, "2019",
	"Hydlide (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_hydlidecRomInfo, nes_hydlidecRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Immortal, The (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_immortalthecRomDesc[] = {
	{ "immortal, the (usa) - castellano v1.0.nes",          393232, 0xbf87b488, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_immortalthec)
STD_ROM_FN(nes_immortalthec)

struct BurnDriver BurnDrvnes_immortalthec = {
	"nes_immortalthec", "nes_immortalthe", NULL, NULL, "2004",
	"Immortal, The (Hack, Spanish)\0", NULL, "R. Merida", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RPG | GBF_RUNGUN, 0,
	NESGetZipName, nes_immortalthecRomInfo, nes_immortalthecRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Jungle Book, The (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_junglebookthecRomDesc[] = {
	{ "jungle book, the (usa) - castellano v1.0.nes",          262160, 0x996a8677, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_junglebookthec)
STD_ROM_FN(nes_junglebookthec)

struct BurnDriver BurnDrvnes_junglebookthec = {
	"nes_junglebookthec", "nes_junglebookthe", NULL, NULL, "2018",
	"Jungle Book, The (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_junglebookthecRomInfo, nes_junglebookthecRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Just Breed (Hack, Spanish v2.0)
// https://www.romhacking.net/translations/1535/
static struct BurnRomInfo nes_justbreedcRomDesc[] = {
	{ "just breed (japan) - castellano v2.0.nes",          786448, 0xe415a13f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_justbreedc)
STD_ROM_FN(nes_justbreedc)

struct BurnDriver BurnDrvnes_justbreedc = {
	"nes_justbreedc", "nes_justbreed", NULL, NULL, "2010",
	"Just Breed (Hack, Spanish v2.0)\0", NULL, "Butz Klauser", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RPG | GBF_STRATEGY, 0,
	NESGetZipName, nes_justbreedcRomInfo, nes_justbreedcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Karate Kid, The (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_karatekidthecRomDesc[] = {
	{ "karate kid, the (usa) - castellano v1.0.nes",          65552, 0x99cc2044, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_karatekidthec)
STD_ROM_FN(nes_karatekidthec)

struct BurnDriver BurnDrvnes_karatekidthec = {
	"nes_karatekidthec", "nes_karatekidthe", NULL, NULL, "2020",
	"Karate Kid, The (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_karatekidthecRomInfo, nes_karatekidthecRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Karateka (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_karatekacRomDesc[] = {
	{ "karateka (japan) - castellano v1.0.nes",          24592, 0x3839edb9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_karatekac)
STD_ROM_FN(nes_karatekac)

struct BurnDriver BurnDrvnes_karatekac = {
	"nes_karatekac", "nes_karateka", NULL, NULL, "2020",
	"Karateka (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_karatekacRomInfo, nes_karatekacRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Krusty's Fun House (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_krustsfunhoucRomDesc[] = {
	{ "krusty's fun house (usa) - castellano v1.0.nes",          393232, 0xb09308d4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_krustsfunhouc)
STD_ROM_FN(nes_krustsfunhouc)

struct BurnDriver BurnDrvnes_krustsfunhouc = {
	"nes_krustsfunhouc", "nes_krustsfunhou", NULL, NULL, "2019",
	"Krusty's Fun House (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_PUZZLE, 0,
	NESGetZipName, nes_krustsfunhoucRomInfo, nes_krustsfunhoucRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Legacy of the Wizard (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_legacwizcRomDesc[] = {
	{ "legacy of the wizard (usa) - castellano v1.0.nes",          196624, 0xe87e3d09, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_legacwizc)
STD_ROM_FN(nes_legacwizc)

struct BurnDriver BurnDrvnes_legacwizc = {
	"nes_legacwizc", "nes_legacwiz", NULL, NULL, "2020",
	"Legacy of the Wizard (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_legacwizcRomInfo, nes_legacwizcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Legend of Zelda, The (Hack, Italian)
// https://www.romhacking.net/
static struct BurnRomInfo nes_legenzeliRomDesc[] = {
	{ "Legend of Zelda, The (it) (2019)(Stich991).nes",          131088, 0xe0811f91, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_legenzeli)
STD_ROM_FN(nes_legenzeli)

struct BurnDriver BurnDrvnes_legenzeli = {
	"nes_legenzeli", "nes_legenzel", NULL, NULL, "2019",
	"Legend of Zelda, The (Hack, Italian)\0", NULL, "Stich991", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_legenzeliRomInfo, nes_legenzeliRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Legend of Zelda Redux, The (Hack, v3.1)
// https://www.romhacking.net/hacks/5752/
static struct BurnRomInfo nes_legenzelrdRomDesc[] = {
	{ "Legend of Zelda Redux, The v3.1 (2022)(ShadowOne333).nes",          131088, 0x183f0f76, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_legenzelrd)
STD_ROM_FN(nes_legenzelrd)

struct BurnDriver BurnDrvnes_legenzelrd = {
	"nes_legenzelrd", "nes_legenzel", NULL, NULL, "2022",
	"Legend of Zelda Redux, The (Hack, v3.1)\0", NULL, "ShadowOne333", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_legenzelrdRomInfo, nes_legenzelrdRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Legend of Zelda, The - Ancient Dungeon (Hack, v3.0)
// https://www.romhacking.net/hacks/7358/
static struct BurnRomInfo nes_legenzeladRomDesc[] = {
	{ "Legend of Zelda, The - Ancient Dungeon v3.0 (2023)(arnpoly).nes",          131088, 0x2846a6b8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_legenzelad)
STD_ROM_FN(nes_legenzelad)

struct BurnDriver BurnDrvnes_legenzelad = {
	"nes_legenzelad", "nes_legenzel", NULL, NULL, "2023",
	"Legend of Zelda, The - Ancient Dungeon (Hack, v3.0)\0", NULL, "arnpoly", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_legenzeladRomInfo, nes_legenzeladRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lion King, The (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_lionkingthecRomDesc[] = {
	{ "lion king, the (europe) - castellano v1.0.nes",          262160, 0x562245ae, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lionkingthec)
STD_ROM_FN(nes_lionkingthec)

struct BurnDriver BurnDrvnes_lionkingthec = {
	"nes_lionkingthec", "nes_lionkingthe", NULL, NULL, "2019",
	"Lion King, The (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_lionkingthecRomInfo, nes_lionkingthecRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lupin Sansei - Pandora no Isan (Hack, Spanish)
// https://www.romhacking.net/translations/3780/
static struct BurnRomInfo nes_lupinsancRomDesc[] = {
	{ "lupin sansei - pandora no isan (japan) - castellano v1.0.nes",          196624, 0x0bb24755, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lupinsanc)
STD_ROM_FN(nes_lupinsanc)

struct BurnDriver BurnDrvnes_lupinsanc = {
	"nes_lupinsanc", "nes_lupinsan", NULL, NULL, "2018",
	"Lupin Sansei - Pandora no Isan (Hack, Spanish)\0", NULL, "jackic", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_lupinsancRomInfo, nes_lupinsancRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mafat Conspiracy - Golgo 13 (Hack, Spanish v1.1)
// https://www.romhacking.net/translations/3456/
static struct BurnRomInfo nes_mafatconcRomDesc[] = {
	{ "mafat conspiracy - golgo 13 (usa) - castellano v1.1.nes",          262160, 0xb527ad27, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mafatconc)
STD_ROM_FN(nes_mafatconc)

struct BurnDriver BurnDrvnes_mafatconc = {
	"nes_mafatconc", "nes_mafatcon", NULL, NULL, "2018",
	"Mafat Conspiracy - Golgo 13 (Hack, Spanish v1.1)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_SHOOT, 0,
	NESGetZipName, nes_mafatconcRomInfo, nes_mafatconcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Magic of Scheherazade, The (Hack, Spanish v0.99)
// https://www.romhacking.net/translations/5248/
static struct BurnRomInfo nes_magicschcRomDesc[] = {
	{ "magic of scheherazade, the (usa) - castellano v0.99.nes",          262160, 0x9d080895, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_magicschc)
STD_ROM_FN(nes_magicschc)

struct BurnDriver BurnDrvnes_magicschc = {
	"nes_magicschc", "nes_magicsch", NULL, NULL, "2019",
	"Magic of Scheherazade, The (Hack, Spanish v0.99)\0", NULL, "jackic", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_magicschcRomInfo, nes_magicschcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mega Man (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_megamancRomDesc[] = {
	{ "megaman (usa) - castellano v1.0.nes",          131088, 0x53db1d74, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_megamanc)
STD_ROM_FN(nes_megamanc)

struct BurnDriver BurnDrvnes_megamanc = {
	"nes_megamanc", "nes_megaman", NULL, NULL, "2017",
	"Mega Man (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_megamancRomInfo, nes_megamancRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mega Man II (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_megaman2cRomDesc[] = {
	{ "megaman ii (usa) - castellano v1.0.nes",          262160, 0x35babd12, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_megaman2c)
STD_ROM_FN(nes_megaman2c)

struct BurnDriver BurnDrvnes_megaman2c = {
	"nes_megaman2c", "nes_megaman2", NULL, NULL, "2017",
	"Mega Man II (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_megaman2cRomInfo, nes_megaman2cRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mega Man III (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_megaman3cRomDesc[] = {
	{ "megaman iii (usa) - castellano v1.0.nes",          393232, 0x7e1471b2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_megaman3c)
STD_ROM_FN(nes_megaman3c)

struct BurnDriver BurnDrvnes_megaman3c = {
	"nes_megaman3c", "nes_megaman3", NULL, NULL, "2017",
	"Mega Man III (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_megaman3cRomInfo, nes_megaman3cRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mega Man IV (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_megaman4cRomDesc[] = {
	{ "megaman iv (usa) (rev a) - castellano v1.0.nes",          524304, 0xd4141bb2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_megaman4c)
STD_ROM_FN(nes_megaman4c)

struct BurnDriver BurnDrvnes_megaman4c = {
	"nes_megaman4c", "nes_megaman4", NULL, NULL, "2017",
	"Mega Man IV (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_megaman4cRomInfo, nes_megaman4cRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mega Man V (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_megaman5cRomDesc[] = {
	{ "megaman v (usa) - castellano v1.0.nes",          524304, 0xc46d7cd6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_megaman5c)
STD_ROM_FN(nes_megaman5c)

struct BurnDriver BurnDrvnes_megaman5c = {
	"nes_megaman5c", "nes_megaman5", NULL, NULL, "2017",
	"Mega Man V (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_megaman5cRomInfo, nes_megaman5cRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mega Man VI (Hack, Spanish v1.1)
// https://www.romhacking.net/translations/3267/
static struct BurnRomInfo nes_megaman6cRomDesc[] = {
	{ "megaman vi (usa) - castellano v1.1.nes",          524304, 0x1b902805, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_megaman6c)
STD_ROM_FN(nes_megaman6c)

struct BurnDriver BurnDrvnes_megaman6c = {
	"nes_megaman6c", "nes_megaman6", NULL, NULL, "2016",
	"Mega Man VI (Hack, Spanish v1.1)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_megaman6cRomInfo, nes_megaman6cRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Metal Gear (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_metalgearcRomDesc[] = {
	{ "metal gear (usa) - castellano v1.0.nes",          131088, 0xbabc19e2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_metalgearc)
STD_ROM_FN(nes_metalgearc)

struct BurnDriver BurnDrvnes_metalgearc = {
	"nes_metalgearc", "nes_metalgear", NULL, NULL, "2020",
	"Metal Gear (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_ADV, 0,
	NESGetZipName, nes_metalgearcRomInfo, nes_metalgearcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Metroid (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_metroidcRomDesc[] = {
	{ "metroid (usa) - castellano v1.0.nes",          131088, 0x12767f2e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_metroidc)
STD_ROM_FN(nes_metroidc)

struct BurnDriver BurnDrvnes_metroidc = {
	"nes_metroidc", "nes_metroid", NULL, NULL, "2019",
	"Metroid (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_metroidcRomInfo, nes_metroidcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mighty Final Fight (Hack, Spanish)
// https://www.romhacking.net/translations/2743/
static struct BurnRomInfo nes_mightfinfigcRomDesc[] = {
	{ "mighty final fight (usa) - castellano v1.0.nes",          262160, 0x79b72603, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mightfinfigc)
STD_ROM_FN(nes_mightfinfigc)

struct BurnDriver BurnDrvnes_mightfinfigc = {
	"nes_mightfinfigc", "nes_mightfinfig", NULL, NULL, "2016",
	"Mighty Final Fight (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_mightfinfigcRomInfo, nes_mightfinfigcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Maniac Mansion (Euro)
static struct BurnRomInfo nes_maniacmansioneRomDesc[] = {
	{ "maniac mansion (europe).nes",          262160, 0x90333aea, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_maniacmansione)
STD_ROM_FN(nes_maniacmansione)

struct BurnDriver BurnDrvnes_maniacmansione = {
	"nes_maniacmansione", "nes_maniacmansion", NULL, NULL, "1989",
	"Maniac Mansion (Euro)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_maniacmansioneRomInfo, nes_maniacmansioneRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Maniac Mansion (France)
static struct BurnRomInfo nes_maniacmansionfRomDesc[] = {
	{ "maniac mansion (france).nes",          262160, 0x9118cd29, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_maniacmansionf)
STD_ROM_FN(nes_maniacmansionf)

struct BurnDriver BurnDrvnes_maniacmansionf = {
	"nes_maniacmansionf", "nes_maniacmansion", NULL, NULL, "1989",
	"Maniac Mansion (France)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_maniacmansionfRomInfo, nes_maniacmansionfRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Maniac Mansion (Germany)
static struct BurnRomInfo nes_maniacmansiongRomDesc[] = {
	{ "maniac mansion (germany).nes",          262160, 0x05455e77, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_maniacmansiong)
STD_ROM_FN(nes_maniacmansiong)

struct BurnDriver BurnDrvnes_maniacmansiong = {
	"nes_maniacmansiong", "nes_maniacmansion", NULL, NULL, "1989",
	"Maniac Mansion (Germany)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_maniacmansiongRomInfo, nes_maniacmansiongRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Maniac Mansion (Italy)
static struct BurnRomInfo nes_maniacmansioniRomDesc[] = {
	{ "maniac mansion (italy).nes",          262160, 0xb9fd5255, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_maniacmansioni)
STD_ROM_FN(nes_maniacmansioni)

struct BurnDriver BurnDrvnes_maniacmansioni = {
	"nes_maniacmansioni", "nes_maniacmansion", NULL, NULL, "1989",
	"Maniac Mansion (Italy)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_maniacmansioniRomInfo, nes_maniacmansioniRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Maniac Mansion (Japan)
static struct BurnRomInfo nes_maniacmansionjRomDesc[] = {
	{ "maniac mansion (japan).nes",          262160, 0x101f9604, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_maniacmansionj)
STD_ROM_FN(nes_maniacmansionj)

struct BurnDriver BurnDrvnes_maniacmansionj = {
	"nes_maniacmansionj", "nes_maniacmansion", NULL, NULL, "1989",
	"Maniac Mansion (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_maniacmansionjRomInfo, nes_maniacmansionjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Maniac Mansion (Spain)
static struct BurnRomInfo nes_maniacmansionsRomDesc[] = {
	{ "maniac mansion (spain).nes",          262160, 0x901d691d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_maniacmansions)
STD_ROM_FN(nes_maniacmansions)

struct BurnDriver BurnDrvnes_maniacmansions = {
	"nes_maniacmansions", "nes_maniacmansion", NULL, NULL, "1989",
	"Maniac Mansion (Spain)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_maniacmansionsRomInfo, nes_maniacmansionsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Maniac Mansion (Sweden)
static struct BurnRomInfo nes_maniacmansionswRomDesc[] = {
	{ "maniac mansion (sweden).nes",          262160, 0x5a841cb2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_maniacmansionsw)
STD_ROM_FN(nes_maniacmansionsw)

struct BurnDriver BurnDrvnes_maniacmansionsw = {
	"nes_maniacmansionsw", "nes_maniacmansion", NULL, NULL, "1989",
	"Maniac Mansion (Sweden)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_maniacmansionswRomInfo, nes_maniacmansionswRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Maniac Mansion (USA) (Prototype)
static struct BurnRomInfo nes_maniacmansionuprotoRomDesc[] = {
	{ "maniac mansion (usa) (prototype).nes",          262160, 0xbba3ef7e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_maniacmansionuproto)
STD_ROM_FN(nes_maniacmansionuproto)

struct BurnDriver BurnDrvnes_maniacmansionuproto = {
	"nes_maniacmansionuproto", "nes_maniacmansion", NULL, NULL, "1988",
	"Maniac Mansion (USA) (Prototype)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_PROTOTYPE, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_maniacmansionuprotoRomInfo, nes_maniacmansionuprotoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Maniac Mansion (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_mancmansuprocRomDesc[] = {
	{ "maniac mansion (usa) (prototype) - castellano v1.0.nes",          262160, 0x3be70f25, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mancmansuproc)
STD_ROM_FN(nes_mancmansuproc)

struct BurnDriver BurnDrvnes_mancmansuproc = {
	"nes_mancmansuproc", "nes_maniacmansion", NULL, NULL, "2018",
	"Maniac Mansion (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_PROTOTYPE | BDF_HACK, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_mancmansuprocRomInfo, nes_mancmansuprocRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Nekketsu! Street Basket - Ganbare Dunk Heroes (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_nekkestrbascastcRomDesc[] = {
	{ "nekketsu! street basket - ganbare dunk heroes (japan) - castellano v1.0.nes",          262160, 0x3a2487c3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_nekkestrbascastc)
STD_ROM_FN(nes_nekkestrbascastc)

struct BurnDriver BurnDrvnes_nekkestrbascastc = {
	"nes_nekkestrbascastc", "nes_nekkestrbas", NULL, NULL, "2020",
	"Nekketsu! Street Basket - Ganbare Dunk Heroes (Hack, Spanish)\0", NULL, "Max1323", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_nekkestrbascastcRomInfo, nes_nekkestrbascastcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ninja Gaiden (Hack, Spanish + Addendum)
// https://www.romhacking.net/
static struct BurnRomInfo nes_ninjagaidencRomDesc[] = {
	{ "ninja gaiden (usa) - castellano v1.01.nes",          262160, 0x7da08225, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ninjagaidenc)
STD_ROM_FN(nes_ninjagaidenc)

struct BurnDriver BurnDrvnes_ninjagaidenc = {
	"nes_ninjagaidenc", "nes_ninjagaiden", NULL, NULL, "2016",
	"Ninja Gaiden (Hack, Spanish + Addendum)\0", NULL, "Terwilf", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, nes_ninjagaidencRomInfo, nes_ninjagaidencRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ninja Gaiden II - The Dark Sword of Chaos (Hack, Spanish + Addendum)
// https://www.romhacking.net/
static struct BurnRomInfo nes_ninjagaiiicRomDesc[] = {
	{ "ninja gaiden ii - the dark sword of chaos (usa) - castellano v1.0.nes",          262160, 0x5742d6c0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ninjagaiiic)
STD_ROM_FN(nes_ninjagaiiic)

struct BurnDriver BurnDrvnes_ninjagaiiic = {
	"nes_ninjagaiiic", "nes_ninjagaiii", NULL, NULL, "2016",
	"Ninja Gaiden II - The Dark Sword of Chaos (Hack, Spanish + Addendum)\0", NULL, "Terwilf", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, nes_ninjagaiiicRomInfo, nes_ninjagaiiicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ninja Gaiden III - The Ancient Ship of Doom (Hack, Spanish + Addendum)
// https://www.romhacking.net/
static struct BurnRomInfo nes_ninjagaiiiicRomDesc[] = {
	{ "ninja gaiden iii - the ancient ship of doom (usa) - castellano v1.0.nes",          262160, 0xdfb2692b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ninjagaiiiic)
STD_ROM_FN(nes_ninjagaiiiic)

struct BurnDriver BurnDrvnes_ninjagaiiiic = {
	"nes_ninjagaiiiic", "nes_ninjagaiiii", NULL, NULL, "2016",
	"Ninja Gaiden III - The Ancient Ship of Doom (Hack, Spanish + Addendum)\0", NULL, "Terwilf", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, nes_ninjagaiiiicRomInfo, nes_ninjagaiiiicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// North & South (Hack, Spanish v2.0)
// https://www.romhacking.net/translations/1813/
static struct BurnRomInfo nes_northsouthcRomDesc[] = {
	{ "north & south (usa) - castellano v2.0.nes",          262160, 0x98907558, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_northsouthc)
STD_ROM_FN(nes_northsouthc)

struct BurnDriver BurnDrvnes_northsouthc = {
	"nes_northsouthc", "nes_northsouth", NULL, NULL, "2013",
	"North & South (Hack, Spanish v2.0)\0", NULL, "Julian L.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_ACTION | GBF_STRATEGY, 0,
	NESGetZipName, nes_northsouthcRomInfo, nes_northsouthcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// North & South (USA) - Italian v2.0
// https://www.romhacking.net/translations/1850/
static struct BurnRomInfo nes_northsouthiRomDesc[] = {
	{ "North & South (it) v2.0 (2014)(Julian L.).nes",          262160, 0x155fa336, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_northsouthi)
STD_ROM_FN(nes_northsouthi)

struct BurnDriver BurnDrvnes_northsouthi = {
	"nes_northsouthi", "nes_northsouth", NULL, NULL, "2014",
	"North & South (Hack, Italian v2.0)\0", NULL, "Julian L.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_ACTION | GBF_STRATEGY, 0,
	NESGetZipName, nes_northsouthiRomInfo, nes_northsouthiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Parodius Da! (Hack, Spanish v1.1)
// https://www.romhacking.net/translations/4410/
static struct BurnRomInfo nes_parodiusdacRomDesc[] = {
	{ "parodius da! (japan) - castellano v1.1.nes",          393232, 0x746bb8a8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_parodiusdac)
STD_ROM_FN(nes_parodiusdac)

struct BurnDriver BurnDrvnes_parodiusdac = {
	"nes_parodiusdac", "nes_parodiusda", NULL, NULL, "2018",
	"Parodius Da! (Hack, Spanish v1.1)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_parodiusdacRomInfo, nes_parodiusdacRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// P.O.W. - Prisoners of War (Hack, Spanish v2.0)
// https://www.romhacking.net/translations/2759/
static struct BurnRomInfo nes_powcRomDesc[] = {
	{ "P.O.W. - Prisoners of War T-Spa v2.0 (2022)(Wave).nes",          262160, 0x43c3afd4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_powc)
STD_ROM_FN(nes_powc)

struct BurnDriver BurnDrvnes_powc = {
	"nes_powc", "nes_pow", NULL, NULL, "2022",
	"P.O.W. - Prisoners of War (Hack, Spanish v2.0)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_powcRomInfo, nes_powcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Probotector (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_probotectorcRomDesc[] = {
	{ "probotector (europe) - castellano v1.0.nes",          131088, 0x9e9a6477, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_probotectorc)
STD_ROM_FN(nes_probotectorc)

struct BurnDriver BurnDrvnes_probotectorc = {
	"nes_probotectorc", "nes_contra", NULL, NULL, "2019",
	"Probotector (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_probotectorcRomInfo, nes_probotectorcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Probotector II - Return of the Evil Forces (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_probotectorretcRomDesc[] = {
	{ "probotector ii - return of the evil forces (europe) - castellano v1.0.nes",          262160, 0xf8d46d0b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_probotectorretc)
STD_ROM_FN(nes_probotectorretc)

struct BurnDriver BurnDrvnes_probotectorretc = {
	"nes_probotectorretc", "nes_superc", NULL, NULL, "2019",
	"Probotector II - Return of the Evil Forces (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_probotectorretcRomInfo, nes_probotectorretcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Puyo Puyo (Hack, Spanish v1.1)
// https://www.romhacking.net/translations/5568/
static struct BurnRomInfo nes_puyopuyocRomDesc[] = {
	{ "puyo puyo (japan) - castellano v1.1.nes",          131088, 0xf55b69bd, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_puyopuyoc)
STD_ROM_FN(nes_puyopuyoc)

struct BurnDriver BurnDrvnes_puyopuyoc = {
	"nes_puyopuyoc", "nes_puyopuyo", NULL, NULL, "2020",
	"Puyo Puyo (Hack, Spanish v1.1)\0", NULL, "Max1323", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_puyopuyocRomInfo, nes_puyopuyocRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Prince of Persia (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_princeofpersiacRomDesc[] = {
	{ "prince of persia (usa) - castellano v1.0.nes",          131088, 0x3f11d7a3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_princeofpersiac)
STD_ROM_FN(nes_princeofpersiac)

struct BurnDriver BurnDrvnes_princeofpersiac = {
	"nes_princeofpersiac", "nes_princeofpersia", NULL, NULL, "2019",
	"Prince of Persia (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_princeofpersiacRomInfo, nes_princeofpersiacRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Prince of Persia (Euro)
static struct BurnRomInfo nes_princeofpersiaeRomDesc[] = {
	{ "prince of persia (europe).nes",          131088, 0x84fa4a07, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_princeofpersiae)
STD_ROM_FN(nes_princeofpersiae)

struct BurnDriver BurnDrvnes_princeofpersiae = {
	"nes_princeofpersiae", "nes_princeofpersia", NULL, NULL, "1992",
	"Prince of Persia (Euro)\0", NULL, "Virgin Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_princeofpersiaeRomInfo, nes_princeofpersiaeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Prince of Persia (France)
static struct BurnRomInfo nes_princeofpersiafRomDesc[] = {
	{ "prince of persia (france).nes",          131088, 0xb19a530e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_princeofpersiaf)
STD_ROM_FN(nes_princeofpersiaf)

struct BurnDriver BurnDrvnes_princeofpersiaf = {
	"nes_princeofpersiaf", "nes_princeofpersia", NULL, NULL, "1992",
	"Prince of Persia (France)\0", NULL, "Virgin Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_princeofpersiafRomInfo, nes_princeofpersiafRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Prince of Persia (Germany)
static struct BurnRomInfo nes_princeofpersiagRomDesc[] = {
	{ "Prince of persia (germany).nes",          131088, 0x53a349d4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_princeofpersiag)
STD_ROM_FN(nes_princeofpersiag)

struct BurnDriver BurnDrvnes_princeofpersiag = {
	"nes_princeofpersiag", "nes_princeofpersia", NULL, NULL, "1992",
	"Prince of Persia (Germany)\0", NULL, "Virgin Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_princeofpersiagRomInfo, nes_princeofpersiagRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Prince of Persia (Russia)
static struct BurnRomInfo nes_princeofpersiarRomDesc[] = {
	{ "prince of persia (russia).nes",          131088, 0x094e6961, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_princeofpersiar)
STD_ROM_FN(nes_princeofpersiar)

struct BurnDriver BurnDrvnes_princeofpersiar = {
	"nes_princeofpersiar", "nes_princeofpersia", NULL, NULL, "1994",
	"Prince of Persia (Russia)\0", NULL, "Virgin Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_princeofpersiarRomInfo, nes_princeofpersiarRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Prince of Persia (Spain)
static struct BurnRomInfo nes_princeofpersiasRomDesc[] = {
	{ "prince of persia (spain).nes",          131088, 0x7817051a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_princeofpersias)
STD_ROM_FN(nes_princeofpersias)

struct BurnDriver BurnDrvnes_princeofpersias = {
	"nes_princeofpersias", "nes_princeofpersia", NULL, NULL, "1992",
	"Prince of Persia (Spain)\0", NULL, "Virgin Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_princeofpersiasRomInfo, nes_princeofpersiasRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rambo (Hack, Spanish)
// https://www.romhacking.net/translations/4077/
static struct BurnRomInfo nes_rambocRomDesc[] = {
	{ "rambo (usa) (rev 1) - castellano v1.0.nes",          131088, 0xf28cc969, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ramboc)
STD_ROM_FN(nes_ramboc)

struct BurnDriver BurnDrvnes_ramboc = {
	"nes_ramboc", "nes_rambo", NULL, NULL, "2018",
	"Rambo (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_rambocRomInfo, nes_rambocRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Renegade (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_renegadecRomDesc[] = {
	{ "renegade (usa) - castellano v1.0.nes",          131088, 0xacac361a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_renegadec)
STD_ROM_FN(nes_renegadec)

struct BurnDriver BurnDrvnes_renegadec = {
	"nes_renegadec", "nes_renegade", NULL, NULL, "2017",
	"Renegade (Hack, Spanish)\0", NULL, "JonnyVilla2088", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_renegadecRomInfo, nes_renegadecRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rescue - The Embassy Mission (Hack, Spanish)
// https://www.romhacking.net/translations/4016/
static struct BurnRomInfo nes_rescuecRomDesc[] = {
	{ "rescue - the embassy mission (usa) - castellano v1.0.nes",          262160, 0xab441e08, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rescuec)
STD_ROM_FN(nes_rescuec)

struct BurnDriver BurnDrvnes_rescuec = {
	"nes_rescuec", "nes_rescue", NULL, NULL, "2018",
	"Rescue - The Embassy Mission (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_SHOOT | GBF_ADV, 0,
	NESGetZipName, nes_rescuecRomInfo, nes_rescuecRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// RoboCop (Hack, Spanish v0.91)
// https://www.romhacking.net/translations/2710/
static struct BurnRomInfo nes_robocopcRomDesc[] = {
	{ "robocop (usa) - castellano v0.91.nes",          262160, 0x0f97e1e8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_robocopc)
STD_ROM_FN(nes_robocopc)

struct BurnDriver BurnDrvnes_robocopc = {
	"nes_robocopc", "nes_robocop", NULL, NULL, "2016",
	"RoboCop (Hack, Spanish v0.91)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_robocopcRomInfo, nes_robocopcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// RoboCop 2 (Hack, Spanish v2.0)
// https://www.romhacking.net/translations/2686/
static struct BurnRomInfo nes_robocop2cRomDesc[] = {
	{ "RoboCop 2 T-Spa v2.0 (2022)(Wave).nes",          262160, 0x2fcfdd26, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_robocop2c)
STD_ROM_FN(nes_robocop2c)

struct BurnDriver BurnDrvnes_robocop2c = {
	"nes_robocop2c", "nes_robocop2", NULL, NULL, "2022",
	"RoboCop 2 (Hack, Spanish v2.0)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_robocop2cRomInfo, nes_robocop2cRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Robocop 3 (Hack, Spanish v2.0)
// https://www.romhacking.net/translations/2698/
static struct BurnRomInfo nes_robocop3cRomDesc[] = {
	{ "RoboCop 3 T-Spa v2.0 (2022)(Wave).nes",          262160, 0xc297afad, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_robocop3c)
STD_ROM_FN(nes_robocop3c)

struct BurnDriver BurnDrvnes_robocop3c = {
	"nes_robocop3c", "nes_robocop3", NULL, NULL, "2022",
	"Robocop 3 (Hack, Spanish v2.0)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_robocop3cRomInfo, nes_robocop3cRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Romancia (Hack, Spanish)
// https://www.romhacking.net/translations/7134/
static struct BurnRomInfo nes_romanciasRomDesc[] = {
	{ "Romancia T-Spa (2023)(Max1323).nes",          131088, 0x4befb4a7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_romancias)
STD_ROM_FN(nes_romancias)

struct BurnDriver BurnDrvnes_romancias = {
	"nes_romancias", "nes_romancia", NULL, NULL, "2023",
	"Romancia (Hack, Spanish)\0", NULL, "Max1323", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_romanciasRomInfo, nes_romanciasRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rush'n Attack (Hack, Spanish v1.1)
// https://www.romhacking.net/translations/3369/
static struct BurnRomInfo nes_rushnattackcRomDesc[] = {
	{ "rush'n attack (usa) - castellano v1.1.nes",          131088, 0xb6bdb5e5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rushnattackc)
STD_ROM_FN(nes_rushnattackc)

struct BurnDriver BurnDrvnes_rushnattackc = {
	"nes_rushnattackc", "nes_rushnattack", NULL, NULL, "2021",
	"Rush'n Attack (Hack, Spanish v1.1)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_rushnattackcRomInfo, nes_rushnattackcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Smash T.V. (Hack, Spanish)
// https://www.romhacking.net/translations/4876/
static struct BurnRomInfo nes_smashtvcRomDesc[] = {
	{ "smash t.v. (usa) - castellano v1.0.nes",          262160, 0x658cbecc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_smashtvc)
STD_ROM_FN(nes_smashtvc)

struct BurnDriver BurnDrvnes_smashtvc = {
	"nes_smashtvc", "nes_smashtv", NULL, NULL, "2019",
	"Smash T.V. (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_smashtvcRomInfo, nes_smashtvcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Snake's Revenge (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_snakesrevengecRomDesc[] = {
	{ "snake's revenge (usa) - castellano v1.0.nes",          262160, 0x3d4a2507, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_snakesrevengec)
STD_ROM_FN(nes_snakesrevengec)

struct BurnDriver BurnDrvnes_snakesrevengec = {
	"nes_snakesrevengec", "nes_snakesrevenge", NULL, NULL, "2018",
	"Snake's Revenge (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_ADV, 0,
	NESGetZipName, nes_snakesrevengecRomInfo, nes_snakesrevengecRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Snow Brothers (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_snowbrotherscRomDesc[] = {
	{ "snow brothers (usa) - castellano v1.0.nes",          262160, 0x29c40f70, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_snowbrothersc)
STD_ROM_FN(nes_snowbrothersc)

struct BurnDriver BurnDrvnes_snowbrothersc = {
	"nes_snowbrothersc", "nes_snowbrothers", NULL, NULL, "2018",
	"Snow Brothers (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_snowbrotherscRomInfo, nes_snowbrotherscRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Spy Vs Spy (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_spyvsspycRomDesc[] = {
	{ "spy vs spy (usa) - castellano v1.0.nes",          40976, 0x0c4a3d91, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_spyvsspyc)
STD_ROM_FN(nes_spyvsspyc)

struct BurnDriver BurnDrvnes_spyvsspyc = {
	"nes_spyvsspyc", "nes_spyvsspy", NULL, NULL, "2019",
	"Spy Vs Spy (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_ACTION | GBF_STRATEGY, 0,
	NESGetZipName, nes_spyvsspycRomInfo, nes_spyvsspycRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Star Wars (Namco) (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_starwarsjcRomDesc[] = {
	{ "star wars (japan) (namco) - castellano v1.0.nes",          262160, 0xeef6974a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_starwarsjc)
STD_ROM_FN(nes_starwarsjc)

struct BurnDriver BurnDrvnes_starwarsjc = {
	"nes_starwarsjc", "nes_starwars", NULL, NULL, "2017",
	"Star Wars (Namco) (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_starwarsjcRomInfo, nes_starwarsjcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Star Wars (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_starwarscRomDesc[] = {
	{ "star wars (usa) - castellano v1.0.nes",          262160, 0x0e6e000c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_starwarsc)
STD_ROM_FN(nes_starwarsc)

struct BurnDriver BurnDrvnes_starwarsc = {
	"nes_starwarsc", "nes_starwars", NULL, NULL, "2019",
	"Star Wars (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_starwarscRomInfo, nes_starwarscRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Street Fighter 2010 - The Final Fight (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_streefig201cRomDesc[] = {
	{ "street fighter 2010 - the final fight (usa) - castellano v1.0.nes",          262160, 0x0c963bf7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_streefig201c)
STD_ROM_FN(nes_streefig201c)

struct BurnDriver BurnDrvnes_streefig201c = {
	"nes_streefig201c", "nes_streefig201", NULL, NULL, "2017",
	"Street Fighter 2010 - The Final Fight (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_streefig201cRomInfo, nes_streefig201cRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Street Fighter II - The World Warrior (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_streefigiicRomDesc[] = {
	{ "street fighter ii - the world warrior (unl) - castellano v1.0.nes",          262160, 0x3861489, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_streefigiic)
STD_ROM_FN(nes_streefigiic)

struct BurnDriver BurnDrvnes_streefigiic = {
	"nes_streefigiic", "nes_streefigii", NULL, NULL, "201?",
	"Street Fighter II - The World Warrior (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_streefigiicRomInfo, nes_streefigiicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Mario Bros. (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_smbcRomDesc[] = {
	{ "super mario bros. (world) - castellano v1.0.nes",          40976, 0x54de5344, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_smbc)
STD_ROM_FN(nes_smbc)

struct BurnDriver BurnDrvnes_smbc = {
	"nes_smbc", "nes_smb", NULL, NULL, "2018",
	"Super Mario Bros. (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_smbcRomInfo, nes_smbcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Mario Bros. 2 (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_smb2cRomDesc[] = {
	{ "super mario bros. 2 (usa) (rev 1) - castellano v1.0.nes",          262160, 0x36114415, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_smb2c)
STD_ROM_FN(nes_smb2c)

struct BurnDriver BurnDrvnes_smb2c = {
	"nes_smb2c", "nes_smb2", NULL, NULL, "2017",
	"Super Mario Bros. 2 (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_smb2cRomInfo, nes_smb2cRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Mario Bros. 3 (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_smb3castRomDesc[] = {
	{ "super mario bros. 3 (usa) (rev 1) - castellano v1.0.nes",          393232, 0x2e094f49, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_smb3cast)
STD_ROM_FN(nes_smb3cast)

struct BurnDriver BurnDrvnes_smb3cast = {
	"nes_smb3cast", "nes_smb3", NULL, NULL, "2018",
	"Super Mario Bros. 3 (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_smb3castRomInfo, nes_smb3castRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Sword Master (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_swordmastercRomDesc[] = {
	{ "sword master (usa) - castellano v1.0.nes",          262160, 0x0f7fcbaf, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_swordmasterc)
STD_ROM_FN(nes_swordmasterc)

struct BurnDriver BurnDrvnes_swordmasterc = {
	"nes_swordmasterc", "nes_swordmaster", NULL, NULL, "2019",
	"Sword Master (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_swordmastercRomInfo, nes_swordmastercRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Target Renegade (Hack, Spanish)
// https://www.romhacking.net/translations/3041/
static struct BurnRomInfo nes_targetrenegadecRomDesc[] = {
	{ "target - renegade (usa) - castellano v1.0.nes",          262160, 0x6754acae, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_targetrenegadec)
STD_ROM_FN(nes_targetrenegadec)

struct BurnDriver BurnDrvnes_targetrenegadec = {
	"nes_targetrenegadec", "nes_targetrenegade", NULL, NULL, "2017",
	"Target Renegade (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_targetrenegadecRomInfo, nes_targetrenegadecRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tashiro Masashi no Princess ga Ippai (Hack, Spanish)
// https://www.romhacking.net/translations/6659/
static struct BurnRomInfo nes_tashimasnoprigaipsRomDesc[] = {
	{ "Tashiro Masashi no Princess ga Ippai T-Spa (2021)(Wave).nes",          262160, 0x2e4c79be, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tashimasnoprigaips)
STD_ROM_FN(nes_tashimasnoprigaips)

struct BurnDriver BurnDrvnes_tashimasnoprigaips = {
	"nes_tashimasnoprigaips", "nes_tashimasnoprigaip", NULL, NULL, "2021",
	"Tashiro Masashi no Princess ga Ippai (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_tashimasnoprigaipsRomInfo, nes_tashimasnoprigaipsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Teenage Mutant Ninja Turtles - Tournament Fighters (Hack, Spanish)
// https://www.romhacking.net/translations/2826/
static struct BurnRomInfo nes_tmnttoufigcRomDesc[] = {
	{ "teenage mutant ninja turtles - tournament fighters (usa) - castellano v1.0.nes",          262160, 0x32eac8c5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tmnttoufigc)
STD_ROM_FN(nes_tmnttoufigc)

struct BurnDriver BurnDrvnes_tmnttoufigc = {
	"nes_tmnttoufigc", "nes_tmnttoufig", NULL, NULL, "2020",
	"Teenage Mutant Ninja Turtles - Tournament Fighters (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_tmnttoufigcRomInfo, nes_tmnttoufigcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Teenage Mutant Ninja Turtles (Hack, Spanish v0.9)
// https://www.romhacking.net/
static struct BurnRomInfo nes_tmntcastRomDesc[] = {
	{ "teenage mutant ninja turtles (usa) - castellano v0.9.nes",          262160, 0x30cd0997, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tmntcast)
STD_ROM_FN(nes_tmntcast)

struct BurnDriver BurnDrvnes_tmntcast = {
	"nes_tmntcast", "nes_tmnt", NULL, NULL, "2016",
	"Teenage Mutant Ninja Turtles (Hack, Spanish v0.9)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_tmntcastRomInfo, nes_tmntcastRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Teenage Mutant Ninja Turtles II - The Arcade Game (Hack, Spanish v0.9)
// https://www.romhacking.net/
static struct BurnRomInfo nes_tmntiiarcgamcRomDesc[] = {
	{ "teenage mutant ninja turtles ii - the arcade game (usa) - castellano v0.9.nes",          524304, 0xb83bcec8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tmntiiarcgamc)
STD_ROM_FN(nes_tmntiiarcgamc)

struct BurnDriver BurnDrvnes_tmntiiarcgamc = {
	"nes_tmntiiarcgamc", "nes_tmntiiarcgam", NULL, NULL, "2016",
	"Teenage Mutant Ninja Turtles II - The Arcade Game (Hack, Spanish v0.9)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_tmntiiarcgamcRomInfo, nes_tmntiiarcgamcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Teenage Mutant Ninja Turtles III - The Manhattan Project (Hack, Spanish v0.91)
// https://www.romhacking.net/
static struct BurnRomInfo nes_tmntiiicRomDesc[] = {
	{ "teenage mutant ninja turtles iii - the manhattan project (usa) - castellano v0.91.nes",          524304, 0x3e9ddb5c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tmntiiic)
STD_ROM_FN(nes_tmntiiic)

struct BurnDriver BurnDrvnes_tmntiiic = {
	"nes_tmntiiic", "nes_tmntiii", NULL, NULL, "2017",
	"Teenage Mutant Ninja Turtles III - The Manhattan Project (Hack, Spanish v0.91)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_tmntiiicRomInfo, nes_tmntiiicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Terminator 2 - Judgment Day (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_termi2cRomDesc[] = {
	{ "terminator 2 - judgment day (usa) - castellano v1.0.nes",          262160, 0x43d08e31, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_termi2c)
STD_ROM_FN(nes_termi2c)

struct BurnDriver BurnDrvnes_termi2c = {
	"nes_termi2c", "nes_termi2", NULL, NULL, "2016",
	"Terminator 2 - Judgment Day (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_RUNGUN, 0,
	NESGetZipName, nes_termi2cRomInfo, nes_termi2cRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Thexder (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_thexdercRomDesc[] = {
	{ "Thexder (japan) - castellano v1.0.nes",          40976, 0x52ac30c1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_thexderc)
STD_ROM_FN(nes_thexderc)

struct BurnDriver BurnDrvnes_thexderc = {
	"nes_thexderc", "nes_thexder", NULL, NULL, "2019",
	"Thexder (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_thexdercRomInfo, nes_thexdercRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Time Zone (Hack, Spanish)
// https://www.romhacking.net/translations/3108/
static struct BurnRomInfo nes_timezonesRomDesc[] = {
	{ "Time Zone T-Spa (2017)(Wave).nes",          262160, 0x43154f18, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_timezones)
STD_ROM_FN(nes_timezones)

struct BurnDriver BurnDrvnes_timezones = {
	"nes_timezones", "nes_timezone", NULL, NULL, "2017",
	"Time Zone (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_timezonesRomInfo, nes_timezonesRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tiny Toon Adventures (Hack, Spanish)
// https://www.romhacking.net/translations/5168/
static struct BurnRomInfo nes_tinytooadvcRomDesc[] = {
	{ "Tiny Toon Adventures T-Spa (2019)(Wave).nes",          262160, 0xbcd94fa2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tinytooadvc)
STD_ROM_FN(nes_tinytooadvc)

struct BurnDriver BurnDrvnes_tinytooadvc = {
	"nes_tinytooadvc", "nes_tinytooadv", NULL, NULL, "2019",
	"Tiny Toon Adventures (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_tinytooadvcRomInfo, nes_tinytooadvcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tiny Toon Adventures 6 (Hack, Spanish)
// https://www.romhacking.net/translations/3513/
static struct BurnRomInfo nes_tinytooadv6cRomDesc[] = {
	{ "Tiny Toon Adventures 6 T-Spa (2018)(Wave).nes",          524304, 0x93db8d83, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tinytooadv6c)
STD_ROM_FN(nes_tinytooadv6c)

struct BurnDriver BurnDrvnes_tinytooadv6c = {
	"nes_tinytooadv6c", "nes_tinytooadv6", NULL, NULL, "2018",
	"Tiny Toon Adventures 6 (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_tinytooadv6cRomInfo, nes_tinytooadv6cRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tom & Jerry - The Ultimate Game of Cat and Mouse! (Hack, Spanish)
// https://www.romhacking.net/translations/3714/
static struct BurnRomInfo nes_tomjerultgamcatandmcRomDesc[] = {
	{ "Tom & Jerry - The Ultimate Game of Cat and Mouse! T-Spa (2018)(Wave).nes",          262160, 0x9c6a9bcc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tomjerultgamcatandmc)
STD_ROM_FN(nes_tomjerultgamcatandmc)

struct BurnDriver BurnDrvnes_tomjerultgamcatandmc = {
	"nes_tomjerultgamcatandmc", "nes_tomjerultgamcatandm", NULL, NULL, "2018",
	"Tom & Jerry - The Ultimate Game of Cat and Mouse! (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_tomjerultgamcatandmcRomInfo, nes_tomjerultgamcatandmcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Top Gun - The Second Mission (Hack, Spanish)
// https://www.romhacking.net/translations/4809/
static struct BurnRomInfo nes_topgunsecmiscRomDesc[] = {
	{ "Top Gun - The Second Mission T-Spa (2019)(Wave).nes",          262160, 0x350f534b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_topgunsecmisc)
STD_ROM_FN(nes_topgunsecmisc)

struct BurnDriver BurnDrvnes_topgunsecmisc = {
	"nes_topgunsecmisc", "nes_topgunsecmis", NULL, NULL, "2019",
	"Top Gun - The Second Mission (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_SIM | GBF_SHOOT, 0,
	NESGetZipName, nes_topgunsecmiscRomInfo, nes_topgunsecmiscRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Top Gun (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_topguncRomDesc[] = {
	{ "top gun (usa) (rev 1) - castellano v1.0.nes",          131088, 0x879481af, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_topgunc)
STD_ROM_FN(nes_topgunc)

struct BurnDriver BurnDrvnes_topgunc = {
	"nes_topgunc", "nes_topgun", NULL, NULL, "2019",
	"Top Gun (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_SIM | GBF_SHOOT, 0,
	NESGetZipName, nes_topguncRomInfo, nes_topguncRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};							

// Total Recall (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_totalrecallcRomDesc[] = {
	{ "Total Recall (USA) - Castellano v1.0.nes",          131088, 0x93a02a67, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_totalrecallc)
STD_ROM_FN(nes_totalrecallc)

struct BurnDriver BurnDrvnes_totalrecallc = {
	"nes_totalrecallc", "nes_totalrecall", NULL, NULL, "2019",
	"Total Recall (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_totalrecallcRomInfo, nes_totalrecallcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Uncanny X-Men, The (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_uncanxmencRomDesc[] = {
	{ "uncanny x-men, the (usa) - castellano v1.0.nes",          131088, 0x21a9db24, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_uncanxmenc)
STD_ROM_FN(nes_uncanxmenc)

struct BurnDriver BurnDrvnes_uncanxmenc = {
	"nes_uncanxmenc", "nes_uncanxmen", NULL, NULL, "2019",
	"Uncanny X-Men, The (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_uncanxmencRomInfo, nes_uncanxmencRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Valkyrie no Bouken - Toki no Kagi Densetsu (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_valkynoboucRomDesc[] = {
	{ "valkyrie no bouken - toki no kagi densetsu (japan) - castellano v1.0.nes",          65552, 0x9e222fab, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_valkynobouc)
STD_ROM_FN(nes_valkynobouc)

struct BurnDriver BurnDrvnes_valkynobouc = {
	"nes_valkynobouc", "nes_valkynobou", NULL, NULL, "2019",
	"Valkyrie no Bouken - Toki no Kagi Densetsu (Hack, Spanish)\0", NULL, "Max1323", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_valkynoboucRomInfo, nes_valkynoboucRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wizards & Warriors III - Kuros - Visions of Power (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_wizarwariiicRomDesc[] = {
	{ "wizards & warriors iii - kuros - visions of power (usa) - castellano v1.0.nes",          262160, 0x7135c442, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_wizarwariiic)
STD_ROM_FN(nes_wizarwariiic)

struct BurnDriver BurnDrvnes_wizarwariiic = {
	"nes_wizarwariiic", "nes_wizarwariii", NULL, NULL, "2020",
	"Wizards & Warriors III - Kuros - Visions of Power (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_wizarwariiicRomInfo, nes_wizarwariiicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wolverine (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_wolverinecRomDesc[] = {
	{ "wolverine (usa) - castellano v1.0.nes",          262160, 0xdb5ee5cb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_wolverinec)
STD_ROM_FN(nes_wolverinec)

struct BurnDriver BurnDrvnes_wolverinec = {
	"nes_wolverinec", "nes_wolverine", NULL, NULL, "2019",
	"Wolverine (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_wolverinecRomInfo, nes_wolverinecRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Yie Ar Kung-Fu (V1.4) (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_yiearkungfucRomDesc[] = {
	{ "yie ar kung-fu (japan) (v1.4) - castellano v1.0.nes",          24592, 0x032019a7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_yiearkungfuc)
STD_ROM_FN(nes_yiearkungfuc)

struct BurnDriver BurnDrvnes_yiearkungfuc = {
	"nes_yiearkungfuc", "nes_yiearkungfu", NULL, NULL, "2019",
	"Yie Ar Kung-Fu (V1.4) (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_yiearkungfucRomInfo, nes_yiearkungfucRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ys (Hack, Spanish v1.1)
// https://www.romhacking.net/
static struct BurnRomInfo nes_yscRomDesc[] = {
	{ "ys (japan) - castellano v1.1.nes",          262160, 0x024dd1cf, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ysc)
STD_ROM_FN(nes_ysc)

struct BurnDriver BurnDrvnes_ysc = {
	"nes_ysc", "nes_ys", NULL, NULL, "2017",
	"Ys (Hack, Spanish v1.1)\0", NULL, "Takkun57", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_yscRomInfo, nes_yscRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ys II - Ancient Ys Vanished - The Final Chapter (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_ysiicRomDesc[] = {
	{ "ys ii - ancient ys vanished - the final chapter (japan) - castellano v1.0.nes",          393232, 0x20770bf0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ysiic)
STD_ROM_FN(nes_ysiic)

struct BurnDriver BurnDrvnes_ysiic = {
	"nes_ysiic", "nes_ysii", NULL, NULL, "2017",
	"Ys II - Ancient Ys Vanished - The Final Chapter (Hack, Spanish)\0", NULL, "Takkun57", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_ysiicRomInfo, nes_ysiicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};	

// Zelda II - The Adventure of Link (Rev 2) (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_zeldaiicRomDesc[] = {
	{ "zelda ii - the adventure of link (europe) (rev 2) - castellano v1.0.nes",          262160, 0xd31d09ae, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_zeldaiic)
STD_ROM_FN(nes_zeldaiic)

struct BurnDriver BurnDrvnes_zeldaiic = {
	"nes_zeldaiic", "nes_zeldaii", NULL, NULL, "2016",
	"Zelda II - The Adventure of Link (Rev 2) (Hack, Spanish)\0", NULL, "jackic", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_zeldaiicRomInfo, nes_zeldaiicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Zelda II Redux - The Adventure of Link (Hack, v3.0)
// https://www.romhacking.net/hacks/5440/
static struct BurnRomInfo nes_zeldaiirdRomDesc[] = {
	{ "Zelda II - The Adventure of Link Redux v3.0 (2022)(ShadowOne333).nes",          262160, 0xf4bdec40, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_zeldaiird)
STD_ROM_FN(nes_zeldaiird)

struct BurnDriver BurnDrvnes_zeldaiird = {
	"nes_zeldaiird", "nes_zeldaii", NULL, NULL, "2022",
	"Zelda II Redux - The Adventure of Link (Hack, v3.0)\0", NULL, "ShadowOne333", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_zeldaiirdRomInfo, nes_zeldaiirdRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Adventure Island IV (Hack, Spanish)
// https://www.romhacking.net/translations/2824/
static struct BurnRomInfo nes_advenislivcRomDesc[] = {
	{ "Adventure Island IV T-Spa (2016)(Wave).nes",          393232, 0x9ba3eb86, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_advenislivc)
STD_ROM_FN(nes_advenislivc)

struct BurnDriver BurnDrvnes_advenislivc = {
	"nes_advenislivc", "nes_advenisliv", NULL, NULL, "2016",
	"Adventure Island IV (Hack, Spanish)\0", NULL, "Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_advenislivcRomInfo, nes_advenislivcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ganbare Goemon Gaiden - Kieta Ougon Kiseru (Hack, Spanish v0.99)
// https://www.romhacking.net/
static struct BurnRomInfo nes_ganbagoegaicRomDesc[] = {
	{ "ganbare goemon gaiden - kieta ougon kiseru (japan) - castellano v0.99.nes",          524304, 0x90ac0bda, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ganbagoegaic)
STD_ROM_FN(nes_ganbagoegaic)

struct BurnDriver BurnDrvnes_ganbagoegaic = {
	"nes_ganbagoegaic", "nes_ganbagoegai", NULL, NULL, "2021",
	"Ganbare Goemon Gaiden - Kieta Ougon Kiseru (Hack, Spanish v0.99)\0", NULL, "jackic", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_ganbagoegaicRomInfo, nes_ganbagoegaicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// SD Battle Oozumou - Heisei Hero Basho (Japan)
static struct BurnRomInfo nes_sdbttloozumouRomDesc[] = {
	{ "sd battle oozumou - heisei hero basho (japan).nes",          262160, 0xcd1931de, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sdbttloozumou)
STD_ROM_FN(nes_sdbttloozumou)

struct BurnDriver BurnDrvnes_sdbttloozumou = {
	"nes_sdbttloozumou", NULL, NULL, NULL, "1990",
	"SD Battle Oozumou - Heisei Hero Basho (Japan)\0", NULL, "Banpresto", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_sdbttloozumouRomInfo, nes_sdbttloozumouRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};								

// SD Gundam - Gachapon Senshi 2 - Capsule Senki (Japan)
static struct BurnRomInfo nes_sdgundgs2RomDesc[] = {
	{ "sd gundam - gachapon senshi 2 - capsule senki (japan).nes",          262160, 0x88641b52, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sdgundgs2)
STD_ROM_FN(nes_sdgundgs2)

struct BurnDriver BurnDrvnes_sdgundgs2 = {
	"nes_sdgundgs2", NULL, NULL, NULL, "1989",
	"SD Gundam - Gachapon Senshi 2 - Capsule Senki (Japan)\0", NULL, "Bandai Shinsei", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_sdgundgs2RomInfo, nes_sdgundgs2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// SD Gundam - Gachapon Senshi 2 - Capsule Senki (Hack, Spanish)
static struct BurnRomInfo nes_sdgundgs2cRomDesc[] = {
	{ "sd gundam - gachapon senshi 2 - capsule senki (japan) - castellano v1.0.nes",          262160, 0x86274ffd, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sdgundgs2c)
STD_ROM_FN(nes_sdgundgs2c)

struct BurnDriver BurnDrvnes_sdgundgs2c = {
	"nes_sdgundgs2c", "nes_sdgundgs2", NULL, NULL, "2020",
	"SD Gundam - Gachapon Senshi 2 - Capsule Senki (Hack, Spanish)\0", NULL, "Max1323", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_sdgundgs2cRomInfo, nes_sdgundgs2cRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// SD Gundam - Gachapon Senshi 3 - Eiyuu Senki (Japan)
static struct BurnRomInfo nes_sdgundgs3RomDesc[] = {
	{ "sd gundam - gachapon senshi 3 - eiyuu senki (japan).nes",          262160, 0x3af5beff, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sdgundgs3)
STD_ROM_FN(nes_sdgundgs3)

struct BurnDriver BurnDrvnes_sdgundgs3 = {
	"nes_sdgundgs3", NULL, NULL, NULL, "1990",
	"SD Gundam - Gachapon Senshi 3 - Eiyuu Senki (Japan)\0", NULL, "Yutaka", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_sdgundgs3RomInfo, nes_sdgundgs3RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};						

// SD Gundam - Gachapon Senshi 4 - New Type Story (Japan)
static struct BurnRomInfo nes_sdgundgs4RomDesc[] = {
	{ "sd gundam - gachapon senshi 4 - new type story (japan).nes",          524304, 0x078b916e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sdgundgs4)
STD_ROM_FN(nes_sdgundgs4)

struct BurnDriver BurnDrvnes_sdgundgs4 = {
	"nes_sdgundgs4", NULL, NULL, NULL, "1991",
	"SD Gundam - Gachapon Senshi 4 - New Type Story (Japan)\0", NULL, "Yutaka", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 3, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_sdgundgs4RomInfo, nes_sdgundgs4RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// SD Gundam - Gachapon Senshi 5 - Battle of Universal Century (Japan)
static struct BurnRomInfo nes_sdgachapon5RomDesc[] = {
	{ "sd gundam - gachapon senshi 5 - battle of universal century (japan).nes",          262160, 0x971d0527, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sdgachapon5)
STD_ROM_FN(nes_sdgachapon5)

struct BurnDriver BurnDrvnes_sdgachapon5 = {
	"nes_sdgachapon5", NULL, NULL, NULL, "1992",
	"SD Gundam - Gachapon Senshi 5 - Battle of Universal Century (Japan)\0", NULL, "Yutaka", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_sdgachapon5RomInfo, nes_sdgachapon5RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// SD Gundam Gaiden - Knight Gundam Monogatari (Hack, English)
static struct BurnRomInfo nes_sdgunkgmRomDesc[] = {
	{ "sd gundam gaiden - knight gundam monogatari (japan) (v1.0) (t-eng).nes",          393232, 0x2c91773e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sdgunkgm)
STD_ROM_FN(nes_sdgunkgm)

struct BurnDriver BurnDrvnes_sdgunkgm = {
	"nes_sdgunkgm", NULL, NULL, NULL, "2020",
	"SD Gundam Gaiden - Knight Gundam Monogatari (Hack, English)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_sdgunkgmRomInfo, nes_sdgunkgmRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// SD Gundam Gaiden - Knight Gundam Monogatari (Japan, v1.1)
static struct BurnRomInfo nes_sdgunkgmjRomDesc[] = {
	{ "sd gundam gaiden - knight gundam monogatari (japan) (v1.1).nes",          393232, 0xb6cafb31, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sdgunkgmj)
STD_ROM_FN(nes_sdgunkgmj)

struct BurnDriver BurnDrvnes_sdgunkgmj = {
	"nes_sdgunkgmj", "nes_sdgunkgm", NULL, NULL, "1990",
	"SD Gundam Gaiden - Knight Gundam Monogatari (Japan, v1.1)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_sdgunkgmjRomInfo, nes_sdgunkgmjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// SD Gundam Gaiden - Knight Gundam Monogatari 2 - Hikari no Kishi (Japan)
static struct BurnRomInfo nes_sdgunkgm2RomDesc[] = {
	{ "sd gundam gaiden - knight gundam monogatari 2 - hikari no kishi (japan).nes",          524304, 0x0c1319dd, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sdgunkgm2)
STD_ROM_FN(nes_sdgunkgm2)

struct BurnDriver BurnDrvnes_sdgunkgm2 = {
	"nes_sdgunkgm2", NULL, NULL, NULL, "1991",
	"SD Gundam Gaiden - Knight Gundam Monogatari 2 - Hikari no Kishi (Japan)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_sdgunkgm2RomInfo, nes_sdgunkgm2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// SD Gundam Gaiden - Knight Gundam Monogatari 3 - Densetsu no Kishi Dan (Japan)
static struct BurnRomInfo nes_sdgunkgm3RomDesc[] = {
	{ "sd gundam gaiden - knight gundam monogatari 3 - densetsu no kishi dan (japan).nes",          524304, 0xf02a0aab, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sdgunkgm3)
STD_ROM_FN(nes_sdgunkgm3)

struct BurnDriver BurnDrvnes_sdgunkgm3 = {
	"nes_sdgunkgm3", NULL, NULL, NULL, "1992",
	"SD Gundam Gaiden - Knight Gundam Monogatari 3 - Densetsu no Kishi Dan (Japan)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_sdgunkgm3RomInfo, nes_sdgunkgm3RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// SD Hero Soukessen - Taose! Aku no Gundan (Japan)
static struct BurnRomInfo nes_sdhstangRomDesc[] = {
	{ "SD Hero Soukessen - Taose! Aku no Gundan (Japan).nes",          262160, 0xf17fefdd, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sdhstang)
STD_ROM_FN(nes_sdhstang)

struct BurnDriver BurnDrvnes_sdhstang = {
	"nes_sdhstang", NULL, NULL, NULL, "1990",
	"SD Hero Soukessen - Taose! Aku no Gundan (Japan)\0", NULL, "Banpresto", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_sdhstangRomInfo, nes_sdhstangRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// SD Hero Soukessen - Taose! Aku no Gundan (Hack, Spanish v1.0)
// https://www.romhacking.net/
static struct BurnRomInfo nes_sdhstangcRomDesc[] = {
	{ "sd hero soukessen - taose! aku no gundan (japan) - castellano v1.0.nes",          262160, 0x7c0a15a4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sdhstangc)
STD_ROM_FN(nes_sdhstangc)

struct BurnDriver BurnDrvnes_sdhstangc = {
	"nes_sdhstangc", "nes_sdhstang", NULL, NULL, "2020",
	"SD Hero Soukessen - Taose! Aku no Gundan (Hack, Spanish v1.0)\0", NULL, "Max1323", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_sdhstangcRomInfo, nes_sdhstangcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// SD Keiji - Blader (Hack, English)
static struct BurnRomInfo nes_sdkbladeRomDesc[] = {
	{ "sd keiji - blader (japan) [t-eng].nes",          393232, 0x1fa8a57d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sdkblade)
STD_ROM_FN(nes_sdkblade)

struct BurnDriverD BurnDrvnes_sdkblade = {
	"nes_sdkblade", NULL, NULL, NULL, "2021",
	"SD Keiji - Blader (Hack, English)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_sdkbladeRomInfo, nes_sdkbladeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// SD Keiji - Blader (Japan)
static struct BurnRomInfo nes_sdkbladejRomDesc[] = {
	{ "sd keiji - blader (japan).nes",          262160, 0x452c373c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sdkbladej)
STD_ROM_FN(nes_sdkbladej)

struct BurnDriverD BurnDrvnes_sdkbladej = {
	"nes_sdkbladej", "nes_sdkblade", NULL, NULL, "1991",
	"SD Keiji - Blader (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_sdkbladejRomInfo, nes_sdkbladejRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// SD Gundam World - Gachapon Senshi - Scramble Wars (Hack, Spanish)
static struct BurnRomInfo fds_sdgunworgacsescwacRomDesc[] = {
	{ "sd gundam world - gachapon senshi - scramble wars (japan) [b] - castellano v1.0.fds",          131016, 0x53f73319, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_sdgunworgacsescwac, fds_sdgunworgacsescwac, fds_fdsbios)
STD_ROM_FN(fds_sdgunworgacsescwac)

struct BurnDriver BurnDrvfds_sdgunworgacsescwac = {
	"fds_sdgunworgacsescwac", "fds_sdgunworgacsescwa", "fds_fdsbios", NULL, "2020",
	"SD Gundam World - Gachapon Senshi - Scramble Wars (Hack, Spanish)\0", NULL, "Max1323", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_FDS, GBF_STRATEGY, 0,
	NESGetZipName, fds_sdgunworgacsescwacRomInfo, fds_sdgunworgacsescwacRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Mario Brothers (Hack, Spanish)
static struct BurnRomInfo fds_supermarbrocRomDesc[] = {
	{ "super mario brothers (japan) - castellano v1.0.fds",          65516, 0x42d4a7c5, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_supermarbroc, fds_supermarbroc, fds_fdsbios)
STD_ROM_FN(fds_supermarbroc)

struct BurnDriver BurnDrvfds_supermarbroc = {
	"fds_supermarbroc", "fds_supermarbro", "fds_fdsbios", NULL, "2020",
	"Super Mario Brothers (Hack, Spanish)\0", NULL, "Noishe", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_FDS, GBF_PLATFORM, 0,
	NESGetZipName, fds_supermarbrocRomInfo, fds_supermarbrocRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Link no Bouken - The Legend of Zelda 2 (Rev 1) (Hack, Spanish)
static struct BurnRomInfo fds_linknoboucRomDesc[] = {
	{ "link no bouken - the legend of zelda 2 (japan) (rev 1) - castellano v1.0.fds",          131000, 0x60a26198, BRF_ESS | BRF_PRG },
};

STDROMPICKEXT(fds_linknobouc, fds_linknobouc, fds_fdsbios)
STD_ROM_FN(fds_linknobouc)

struct BurnDriver BurnDrvfds_linknobouc = {
	"fds_linknobouc", "fds_linknobou", "fds_fdsbios", NULL, "2019",
	"Link no Bouken - The Legend of Zelda 2 (Rev 1) (Hack, Spanish)\0", NULL, "jackic", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_FDS, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, fds_linknoboucRomInfo, fds_linknoboucRomName, NULL, NULL, NULL, NULL, NESFDSInputInfo, NESFDSDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// EarthBound Zero (USA)
// https://www.romhacking.net/
static struct BurnRomInfo nes_earthboundzeroRomDesc[] = {
	{ "earthbound zero (usa)(2014)(giygas999).nes",          524304, 0x6a5e39e2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_earthboundzero)
STD_ROM_FN(nes_earthboundzero)

struct BurnDriver BurnDrvnes_earthboundzero = {
	"nes_earthboundzero", "nes_earthbound", NULL, NULL, "2014",
	"Earth Bound Zero (USA)\0", NULL, "Giygas999", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_earthboundzeroRomInfo, nes_earthboundzeroRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// EarthBound Zero (Hack, Spanish v0.99)
// https://www.romhacking.net/
static struct BurnRomInfo nes_earthboundzerocRomDesc[] = {
	{ "earthbound zero (usa) - castellano v0.99.nes",          524304, 0x2e24c315, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_earthboundzeroc)
STD_ROM_FN(nes_earthboundzeroc)

struct BurnDriver BurnDrvnes_earthboundzeroc = {
	"nes_earthboundzeroc", "nes_earthbound", NULL, NULL, "201?",
	"EarthBound Zero (Hack, Spanish v0.99)\0", NULL, "jackic", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_earthboundzerocRomInfo, nes_earthboundzerocRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// EarthBound Beginnings (Hack)
// https://www.romhacking.net/hacks/5967/
static struct BurnRomInfo nes_earthboundbRomDesc[] = {
	{ "EarthBound Beginnings (2021)(ABOhiccups).nes",          524304, 0xe806cd5e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_earthboundb)
STD_ROM_FN(nes_earthboundb)

struct BurnDriver BurnDrvnes_earthboundb = {
	"nes_earthboundb", "nes_earthbound", NULL, NULL, "2021",
	"EarthBound Beginnings (Hack)\0", NULL, "ABOhiccups", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_earthboundbRomInfo, nes_earthboundbRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// EarthBound (Hack, Italian v1.1)
// https://www.romhacking.net/translations/7069/
static struct BurnRomInfo nes_earthboundbiRomDesc[] = {
	{ "EarthBound Beginnings T-Ita v1.1 (2023)(GiAnMMV).nes",          524304, 0xe4df7410, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_earthboundbi)
STD_ROM_FN(nes_earthboundbi)

struct BurnDriver BurnDrvnes_earthboundbi = {
	"nes_earthboundbi", "nes_earthbound", NULL, NULL, "2023",
	"EarthBound (Hack, Italian v1.1)\0", NULL, "GiAnMMV", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_earthboundbiRomInfo, nes_earthboundbiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dai-2-ji Super Robot Taisen (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_dai2jisuprotajcRomDesc[] = {
	{ "Dai-2-ji Super Robot Taisen (Japan) - Castellano v1.0.nes",          524304, 0x5b7ab480, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dai2jisuprotajc)
STD_ROM_FN(nes_dai2jisuprotajc)

struct BurnDriver BurnDrvnes_dai2jisuprotajc = {
	"nes_dai2jisuprotajc", "nes_dai2jisuprota", NULL, NULL, "2021",
	"Dai-2-ji Super Robot Taisen (Hack, Spanish)\0", NULL, "Max1323", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_dai2jisuprotajcRomInfo, nes_dai2jisuprotajcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dai-2-ji Super Robot Taisen (Japan) - Italian v0.98
// https://www.romhacking.net/
static struct BurnRomInfo nes_dai2jisuprotajiRomDesc[] = {
	{ "Super Robot Taisen (it) v0.98i (2019)(Wolfgare).nes",          524304, 0xdfd59e4e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dai2jisuprotaji)
STD_ROM_FN(nes_dai2jisuprotaji)

struct BurnDriver BurnDrvnes_dai2jisuprotaji = {
	"nes_dai2jisuprotaji", "nes_dai2jisuprota", NULL, NULL, "2019",
	"Dai-2-ji Super Robot Taisen (Hack, Italian v0.98)\0", NULL, "Wolfgare", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_dai2jisuprotajiRomInfo, nes_dai2jisuprotajiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Shin 4 Nin Uchi Mahjong (T-Chi)
// http://wangyixiao.ysepan.com/
static struct BurnRomInfo nes_shin4ninuchmacRomDesc[] = {
	{ "Shin 4 Nin Uchi Mahjong (T-Chi).nes",          393232, 0x975f7379, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_shin4ninuchmac)
STD_ROM_FN(nes_shin4ninuchmac)

struct BurnDriver BurnDrvnes_shin4ninuchmac = {
	"nes_shin4ninuchmac", "nes_shin4ninuchma", NULL, NULL, "2013",
	"Shin 4 Nin Uchi Mahjong (T-Chi)\0", NULL, "Wang Yixiao", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 4, HARDWARE_NES, GBF_MAHJONG, 0,
	NESGetZipName, nes_shin4ninuchmacRomInfo, nes_shin4ninuchmacRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Alien 3 (T-Chi, v1.1)
// http://www.dmgrom.com/cnpage.html
static struct BurnRomInfo nes_alien3scRomDesc[] = {
	{ "Alien 3 (T-Chi, v1.1).nes",          262160, 0x70506f6f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_alien3sc)
STD_ROM_FN(nes_alien3sc)

struct BurnDriver BurnDrvnes_alien3sc = {
	"nes_alien3sc", "nes_alien3", NULL, NULL, "2020",
	"Alien 3 (T-Chi, v1.1)\0", NULL, "DMG Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_alien3scRomInfo, nes_alien3scRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Grand Master (T-Chi, v1.1)
// https://www.nesbbs.com/bbs/thread-51304-1-1.html
static struct BurnRomInfo nes_grandmastercRomDesc[] = {
	{ "Grand Master (T-Chi, v1.1).nes",          1048592, 0x505d11c0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_grandmasterc)
STD_ROM_FN(nes_grandmasterc)

struct BurnDriver BurnDrvnes_grandmasterc = {
	"nes_grandmasterc", "nes_grandmaster", NULL, NULL, "2021",
	"Grand Master (T-Chi, v1.1)\0", NULL, "HHNM Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_grandmastercRomInfo, nes_grandmastercRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Nekketsu! Street Basket - Ganbare Dunk Heroes (T-Chi, v2)
// https://www.nesbbs.com/bbs/forum.php?mod=viewthread&tid=50722 
static struct BurnRomInfo nes_nekkestrbascRomDesc[] = {
	{ "nekketsu! street basket - ganbare dunk heroes (T-Chi, v2).nes",          524304, 0x8f359b4f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_nekkestrbasc)
STD_ROM_FN(nes_nekkestrbasc)

struct BurnDriver BurnDrvnes_nekkestrbasc = {
	"nes_nekkestrbasc", "nes_nekkestrbas", NULL, NULL, "2020",
	"Nekketsu! Street Basket - Ganbare Dunk Heroes (T-Chi, v2)\0", NULL, "HHNM Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_nekkestrbascRomInfo, nes_nekkestrbascRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Grand Master (Hack, Spanish)
// https://www.romhacking.net/
static struct BurnRomInfo nes_grandmasterjcRomDesc[] = {
	{ "grand master (japan) - castellano.nes",          393232, 0x3ad512ce, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_grandmasterjc)
STD_ROM_FN(nes_grandmasterjc)

struct BurnDriver BurnDrvnes_grandmasterjc = {
	"nes_grandmasterjc", "nes_grandmaster", NULL, NULL, "2021",
	"Grand Master (Hack, Spanish)\0", NULL, "Max1323", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_grandmasterjcRomInfo, nes_grandmasterjcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// War on Wheels (USA) (Proto)
static struct BurnRomInfo nes_wowheelsRomDesc[] = {
	{ "War on Wheels (Proto)(2006)(Jaleco).nes",          393232, 0xc957dcb0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_wowheels)
STD_ROM_FN(nes_wowheels)

	struct BurnDriver BurnDrvnes_wowheels = {
	"nes_wowheels", NULL, NULL, NULL, "1991-2006",
	"War on Wheels (USA) (Prototype)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_PROTOTYPE, 1, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_wowheelsRomInfo, nes_wowheelsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// 1991 Du Ma Racing (Unl)
static struct BurnRomInfo nes_1991dumaracRomDesc[] = {
	{ "1991 Du Ma Racing (Unl)(1991)(Idea-tek).nes",          65552, 0x8cd7f9b1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_1991dumarac)
STD_ROM_FN(nes_1991dumarac)

struct BurnDriver BurnDrvnes_1991dumarac = {
	"nes_1991dumarac", NULL, NULL, NULL, "1991",
	"1991 Du Ma Racing (Unl)\0", NULL, "Idea-tek", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC | GBF_MISC, 0,
	NESGetZipName, nes_1991dumaracRomInfo, nes_1991dumaracRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Adam & Eve (Unl)
static struct BurnRomInfo nes_adameveRomDesc[] = {
	{ "Adam & Eve (Unl)(1991)(Mega Soft).nes",          49168, 0x9e2d9a66, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_adameve)
STD_ROM_FN(nes_adameve)

struct BurnDriver BurnDrvnes_adameve = {
	"nes_adameve", NULL, NULL, NULL, "1991",
	"Adam & Eve (Unl)\0", NULL, "Mega Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_adameveRomInfo, nes_adameveRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Aladdin 4 (Unl)
static struct BurnRomInfo nes_aladdin4RomDesc[] = {
	{ "Aladdin 4 (Unl)(1996)(J.Y. Company).nes",          524304, 0xdda79434, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_aladdin4)
STD_ROM_FN(nes_aladdin4)

struct BurnDriver BurnDrvnes_aladdin4 = {
	"nes_aladdin4", NULL, NULL, NULL, "1996",
	"Aladdin 4 (Unl)\0", NULL, "J.Y. Company", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_aladdin4RomInfo, nes_aladdin4RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Animal Blockes (Unl)
static struct BurnRomInfo nes_animalblkRomDesc[] = {
	{ "Animal Blockes (200x)(Unknown).nes",          49168, 0xfc2b860c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_animalblk)
STD_ROM_FN(nes_animalblk)

struct BurnDriver BurnDrvnes_animalblk = {
	"nes_animalblk", NULL, NULL, NULL, "200?",
	"Animal Blockes (Unl)\0", NULL, "<unknown>", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_animalblkRomInfo, nes_animalblkRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Archer, The (Unl)
static struct BurnRomInfo nes_archerRomDesc[] = {
	{ "Archer, The (200X)(Power Joy).nes",          24592, 0x911e0365, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_archer)
STD_ROM_FN(nes_archer)

struct BurnDriver BurnDrvnes_archer = {
	"nes_archer", NULL, NULL, NULL, "200?",
	"Archer, The (Unl)\0", NULL, "Power Joy", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_archerRomInfo, nes_archerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// AV Pretty Girl Fight (Unl)
static struct BurnRomInfo nes_avpregirfigRomDesc[] = {
	{ "AV Pretty Girl Fight (Unl).nes",          655376, 0xc3d2b090, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_avpregirfig)
STD_ROM_FN(nes_avpregirfig)

struct BurnDriver BurnDrvnes_avpregirfig = {
	"nes_avpregirfig", NULL, NULL, NULL, "1994",
	"AV Pretty Girl Fight (Unl)\0", NULL, "Someri Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_avpregirfigRomInfo, nes_avpregirfigRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Blob Man (Unl)
static struct BurnRomInfo nes_blobmanRomDesc[] = {
	{ "Blob Man (Unl).nes",          40976, 0xeef9db4b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_blobman)
STD_ROM_FN(nes_blobman)

struct BurnDriver BurnDrvnes_blobman = {
	"nes_blobman", NULL, NULL, NULL, "2007",
	"Blob Man (Unl)\0", NULL, "<unknown>", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_blobmanRomInfo, nes_blobmanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Boogerman (Unl)
static struct BurnRomInfo nes_boogermanRomDesc[] = {
	{ "Boogerman (Unl).nes",          524304, 0xf10d5e5b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_boogerman)
STD_ROM_FN(nes_boogerman)

struct BurnDriver BurnDrvnes_boogerman = {
	"nes_boogerman", NULL, NULL, NULL, "1997",
	"Boogerman (Unl)\0", NULL, "Realtec", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_boogermanRomInfo, nes_boogermanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bookyman (Unl)
static struct BurnRomInfo nes_bookymanRomDesc[] = {
	{ "Bookyman (1991)(Mega Soft).nes",          24592, 0xd8f11b78, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bookyman)
STD_ROM_FN(nes_bookyman)

struct BurnDriver BurnDrvnes_bookyman = {
	"nes_bookyman", NULL, NULL, NULL, "1991",
	"Bookyman (Unl)\0", NULL, "Mega Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_MAZE | GBF_ACTION, 0,
	NESGetZipName, nes_bookymanRomInfo, nes_bookymanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Contra 168-in-1 (Unl)
static struct BurnRomInfo nes_contra168in1RomDesc[] = {
	{ "Contra 168-in-1 (Unl).nes",          1048592, 0xc6fd114e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_contra168in1)
STD_ROM_FN(nes_contra168in1)

struct BurnDriver BurnDrvnes_contra168in1 = {
	"nes_contra168in1", NULL, NULL, NULL, "19??",
	"Contra 168-in-1 (Unl)\0", NULL, "<unknown>", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_contra168in1RomInfo, nes_contra168in1RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Creatom (Unl)
static struct BurnRomInfo nes_creatomRomDesc[] = {
	{ "Creatom (Unl)(1991)(Micro Genius).nes",          98320, 0x1a1328bc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_creatom)
STD_ROM_FN(nes_creatom)

struct BurnDriver BurnDrvnes_creatom = {
	"nes_creatom", NULL, NULL, NULL, "1991",
	"Creatom (Unl)\0", NULL, "Micro Genius", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_creatomRomInfo, nes_creatomRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Danger Bridge (Unl)
static struct BurnRomInfo nes_dangbridgeRomDesc[] = {
	{ "Danger Bridge (200x)(Power Joy).nes",          49168, 0x5e59a8b1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dangbridge)
STD_ROM_FN(nes_dangbridge)

struct BurnDriver BurnDrvnes_dangbridge = {
	"nes_dangbridge", NULL, NULL, NULL, "200?",
	"Danger Bridge (Unl)\0", NULL, "Power Joy", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_dangbridgeRomInfo, nes_dangbridgeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dao Shuai (Asia) (Unl)
static struct BurnRomInfo nes_daoshuaiRomDesc[] = {
	{ "Dao Shuai (Asia)(Unl)(1989).nes",          65552, 0x00951874, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_daoshuai)
STD_ROM_FN(nes_daoshuai)

struct BurnDriver BurnDrvnes_daoshuai = {
	"nes_daoshuai", NULL, NULL, NULL, "1989",
	"Dao Shuai (Asia) (Unl)\0", NULL, "<unknown>", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_daoshuaiRomInfo, nes_daoshuaiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Depth Bomb v1 (Unl)
static struct BurnRomInfo nes_depbomb1RomDesc[] = {
	{ "Depth Bomb v1 (Unl)(2004)(Nice Code).nes",          24592, 0xa1d97a3e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_depbomb1)
STD_ROM_FN(nes_depbomb1)

struct BurnDriver BurnDrvnes_depbomb1 = {
	"nes_depbomb1", NULL, NULL, NULL, "2004",
	"Depth Bomb v1 (Unl)\0", NULL, "Nice Code Software", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_STRATEGY | GBF_BOARD, 0,
	NESGetZipName, nes_depbomb1RomInfo, nes_depbomb1RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Depth Bomb v2 (Unl)
static struct BurnRomInfo nes_depbomb2RomDesc[] = {
	{ "Depth Bomb v2 (Unl)(2004)(Nice Code).nes",          24592, 0x4cf58383, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_depbomb2)
STD_ROM_FN(nes_depbomb2)

struct BurnDriver BurnDrvnes_depbomb2 = {
	"nes_depbomb2", "nes_depbomb1", NULL, NULL, "2004",
	"Depth Bomb v2 (Unl)\0", NULL, "Nice Code Software", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_STRATEGY | GBF_BOARD, 0,
	NESGetZipName, nes_depbomb2RomInfo, nes_depbomb2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dive Man (Unl)
static struct BurnRomInfo nes_divemanRomDesc[] = {
	{ "Dive Man (Unl)(199x)(Power Joy).nes",          262160, 0xb12bfcc2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_diveman)
STD_ROM_FN(nes_diveman)

struct BurnDriver BurnDrvnes_diveman = {
	"nes_diveman", NULL, NULL, NULL, "199?",
	"Dive Man (Unl)\0", NULL, "Power Joy", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_divemanRomInfo, nes_divemanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dringle (Unl)
static struct BurnRomInfo nes_dringleRomDesc[] = {
	{ "Dringle (Unl)(2005).nes",          40976, 0x05c38615, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dringle)
STD_ROM_FN(nes_dringle)

struct BurnDriver BurnDrvnes_dringle = {
	"nes_dringle", NULL, NULL, NULL, "2005",
	"Dringle (Unl)\0", NULL, "<unknown>", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_dringleRomInfo, nes_dringleRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Echo Chamber (Unl)
static struct BurnRomInfo nes_echocambRomDesc[] = {
	{ "Echo Chamber (Unl)(200X)(Nice Code).nes",          40976, 0xc2aa9dc8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_echocamb)
STD_ROM_FN(nes_echocamb)

struct BurnDriver BurnDrvnes_echocamb = {
	"nes_echocamb", NULL, NULL, NULL, "200?",
	"Echo Chamber (Unl)\0", NULL, "Nice Code", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_echocambRomInfo, nes_echocambRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Eeeck! A Mouse! (Unl)
static struct BurnRomInfo nes_eeeckRomDesc[] = {
	{ "Eeeck! A Mouse! (Unl)(200X)(Nice Code).nes",          40976, 0x9efb7a7d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_eeeck)
STD_ROM_FN(nes_eeeck)

struct BurnDriver BurnDrvnes_eeeck = {
	"nes_eeeck", NULL, NULL, NULL, "200?",
	"Eeeck! A Mouse! (Unl)\0", NULL, "Nice Code", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_eeeckRomInfo, nes_eeeckRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Elfland (Unl)
// https://www.romhacking.net/forum/index.php?topic=29783.0
static struct BurnRomInfo nes_elflandRomDesc[] = {
	{ "Elfland (Unl)(1992)(TipTop).nes",          65552, 0x93c86e5d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_elfland)
STD_ROM_FN(nes_elfland)

struct BurnDriver BurnDrvnes_elfland = {
	"nes_elfland", NULL, NULL, NULL, "1992",
	"Elfland (Unl)\0", "Ripped from 200-in-1 multicard from Dacicus", "TipTop", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_elflandRomInfo, nes_elflandRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Fire Dragon (Asia) (Unl)
static struct BurnRomInfo nes_firedragonRomDesc[] = {
	{ "Fire Dragon (Asia)(Unl)(199x)(GamTec).nes",          40976, 0x8ac54f30, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_firedragon)
STD_ROM_FN(nes_firedragon)

struct BurnDriver BurnDrvnes_firedragon = {
	"nes_firedragon", NULL, NULL, NULL, "199?",
	"Fire Dragon (Asia) (Unl)\0", NULL, "Gamtec", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_firedragonRomInfo, nes_firedragonRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Fish Story (Unl)
static struct BurnRomInfo nes_fishstoryRomDesc[] = {
	{ "Fish Story (Unl)(200x).nes",          49168, 0xafe5a331, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_fishstory)
STD_ROM_FN(nes_fishstory)

struct BurnDriver BurnDrvnes_fishstory = {
	"nes_fishstory", NULL, NULL, NULL, "200?",
	"Fish Story (Unl)\0", NULL, "<unknown>", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_fishstoryRomInfo, nes_fishstoryRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Five Days (Unl)
static struct BurnRomInfo nes_fivedaysRomDesc[] = {
	{ "Five Days (Unl)(2005).nes",          24592, 0x4d8858e4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_fivedays)
STD_ROM_FN(nes_fivedays)

struct BurnDriver BurnDrvnes_fivedays = {
	"nes_fivedays", NULL, NULL, NULL, "2005",
	"Five Days (Unl)\0", NULL, "<unknown>", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_fivedaysRomInfo, nes_fivedaysRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Frog Adventure (Unl)
static struct BurnRomInfo nes_frogadvRomDesc[] = {
	{ "Frog Adventure (Unl)(1993)(Sachen).nes",          98320, 0x842d3e9f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_frogadv)
STD_ROM_FN(nes_frogadv)

struct BurnDriver BurnDrvnes_frogadv = {
	"nes_frogadv", NULL, NULL, NULL, "1993",
	"Frog Adventure (Unl)\0", NULL, "Sachen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_frogadvRomInfo, nes_frogadvRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Garden War (Unl)
static struct BurnRomInfo nes_gardenwarRomDesc[] = {
	{ "Garden War (Unl)(200x).nes",          65552, 0x588a838e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gardenwar)
STD_ROM_FN(nes_gardenwar)

struct BurnDriver BurnDrvnes_gardenwar = {
	"nes_gardenwar", NULL, NULL, NULL, "200?",
	"Garden War (Unl)\0", NULL, "<unknown>", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_gardenwarRomInfo, nes_gardenwarRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Huang Di (Asia) (Unl)
static struct BurnRomInfo nes_huangdiRomDesc[] = {
	{ "Huang Di (Asia)(Unl)(1994)(Asder).nes",          393232, 0xdfdec378, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_huangdi)
STD_ROM_FN(nes_huangdi)

struct BurnDriver BurnDrvnes_huangdi = {
	"nes_huangdi", NULL, NULL, NULL, "1994",
	"Huang Di (Asia) (Unl)\0", NULL, "Asder", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_huangdiRomInfo, nes_huangdiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Huge Insect (Asia) (Unl)
static struct BurnRomInfo nes_hugeinsectRomDesc[] = {
	{ "Huge Insect (Asia)(Unl)(1993)(Thin Chen).nes",          65552, 0x552a903a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hugeinsect)
STD_ROM_FN(nes_hugeinsect)

struct BurnDriver BurnDrvnes_hugeinsect = {
	"nes_hugeinsect", NULL, NULL, NULL, "1993",
	"Huge Insect (Asia) (Unl)\0", NULL, "Thin Chen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_hugeinsectRomInfo, nes_hugeinsectRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Jump-Jump (Unl)
static struct BurnRomInfo nes_jumpjumpRomDesc[] = {
	{ "Jump-Jump (Unl)(200x).nes",          40976, 0x3fe43784, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jumpjump)
STD_ROM_FN(nes_jumpjump)

struct BurnDriver BurnDrvnes_jumpjump = {
	"nes_jumpjump", NULL, NULL, NULL, "200?",
	"Jump-Jump (Unl)\0", NULL, "<unknown>", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_jumpjumpRomInfo, nes_jumpjumpRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// JY 45-in-1 (Unl)
static struct BurnRomInfo nes_jy45in1RomDesc[] = {
	{ "JY 45-in-1 (Unl)(1998)(J.Y. Company).nes",          4194320, 0x2a798367, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jy45in1)
STD_ROM_FN(nes_jy45in1)

struct BurnDriver BurnDrvnes_jy45in1 = {
	"nes_jy45in1", NULL, NULL, NULL, "1998",
	"JY 45-in-1 (Unl)\0", NULL, "J.Y. Company", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_jy45in1RomInfo, nes_jy45in1RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kart Fighter (Unl)
static struct BurnRomInfo nes_kartfighterRomDesc[] = {
	{ "Kart Fighter (Unl)(1994)(Ge De Industry Co.).nes",          393232, 0x7318bed4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kartfighter)
STD_ROM_FN(nes_kartfighter)

struct BurnDriver BurnDrvnes_kartfighter = {
	"nes_kartfighter", NULL, NULL, NULL, "1994",
	"Kart Fighter (Unl)\0", NULL, "Ge De Industry Co.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_kartfighterRomInfo, nes_kartfighterRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Kart Fighter (Hack)
static struct BurnRomInfo nes_skartfighterRomDesc[] = {
	{ "Super Kart Fighter Hack (2022)(Mr. Streetwize).nes",          393232, 0xce36e36d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_skartfighter)
STD_ROM_FN(nes_skartfighter)

struct BurnDriver BurnDrvnes_skartfighter = {
	"nes_skartfighter", "nes_kartfighter", NULL, NULL, "2022",
	"Super Kart Fighter (Hack)\0", NULL, "Mr. Streetwize", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_skartfighterRomInfo, nes_skartfighterRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mahjong Block (Unl)
static struct BurnRomInfo nes_mahjongblockRomDesc[] = {
	{ "Mahjong Block (Unl)(1991)(Idea-tek).nes",          65552, 0x30820b60, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mahjongblock)
STD_ROM_FN(nes_mahjongblock)

struct BurnDriver BurnDrvnes_mahjongblock = {
	"nes_mahjongblock", NULL, NULL, NULL, "1991",
	"Mahjong Block (Unl)\0", NULL, "Idea-tek", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_mahjongblockRomInfo, nes_mahjongblockRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Master Shooter (Unl)
static struct BurnRomInfo nes_mastershooterRomDesc[] = {
	{ "Master Shooter (Unl)(1993)(NTDEC).nes",          65552, 0xd2dcae89, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mastershooter)
STD_ROM_FN(nes_mastershooter)

struct BurnDriver BurnDrvnes_mastershooter = {
	"nes_mastershooter", NULL, NULL, NULL, "1993",
	"Master Shooter (Unl)\0", NULL, "NTDEC", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_mastershooterRomInfo, nes_mastershooterRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mice Mission (Unl)
static struct BurnRomInfo nes_micemissionRomDesc[] = {
	{ "Mice Mission (Unl)(200x).nes",          40976, 0x78820fd8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_micemission)
STD_ROM_FN(nes_micemission)

struct BurnDriver BurnDrvnes_micemission = {
	"nes_micemission", NULL, NULL, NULL, "200?",
	"Mice Mission (Unl)\0", NULL, "<unknown>", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_micemissionRomInfo, nes_micemissionRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Monkey King (China) (Unl)
static struct BurnRomInfo nes_monkeykingRomDesc[] = {
	{ "Monkey King (Unl)(2005)(Waixing).nes",          524304, 0xe5119eed, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_monkeyking)
STD_ROM_FN(nes_monkeyking)

struct BurnDriver BurnDrvnes_monkeyking = {
	"nes_monkeyking", NULL, NULL, NULL, "2005",
	"Monkey King (China) (Unl)\0", NULL, "Waixing", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_monkeykingRomInfo, nes_monkeykingRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Panda Baby (Unl)
static struct BurnRomInfo nes_pandababyRomDesc[] = {
	{ "Panda Baby (Unl)(1997)(Dragon Co.).nes",          524304, 0x042f5b25, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pandababy)
STD_ROM_FN(nes_pandababy)

struct BurnDriver BurnDrvnes_pandababy = {
	"nes_pandababy", NULL, NULL, NULL, "1997",
	"Panda Baby (Unl)\0", NULL, "Dragon Co.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_pandababyRomInfo, nes_pandababyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Panda World (Unl)
static struct BurnRomInfo nes_pandaworldRomDesc[] = {
	{ "Panda World (Unl)(20xx).nes",          262160, 0xdff2fe93, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pandaworld)
STD_ROM_FN(nes_pandaworld)

struct BurnDriver BurnDrvnes_pandaworld = {
	"nes_pandaworld", NULL, NULL, NULL, "20??",
	"Panda World (Unl)\0", NULL, "<unknown>", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_pandaworldRomInfo, nes_pandaworldRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Pocahontas (Hack)
static struct BurnRomInfo nes_pocahontasRomDesc[] = {
	{ "Pocahontas (2024)(lancuster).nes",          524304, 0x5e247c68, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pocahontas)
STD_ROM_FN(nes_pocahontas)

struct BurnDriver BurnDrvnes_pocahontas = {
	"nes_pocahontas", NULL, NULL, NULL, "2024",
	"Pocahontas (Hack)\0", NULL, "lancuster", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_pocahontasRomInfo, nes_pocahontasRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Pocohontos (China) (Unl)
static struct BurnRomInfo nes_pocohontosRomDesc[] = {
	{ "Pocohontos (Unl)(China)(1997)(Hosenkan Electronics).nes",          524304, 0xb57153d5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pocohontos)
STD_ROM_FN(nes_pocohontos)

struct BurnDriver BurnDrvnes_pocohontos = {
	"nes_pocohontos", "nes_pocahontas", NULL, NULL, "1997",
	"Pocohontos (China) (Unl)\0", NULL, "Hosenkan Electronics", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_pocohontosRomInfo, nes_pocohontosRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Pulveration (Unl)
static struct BurnRomInfo nes_pulverationRomDesc[] = {
	{ "Pulveration (Unl)(200x)(Nice Code Software).nes",          40976, 0x27de9c6e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pulveration)
STD_ROM_FN(nes_pulveration)

struct BurnDriver BurnDrvnes_pulveration = {
	"nes_pulveration", NULL, NULL, NULL, "200?",
	"Pulveration (Unl)\0", NULL, "Nice Code Software", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_pulverationRomInfo, nes_pulverationRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rocketman (Unl)
static struct BurnRomInfo nes_rocketmanRomDesc[] = {
	{ "Rocketman (Unl)(2007)(Nide Code Software).nes",          40976, 0xc18196f2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rocketman)
STD_ROM_FN(nes_rocketman)

struct BurnDriver BurnDrvnes_rocketman = {
	"nes_rocketman", NULL, NULL, NULL, "2007",
	"Rocketman (Unl)\0", NULL, "Nice Code Software", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_rocketmanRomInfo, nes_rocketmanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Samurai Spirits (Unl)
static struct BurnRomInfo nes_samuraispiritsRomDesc[] = {
	{ "Samurai Spirits (Unl)(199x)(Rex Soft).nes",          786448, 0x9b7305f7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_samuraispirits)
STD_ROM_FN(nes_samuraispirits)

struct BurnDriver BurnDrvnes_samuraispirits = {
	"nes_samuraispirits", NULL, NULL, NULL, "199?",
	"Samurai Spirits (Unl)\0", NULL, "Rex Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_samuraispiritsRomInfo, nes_samuraispiritsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Street Fighter II - The World Warrior (Unl)
static struct BurnRomInfo nes_streefigiiRomDesc[] = {
	{ "Street Fighter II - The World Warrior (Unl).nes",          262160, 0xdedfa5bb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_streefigii)
STD_ROM_FN(nes_streefigii)

struct BurnDriver BurnDrvnes_streefigii = {
	"nes_streefigii", NULL, NULL, NULL, "1992",
	"Street Fighter II - The World Warrior (Unl)\0", NULL, "Yoko Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_streefigiiRomInfo, nes_streefigiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Street Fighter II Hack (Hack of SFIII)
static struct BurnRomInfo nes_streefigiihacRomDesc[] = {
	{ "Street Fighter II Hack (Hack of SFIII).nes",          655376, 0x470ce47e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_streefigiihac)
STD_ROM_FN(nes_streefigiihac)

struct BurnDriver BurnDrvnes_streefigiihac = {
	"nes_streefigiihac", "nes_streefigiii", NULL, NULL, "199?",
	"Street Fighter II Hack (Hack of SFIII)\0", NULL, "<unknown>", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_streefigiihacRomInfo, nes_streefigiihacRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Street Fighter III (Unl)
static struct BurnRomInfo nes_streefigiiiRomDesc[] = {
	{ "Street Fighter III (Unl).nes",          655376, 0xa21b5886, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_streefigiii)
STD_ROM_FN(nes_streefigiii)

struct BurnDriver BurnDrvnes_streefigiii = {
	"nes_streefigiii", NULL, NULL, NULL, "199?",
	"Street Fighter III (Unl)\0", NULL, "<unknown>", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_streefigiiiRomInfo, nes_streefigiiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Maruo (Unl)
static struct BurnRomInfo nes_smaruoRomDesc[] = {
	{ "Super Maruo (Unknown).nes",          49168, 0xe5334399, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_smaruo)
STD_ROM_FN(nes_smaruo)

	struct BurnDriver BurnDrvnes_smaruo = {
	"nes_smaruo", NULL, NULL, NULL, "199?",
	"Super Maruo (Unl)\0", NULL, "<unknown>", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_smaruoRomInfo, nes_smaruoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Supervision 16-in-1 (Unl)
static struct BurnRomInfo nes_super16in1RomDesc[] = {
	{ "Supervision 16-in-1 (Unl).nes",          2129936, 0x48017a49, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_super16in1)
STD_ROM_FN(nes_super16in1)

struct BurnDriver BurnDrvnes_super16in1 = {
	"nes_super16in1", NULL, NULL, NULL, "199?",
	"Supervision 16-in-1 (Unl)\0", NULL, "Supervision", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_super16in1RomInfo, nes_super16in1RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tiny Toon Adventures 6 (Unl)
static struct BurnRomInfo nes_tinytooadv6RomDesc[] = {
	{ "Tiny Toon Adventures 6 (Unl).nes",          524304, 0x476cb108, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tinytooadv6)
STD_ROM_FN(nes_tinytooadv6)

struct BurnDriver BurnDrvnes_tinytooadv6 = {
	"nes_tinytooadv6", NULL, NULL, NULL, "1997",
	"Tiny Toon Adventures 6 (Unl)\0", NULL, "J.Y. Company", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_tinytooadv6RomInfo, nes_tinytooadv6RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Titanic (Hack, English v2.1)
static struct BurnRomInfo nes_titanicRomDesc[] = {
	{ "Titanic (T-Eng, v2.1)(2022(pacnsacdave).nes",          524304, 0x4f0bef8a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_titanic)
STD_ROM_FN(nes_titanic)

struct BurnDriver BurnDrvnes_titanic = {
	"nes_titanic", NULL, NULL, NULL, "2022",
	"Titanic (Hack, English v2.1)\0", NULL, "pacnsacdave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_titanicRomInfo, nes_titanicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Titanic (China) (Unl)
static struct BurnRomInfo nes_titaniccRomDesc[] = {
	{ "Titanic (Unl)(Chi)(2005)(Shenzhen Nanjing Technology).nes",          524304, 0xc63a373f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_titanicc)
STD_ROM_FN(nes_titanicc)

struct BurnDriver BurnDrvnes_titanicc = {
	"nes_titanicc", "nes_titanic", NULL, NULL, "2005",
	"Titanic (China) (Unl)\0", NULL, "Shenzhen Nanjing Technology", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_titaniccRomInfo, nes_titaniccRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ultimate Mortal Kombat 3 (Hack)
// https://www.romhacking.net/hacks/4052/
static struct BurnRomInfo nes_ultimmorkom3hRomDesc[] = {
	{ "Ultimate Mortal Kombat 3 (Hack).nes",          2097168, 0xa0a183e6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ultimmorkom3h)
STD_ROM_FN(nes_ultimmorkom3h)

struct BurnDriver BurnDrvnes_ultimmorkom3h = {
	"nes_ultimmorkom3h", "nes_ultimmorkom3", NULL, NULL, "2020",
	"Ultimate Mortal Kombat 3 (Hack)\0", NULL, "Vasil", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_ultimmorkom3hRomInfo, nes_ultimmorkom3hRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ultimate Mortal Kombat 3 (Unl)
static struct BurnRomInfo nes_ultimmorkom3RomDesc[] = {
	{ "Ultimate Mortal Kombat 3 (Unl).nes",          1048592, 0xc9495564, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ultimmorkom3)
STD_ROM_FN(nes_ultimmorkom3)

struct BurnDriver BurnDrvnes_ultimmorkom3 = {
	"nes_ultimmorkom3", NULL, NULL, NULL, "1996",
	"Ultimate Mortal Kombat 3 (Unl)\0", NULL, "Ka Sheng", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_ultimmorkom3RomInfo, nes_ultimmorkom3RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Urban Strike (Unl)
static struct BurnRomInfo nes_urbanstrikeRomDesc[] = {
	{ "Urban Strike (USA).nes",          262160, 0xfd02591b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_urbanstrike)
STD_ROM_FN(nes_urbanstrike)

struct BurnDriver BurnDrvnes_urbanstrike = {
	"nes_urbanstrike", NULL, NULL, NULL, "1995",
	"Urban Strike (Unl)\0", NULL, "<unknown>", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_urbanstrikeRomInfo, nes_urbanstrikeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Vanguard (Unl)
static struct BurnRomInfo nes_vanguardRomDesc[] = {
	{ "Vanguard (20XX)(Power Joy).nes",          163856, 0xb6c0c49e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vanguard)
STD_ROM_FN(nes_vanguard)

struct BurnDriver BurnDrvnes_vanguard = {
	"nes_vanguard", NULL, NULL, NULL, "200?",
	"Vanguard (Unl)\0", NULL, "Power Joy", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_vanguardRomInfo, nes_vanguardRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// ----------------------------------------
// END of "Non Homebrew (Unlicensed) Games"
// ----------------------------------------

// -------------------------------
// Aftermarket/Hack/Homebrew Games
// -------------------------------

// 5-star Restaurant (HB)
static struct BurnRomInfo nes_5starRomDesc[] = {
	{ "5-star Restaurant (2023)(Wendel Scardua).nes",          81936, 0x42658f47, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_5star)
STD_ROM_FN(nes_5star)

struct BurnDriver BurnDrvnes_5star = {
	"nes_5star", NULL, NULL, NULL, "2023",
	"5-star Restaurant (HB)\0", NULL, "Wendel Scardua", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_5starRomInfo, nes_5starRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// 8-bit Illustrations (HB)
static struct BurnRomInfo nes_8bitpicsRomDesc[] = {
	{ "8bit Illustrations (2015)(RIKI).nes",          524304, 0x19ca739b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_8bitpics)
STD_ROM_FN(nes_8bitpics)

struct BurnDriver BurnDrvnes_8bitpics = {
	"nes_8bitpics", NULL, NULL, NULL, "2015",
	"8-bit Illustrations (HB)\0", NULL, "RiKi", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_8bitpicsRomInfo, nes_8bitpicsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// 8-bit Music Power (HB)
static struct BurnRomInfo nes_8bitmusicRomDesc[] = {
	{ "8bit Music Power (2017)(RIKI).nes",          786448, 0x351426ab, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_8bitmusic)
STD_ROM_FN(nes_8bitmusic)

struct BurnDriver BurnDrvnes_8bitmusic = {
	"nes_8bitmusic", NULL, NULL, NULL, "2017",
	"8-bit Music Power (HB)\0", NULL, "RiKi - Columbus Circle", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_8bitmusicRomInfo, nes_8bitmusicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// 8-bit Music Power ENCORE (HB)
static struct BurnRomInfo nes_8bitmusiceRomDesc[] = {
	{ "8bit Music Power ENCORE (2017)(RIKI).nes",          524304, 0x8b381de2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_8bitmusice)
STD_ROM_FN(nes_8bitmusice)

struct BurnDriver BurnDrvnes_8bitmusice = {
	"nes_8bitmusice", "nes_8bitmusic", NULL, NULL, "2017",
	"8-bit Music Power ENCORE (HB)\0", NULL, "RiKi", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW | BDF_CLONE, 1, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_8bitmusiceRomInfo, nes_8bitmusiceRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// 8-Bit Rhythm Land (HB)
static struct BurnRomInfo nes_8bitrhylanRomDesc[] = {
	{ "8-Bit Rhythm Land (2018)(Columbus Circle).nes",          786448, 0x48859a73, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_8bitrhylan)
STD_ROM_FN(nes_8bitrhylan)

struct BurnDriver BurnDrvnes_8bitrhylan = {
	"nes_8bitrhylan", NULL, NULL, NULL, "2018",
	"8-Bit Rhythm Land (HB)\0", NULL, "Columbus Circle", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_8bitrhylanRomInfo, nes_8bitrhylanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// 8-bit XMAS 2017 (HB)
static struct BurnRomInfo nes_8bitxmas17RomDesc[] = {
	{ "8-bit XMAS 2017 (2017)(RetroUSB).nes",          2097168, 0x330da716, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_8bitxmas17)
STD_ROM_FN(nes_8bitxmas17)

struct BurnDriver BurnDrvnes_8bitxmas17 = {
	"nes_8bitxmas17", NULL, NULL, NULL, "2017",
	"8-bit XMAS 2017 (HB)\0", "8-bit XMAS 2008-2016 Compilation", "retroUSB", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_8bitxmas17RomInfo, nes_8bitxmas17RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// 8-bit XMAS 2018 (HB)
static struct BurnRomInfo nes_8bitxmas18RomDesc[] = {
	{ "8-bit XMAS 2018 (2018)(RetroUSB).nes",          131088, 0x9c8d171e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_8bitxmas18)
STD_ROM_FN(nes_8bitxmas18)

struct BurnDriver BurnDrvnes_8bitxmas18 = {
	"nes_8bitxmas18", NULL, NULL, NULL, "2018",
	"8-bit XMAS 2018 (HB)\0", NULL, "retroUSB", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_8bitxmas18RomInfo, nes_8bitxmas18RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// 8-bit XMAS 2019 (HB)
static struct BurnRomInfo nes_8bitxmas19RomDesc[] = {
	{ "8-bit XMAS 2019 (2019)(RetroUSB).nes",          131088, 0x6a33f365, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_8bitxmas19)
STD_ROM_FN(nes_8bitxmas19)

struct BurnDriver BurnDrvnes_8bitxmas19 = {
	"nes_8bitxmas19", NULL, NULL, NULL, "2019",
	"8-bit XMAS 2019 (HB)\0", NULL, "retroUSB", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_8bitxmas19RomInfo, nes_8bitxmas19RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// 8-bit XMAS 2020 (HB)
static struct BurnRomInfo nes_8bitxmas20RomDesc[] = {
	{ "8-bit XMAS 2020 (2020)(RetroUSB).nes",          131088, 0x4dacc860, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_8bitxmas20)
STD_ROM_FN(nes_8bitxmas20)

struct BurnDriver BurnDrvnes_8bitxmas20 = {
	"nes_8bitxmas20", NULL, NULL, NULL, "2020",
	"8-bit XMAS 2020 (HB)\0", NULL, "retroUSB", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_8bitxmas20RomInfo, nes_8bitxmas20RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// 8-bit XMAS 2021 (HB)
static struct BurnRomInfo nes_8bitxmas21RomDesc[] = {
	{ "8-bit XMAS 2021 (2021)(RetroUSB).nes",          131088, 0x94c3e8a3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_8bitxmas21)
STD_ROM_FN(nes_8bitxmas21)

struct BurnDriver BurnDrvnes_8bitxmas21 = {
	"nes_8bitxmas21", NULL, NULL, NULL, "2021",
	"8-bit XMAS 2021 (HB)\0", NULL, "retroUSB", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_8bitxmas21RomInfo, nes_8bitxmas21RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// 8-bit XMAS 2022 (HB)
static struct BurnRomInfo nes_8bitxmas22RomDesc[] = {
	{ "8-bit XMAS 2022 (2022)(RetroUSB).nes",          131088, 0x81bbc4a5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_8bitxmas22)
STD_ROM_FN(nes_8bitxmas22)

struct BurnDriver BurnDrvnes_8bitxmas22 = {
	"nes_8bitxmas22", NULL, NULL, NULL, "2022",
	"8-bit XMAS 2022 (HB)\0", NULL, "retroUSB", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_8bitxmas22RomInfo, nes_8bitxmas22RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// 2048 (HB)
static struct BurnRomInfo nes_2048RomDesc[] = {
	{ "2048 (2014)(Tsone).nes",          16400, 0x50b7ee6f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_2048)
STD_ROM_FN(nes_2048)

struct BurnDriver BurnDrvnes_2048 = {
	"nes_2048", NULL, NULL, NULL, "2014",
	"2048 (HB)\0", NULL, "Tsone", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_2048RomInfo, nes_2048RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Adventures of Panzer, The (HB, v1.5)
static struct BurnRomInfo nes_advpanzerRomDesc[] = {
	{ "Adventures of Panzer, The v1.5 (2021-22)(PixelCraft).nes",          524304, 0x93ba17c9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_advpanzer)
STD_ROM_FN(nes_advpanzer)

struct BurnDriver BurnDrvnes_advpanzer = {
	"nes_advpanzer", NULL, NULL, NULL, "2021-22",
	"Adventures of Panzer, The (HB, v1.5)\0", NULL, "PixelCraft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_advpanzerRomInfo, nes_advpanzerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Adventures of Panzer 2, The (HB, v1.1)
static struct BurnRomInfo nes_advpanzer2RomDesc[] = {
	{ "Adventures of Panzer 2, The v1.1 (2022)(PixelCraft).nes",          524304, 0x29750f4f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_advpanzer2)
STD_ROM_FN(nes_advpanzer2)

struct BurnDriver BurnDrvnes_advpanzer2 = {
	"nes_advpanzer2", NULL, NULL, NULL, "2022",
	"Adventures of Panzer 2, The (HB, v1.1)\0", NULL, "PixelCraft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_advpanzer2RomInfo, nes_advpanzer2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Akai Ringo to Midori no Inko (HB)
static struct BurnRomInfo nes_akairingoRomDesc[] = {
	{ "Akai Ringo to Midori no Inko (2023)(Okunyon).nes",          40976, 0x4a2ae602, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_akairingo)
STD_ROM_FN(nes_akairingo)

struct BurnDriver BurnDrvnes_akairingo = {
	"nes_akairingo", NULL, NULL, NULL, "2023",
	"Akai Ringo to Midori no Inko (HB)\0", NULL, "Okunyon", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_akairingoRomInfo, nes_akairingoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Alfonzo's Arctic Adventure (HB)
static struct BurnRomInfo nes_alfonsarcadvRomDesc[] = {
	{ "Alfonzo's Arctic Adventure (2018)(Spoony Bard Productions).nes",          262160, 0xcd2ada76, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_alfonsarcadv)
STD_ROM_FN(nes_alfonsarcadv)

struct BurnDriver BurnDrvnes_alfonsarcadv = {
	"nes_alfonsarcadv", NULL, NULL, NULL, "2018",
	"Alfonzo's Arctic Adventure (HB)\0", NULL, "Spoony Bard Productions", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_alfonsarcadvRomInfo, nes_alfonsarcadvRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Almika The Star Rider Densetsu Gaiden (HB)
static struct BurnRomInfo nes_almikaRomDesc[] = {
	{ "Almika The Star Rider Densetsu Gaiden (2021)(Mouse Spirit).nes",          524304, 0x3b5a7745, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_almika)
STD_ROM_FN(nes_almika)

struct BurnDriver BurnDrvnes_almika = {
	"nes_almika", NULL, NULL, NULL, "2021",
	"Almika The Star Rider Densetsu Gaiden (HB)\0", NULL, "Mouse Spirit", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_almikaRomInfo, nes_almikaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Almost Hero (HB)
static struct BurnRomInfo nes_almostheroRomDesc[] = {
	{ "Almost Hero (HB).nes",          262160, 0x2419f370, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_almosthero)
STD_ROM_FN(nes_almosthero)

struct BurnDriver BurnDrvnes_almosthero = {
	"nes_almosthero", NULL, NULL, NULL, "2016",
	"Almost Hero (HB)\0", NULL, "Mega Cat Studios", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_almostheroRomInfo, nes_almostheroRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Altercation (HB, v0.1)
static struct BurnRomInfo nes_altercationRomDesc[] = {
	{ "Altercation v0.1 (2021)(Scottlowe).nes",          40976, 0x27288df5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_altercation)
STD_ROM_FN(nes_altercation)

struct BurnDriver BurnDrvnes_altercation = {
	"nes_altercation", NULL, NULL, NULL, "2021",
	"Altercation (HB, v0.1)\0", NULL, "Scottlowe", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_altercationRomInfo, nes_altercationRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Alter Ego (HB)
static struct BurnRomInfo nes_alteregoRomDesc[] = {
	{ "Alter Ego (HB).nes",          40976, 0x5f322f79, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_alterego)
STD_ROM_FN(nes_alterego)

struct BurnDriver BurnDrvnes_alterego = {
	"nes_alterego", NULL, NULL, NULL, "2011",
	"Alter Ego (HB)\0", NULL, "Shiru", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_alteregoRomInfo, nes_alteregoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Alwa's Awakening (HB)
static struct BurnRomInfo nes_awakeningRomDesc[] = {
	{ "Alwa's Awakening (2021)(Elden Pixels).nes",          524304, 0x5cc1abc7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_awakening)
STD_ROM_FN(nes_awakening)

struct BurnDriver BurnDrvnes_awakening = {
	"nes_awakening", NULL, NULL, NULL, "2021",
	"Alwa's Awakening (HB)\0", NULL, "Elden Pixels", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_awakeningRomInfo, nes_awakeningRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Alwa's Awakening (HB, Prototype)
static struct BurnRomInfo nes_awakeningpRomDesc[] = {
	{ "Alwa's Awakening - Prototype (2021)(Elden Pixels).nes",          524304, 0xc07533c0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_awakeningp)
STD_ROM_FN(nes_awakeningp)

struct BurnDriver BurnDrvnes_awakeningp = {
	"nes_awakeningp", "nes_awakening", NULL, NULL, "2021",
	"Alwa's Awakening (HB, Prototype)\0", NULL, "Elden Pixels", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW | BDF_PROTOTYPE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_awakeningpRomInfo, nes_awakeningpRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Amazons Running Diet (HB, Japan)
static struct BurnRomInfo nes_amazorundiejRomDesc[] = {
	{ "Amazons Running Diet (Japan).nes",          524304, 0x1eced454, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_amazorundiej)
STD_ROM_FN(nes_amazorundiej)

struct BurnDriver BurnDrvnes_amazorundiej = {
	"nes_amazorundiej", "nes_amazorundie", NULL, NULL, "2017",
	"Amazons Running Diet (HB, Japan)\0", NULL, "Ancient", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_amazorundiejRomInfo, nes_amazorundiejRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Amazons Running Diet (HB, USA)
static struct BurnRomInfo nes_amazorundieRomDesc[] = {
	{ "Amazons Running Diet (USA).nes",          524304, 0x4db6acdd, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_amazorundie)
STD_ROM_FN(nes_amazorundie)

struct BurnDriver BurnDrvnes_amazorundie = {
	"nes_amazorundie", NULL, NULL, NULL, "2017",
	"Amazons Running Diet (HB, USA)\0", NULL, "Ancient", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_amazorundieRomInfo, nes_amazorundieRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Anguna - Scourge of the Goblin King (HB)
static struct BurnRomInfo nes_angunaRomDesc[] = {
	{ "Anguna - Scourge of the Goblin King (2021)(The 6502 Collective).nes",          524304, 0x1119efff, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_anguna)
STD_ROM_FN(nes_anguna)

struct BurnDriver BurnDrvnes_anguna = {
	"nes_anguna", NULL, NULL, NULL, "2021",
	"Anguna - Scourge of the Goblin King (HB)\0", NULL, "The 6502 Collective", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_angunaRomInfo, nes_angunaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Animal Clipper (HB)
static struct BurnRomInfo nes_animclipRomDesc[] = {
	{ "Animal Clipper (2021)(Okunyon).nes",          40976, 0x47d22165, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_animclip)
STD_ROM_FN(nes_animclip)

struct BurnDriver BurnDrvnes_animclip = {
	"nes_animclip", NULL, NULL, NULL, "2021",
	"Animal Clipper (HB)\0", "If the board completely empties the music crashes", "Okunyon", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_animclipRomInfo, nes_animclipRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Antenna Antics (HB)
static struct BurnRomInfo nes_antennaRomDesc[] = {
	{ "Antenna Antics (2021)(FG Software).nes",          65552, 0x0f5050e6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_antenna)
STD_ROM_FN(nes_antenna)

struct BurnDriver BurnDrvnes_antenna = {
	"nes_antenna", NULL, NULL, NULL, "2021",
	"Antenna Antics (HB)\0", NULL, "FG Software", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_antennaRomInfo, nes_antennaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// AO (HB)
static struct BurnRomInfo nes_aoRomDesc[] = {
	{ "AO (2016)(Second Dimension).nes",          24592, 0xbc0a5f02, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ao)
STD_ROM_FN(nes_ao)

struct BurnDriver BurnDrvnes_ao = {
	"nes_ao", NULL, NULL, NULL, "2016",
	"AO (HB)\0", NULL, "Second Dimension", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_aoRomInfo, nes_aoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// AO (HB, Digital Edition)
static struct BurnRomInfo nes_aodRomDesc[] = {
	{ "AO (2016)(Second Dimension, Digital).nes",          24592, 0xae018214, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_aod)
STD_ROM_FN(nes_aod)

struct BurnDriver BurnDrvnes_aod = {
	"nes_aod", "nes_ao", NULL, NULL, "2016",
	"AO (HB, Digital Edition)\0", NULL, "Second Dimension", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_aodRomInfo, nes_aodRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Apuntalo, Cheril (HB)
static struct BurnRomInfo nes_mojontwiapucheRomDesc[] = {
	{ "Apuntalo, Cheril (2018)(The Mojon Twins).nes",          131088, 0x2fe76a4a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mojontwiapuche)
STD_ROM_FN(nes_mojontwiapuche)

struct BurnDriver BurnDrvnes_mojontwiapuche = {
	"nes_mojontwiapuche", "nes_mojontwichewri", NULL, NULL, "2018",
	"Apuntalo, Cheril (HB)\0", NULL, "The Mojon Twins", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_mojontwiapucheRomInfo, nes_mojontwiapucheRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Arkade Rush (HB)
static struct BurnRomInfo nes_arkaderushRomDesc[] = {
	{ "Arkade Rush (HB)(2021)(Nathan Tolbert).nes",          32784, 0xd40c212e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_arkaderush)
STD_ROM_FN(nes_arkaderush)

struct BurnDriver BurnDrvnes_arkaderush = {
	"nes_arkaderush", NULL, NULL, NULL, "2021",
	"Arkade Rush (HB)\0", NULL, "Nathan Tolbert", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 4, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_arkaderushRomInfo, nes_arkaderushRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Armed for Battle - Limited Edition (HB)
static struct BurnRomInfo nes_armedbatleRomDesc[] = {
	{ "Armed for Battle - Limited Edition (2014) (1010 Howe).nes",          131088, 0x542bbace, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_armedbatle)
STD_ROM_FN(nes_armedbatle)

struct BurnDriver BurnDrvnes_armedbatle = {
	"nes_armedbatle", NULL, NULL, NULL, "2014",
	"Armed for Battle - Limited Edition (HB)\0", NULL, "1010 Howe", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_armedbatleRomInfo, nes_armedbatleRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Armed for Battle (HB)
static struct BurnRomInfo nes_armedbatRomDesc[] = {
	{ "Armed for Battle (2014)(1010 Howe).nes",          131088, 0xa7deed94, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_armedbat)
STD_ROM_FN(nes_armedbat)

struct BurnDriver BurnDrvnes_armedbat = {
	"nes_armedbat", "nes_armedbatle", NULL, NULL, "2014",
	"Armed for Battle (HB)\0", NULL, "1010 Howe", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_armedbatRomInfo, nes_armedbatRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Arm Wrestling Classic, The (HB)
static struct BurnRomInfo nes_armwrestlRomDesc[] = {
	{ "Arm Wrestling Classic, The (2022)(Fista Games).nes",          524304, 0x5c62c55a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_armwrestl)
STD_ROM_FN(nes_armwrestl)

struct BurnDriver BurnDrvnes_armwrestl = {
	"nes_armwrestl", NULL, NULL, NULL, "2022",
	"Arm Wrestling Classic, The (HB)\0", NULL, "Fista Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_armwrestlRomInfo, nes_armwrestlRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Aspect Star N (HB)
static struct BurnRomInfo nes_aspectstarnRomDesc[] = {
	{ "Aspect Star N (2019)(Nicole Express).nes",          24592, 0x14b70f98, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_aspectstarn)
STD_ROM_FN(nes_aspectstarn)

struct BurnDriver BurnDrvnes_aspectstarn = {
	"nes_aspectstarn", NULL, NULL, NULL, "2019",
	"Aspect Star N (HB)\0", NULL, "Nicole Express", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_aspectstarnRomInfo, nes_aspectstarnRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Astral World (GlobalHack)
// https://www.romhacking.net/hacks/8091/
static struct BurnRomInfo nes_astralworldRomDesc[] = {
	{ "Astral World GlobHack (2023)(Xasteria Group).nes",          196624, 0xb4099d18, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_astralworld)
STD_ROM_FN(nes_astralworld)

struct BurnDriver BurnDrvnes_astralworld = {
	"nes_astralworld", "nes_smb", NULL, NULL, "2023",
	"Astral World (GlobalHack)\0", NULL, "Xasteria Group", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_astralworldRomInfo, nes_astralworldRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Astro Ninja Man DX (HB)
static struct BurnRomInfo nes_astronmdxRomDesc[] = {
	{ "Astro Ninja Man DX (2022)(RiKi).nes",          786448, 0x27d5371f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_astronmdx)
STD_ROM_FN(nes_astronmdx)

struct BurnDriver BurnDrvnes_astronmdx = {
	"nes_astronmdx", NULL, NULL, NULL, "2022",
	"Astro Ninja Man DX (HB)\0", NULL, "RiKi", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_astronmdxRomInfo, nes_astronmdxRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Astro Ninja Man (HB)
static struct BurnRomInfo nes_astronmRomDesc[] = {
	{ "Astro Ninja Man (2020)(RiKi).nes",          786448, 0xf709e1e0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_astronm)
STD_ROM_FN(nes_astronm)

struct BurnDriver BurnDrvnes_astronm = {
	"nes_astronm", "nes_astronmdx", NULL, NULL, "2020",
	"Astro Ninja Man (HB)\0", NULL, "RiKi", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_astronmRomInfo, nes_astronmRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Assimilate (HB)
static struct BurnRomInfo nes_assimilateRomDesc[] = {
	{ "Assimilate (HB).nes",          262160, 0xa2d504a8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_assimilate)
STD_ROM_FN(nes_assimilate)

struct BurnDriver BurnDrvnes_assimilate = {
	"nes_assimilate", NULL, NULL, NULL, "2012",
	"Assimilate (HB)\0", NULL, "Nessylum", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_assimilateRomInfo, nes_assimilateRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// AWOL (HB)
static struct BurnRomInfo nes_awolRomDesc[] = {
	{ "AWOL (2023)(Rodnade).nes",          524304, 0x1177eb7a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_awol)
STD_ROM_FN(nes_awol)

struct BurnDriver BurnDrvnes_awol = {
	"nes_awol", NULL, NULL, NULL, "2023",
	"AWOL (HB)\0", NULL, "Rodnade", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_awolRomInfo, nes_awolRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Balloon Stand (HB)
static struct BurnRomInfo nes_ballstandRomDesc[] = {
	{ "Balloon Stand (2022)(Spazzylemons).nes",          24592, 0x1bb52cb6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ballstand)
STD_ROM_FN(nes_ballstand)

struct BurnDriver BurnDrvnes_ballstand = {
	"nes_ballstand", NULL, NULL, NULL, "2022",
	"Balloon Stand (HB)\0", NULL, "Spazzylemons", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_ballstandRomInfo, nes_ballstandRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bandana (HB)
static struct BurnRomInfo nes_bandanaRomDesc[] = {
	{ "Bandana (2021)(Rodnade).nes",          524304, 0x292de1a8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bandana)
STD_ROM_FN(nes_bandana)

struct BurnDriver BurnDrvnes_bandana = {
	"nes_bandana", NULL, NULL, NULL, "2021",
	"Bandana (HB)\0", NULL, "Rodnade", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_bandanaRomInfo, nes_bandanaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bare Metal 2.0 (HB)
static struct BurnRomInfo nes_bmetal2RomDesc[] = {
	{ "Bare Metal 2.0 (2021)(scarduadev).nes",          49168, 0xe37e0c59, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bmetal2)
STD_ROM_FN(nes_bmetal2)

struct BurnDriver BurnDrvnes_bmetal2 = {
	"nes_bmetal2", NULL, NULL, NULL, "2021",
	"Bare Metal 2.0 (HB)\0", "NesDev Competition build", "ScarduaDev", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM | GBF_PUZZLE, 0,
	NESGetZipName, nes_bmetal2RomInfo, nes_bmetal2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Basse Def Adventures (HB)
static struct BurnRomInfo nes_bassedefadvRomDesc[] = {
	{ "Basse Def Adventures (2019)(Broke Studio).nes",          524304, 0xbb87065d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bassedefadv)
STD_ROM_FN(nes_bassedefadv)

struct BurnDriver BurnDrvnes_bassedefadv = {
	"nes_bassedefadv", NULL, NULL, NULL, "2019",
	"Basse Def Adventures (HB)\0", NULL, "Broke Studio", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_bassedefadvRomInfo, nes_bassedefadvRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Pico Pico Grand Adventure (HB)
static struct BurnRomInfo nes_picopicoRomDesc[] = {
	{ "Pico Pico Grand Adventure (J)(2019)(Broke Studio).nes",          524304, 0x3950140d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_picopico)
STD_ROM_FN(nes_picopico)

struct BurnDriver BurnDrvnes_picopico = {
	"nes_picopico", "nes_bassedefadv", NULL, NULL, "2019-20",
	"Pico Pico Grand Adventure (HB)\0", NULL, "Columbus Circle", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_picopicoRomInfo, nes_picopicoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bat Lizard Bonanza (HB)
static struct BurnRomInfo nes_batlizardRomDesc[] = {
	{ "Bat Lizard Bonanza (2020)(John Vanderhoef).nes",          524304, 0x4418f0f3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_batlizard)
STD_ROM_FN(nes_batlizard)

struct BurnDriver BurnDrvnes_batlizard = {
	"nes_batlizard", NULL, NULL, NULL, "2020",
	"Bat Lizard Bonanza (HB)\0", NULL, "John Vanderhoef", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_batlizardRomInfo, nes_batlizardRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Battery Chad - Shock the World (HB)
static struct BurnRomInfo nes_batterychadRomDesc[] = {
	{ "Battery Chad - Shock the World (2019)(Formula Fanboy).nes",          524304, 0x030c4355, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_batterychad)
STD_ROM_FN(nes_batterychad)

struct BurnDriver BurnDrvnes_batterychad = {
	"nes_batterychad", NULL, NULL, NULL, "2019",
	"Battery Chad - Shock the World (HB)\0", NULL, "Formula Fanboy", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_batterychadRomInfo, nes_batterychadRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Battle Kid - Fortress of Peril (HB, Japan)
static struct BurnRomInfo nes_battlkidRomDesc[] = {
	{ "Battle Kid - Fortress of Peril (Japan)(2010)(Sivak Games).nes",          524304, 0xc7f3a581, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_battlkid)
STD_ROM_FN(nes_battlkid)

struct BurnDriver BurnDrvnes_battlkid = {
	"nes_battlkid", NULL, NULL, NULL, "2010",
	"Battle Kid - Fortress of Peril (HB, Japan)\0", NULL, "Sivak Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_battlkidRomInfo, nes_battlkidRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Battle Kid 2 - Mountain of Torment (HB, USA)
static struct BurnRomInfo nes_battlkid2RomDesc[] = {
	{ "Battle Kid 2 - Mountain of Torment (USA)(2012)(Sivak Games).nes",          524304, 0x4916dc6d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_battlkid2)
STD_ROM_FN(nes_battlkid2)

struct BurnDriver BurnDrvnes_battlkid2 = {
	"nes_battlkid2", NULL, NULL, NULL, "2012",
	"Battle Kid 2 - Mountain of Torment (HB, USA)\0", NULL, "Sivak Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_battlkid2RomInfo, nes_battlkid2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Battler (HB)
static struct BurnRomInfo nes_battlerRomDesc[] = {
	{ "Battler (2015)(Karu Gamo).nes",          40976, 0x38f65b2d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_battler)
STD_ROM_FN(nes_battler)

struct BurnDriver BurnDrvnes_battler = {
	"nes_battler", NULL, NULL, NULL, "2015",
	"Battler (HB)\0", NULL, "Karu Gamo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_battlerRomInfo, nes_battlerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Beat 'Em & Eat 'Em (HB)
static struct BurnRomInfo nes_beeeRomDesc[] = {
	{ "Beat 'Em & Eat 'Em v1.0 (2014)(FG Software).nes",          40976, 0x11175864, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_beee)
STD_ROM_FN(nes_beee)

struct BurnDriver BurnDrvnes_beee = {
	"nes_beee", NULL, NULL, NULL, "2014",
	"Beat 'Em & Eat 'Em (HB)\0", "Adult game", "FG Software", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_beeeRomInfo, nes_beeeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Beatles Adventures in Pepperland, The (GlobalHack)
static struct BurnRomInfo nes_beatlesadvRomDesc[] = {
	{ "The Beatles Adventures in Pepperland GlobHack (2021)(NesDraug).nes",          524304, 0xfa5e3fa2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_beatlesadv)
STD_ROM_FN(nes_beatlesadv)

struct BurnDriver BurnDrvnes_beatlesadv = {
	"nes_beatlesadv", "nes_smb2", NULL, NULL, "2021",
	"Beatles Adventures in Pepperland, The (GlobalHack)\0", NULL, "NesDraug", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW | BDF_CLONE | BDF_HOMEBREW | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_beatlesadvRomInfo, nes_beatlesadvRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// BeerSlinger (HB)
static struct BurnRomInfo nes_beerslingerRomDesc[] = {
	{ "BeerSlinger (2018)(Second Dimension).nes",          40976, 0xae0ebf22, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_beerslinger)
STD_ROM_FN(nes_beerslinger)

struct BurnDriver BurnDrvnes_beerslinger = {
	"nes_beerslinger", NULL, NULL, NULL, "2018",
	"BeerSlinger (HB)\0", NULL, "Second Dimension", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_beerslingerRomInfo, nes_beerslingerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Berserk (HB)
static struct BurnRomInfo nes_berserkRomDesc[] = {
	{ "Berzerk (2019)(Parisoft).nes",          65552, 0x25a46b45, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_berserk)
STD_ROM_FN(nes_berserk)

struct BurnDriver BurnDrvnes_berserk = {
	"nes_berserk", NULL, NULL, NULL, "2019",
	"Berserk (HB)\0", NULL, "Parisoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_berserkRomInfo, nes_berserkRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Beyond the Pins (HB)
static struct BurnRomInfo nes_beyopinsRomDesc[] = {
	{ "Beyond the Pins (2021)(KHAN Games).nes",          524304, 0xd5a3f7a0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_beyopins)
STD_ROM_FN(nes_beyopins)

struct BurnDriver BurnDrvnes_beyopins = {
	"nes_beyopins", NULL, NULL, NULL, "2021",
	"Beyond the Pins (HB)\0", NULL, "Khan Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_SPORTSMISC | GBF_ADV, 0,
	NESGetZipName, nes_beyopinsRomInfo, nes_beyopinsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Biocats (HB)
static struct BurnRomInfo nes_biocatsRomDesc[] = {
	{ "Biocats (2022)(PB Games).nes",          524304, 0x9fd3fcfe, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_biocats)
STD_ROM_FN(nes_biocats)

struct BurnDriver BurnDrvnes_biocats = {
	"nes_biocats", NULL, NULL, NULL, "2022",
	"Biocats (HB)\0", NULL, "PB Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_biocatsRomInfo, nes_biocatsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bio Hazard 8bit (HB)
static struct BurnRomInfo nes_biohaz8bitRomDesc[] = {
	{ "Bio Hazard 8bit (2022)(Zitz).nes",          524304, 0xdcc12cac, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_biohaz8bit)
STD_ROM_FN(nes_biohaz8bit)

struct BurnDriver BurnDrvnes_biohaz8bit = {
	"nes_biohaz8bit", NULL, NULL, NULL, "2022",
	"Bio Hazard 8bit (HB)\0", NULL, "Zitz", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_biohaz8bitRomInfo, nes_biohaz8bitRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Black Box Challenge (HB)
static struct BurnRomInfo nes_blackboxchaRomDesc[] = {
	{ "Black Box Challenge (2017)(Sly Dog Studios).nes",          524304, 0x6b30c83b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_blackboxcha)
STD_ROM_FN(nes_blackboxcha)

struct BurnDriver BurnDrvnes_blackboxcha = {
	"nes_blackboxcha", NULL, NULL, NULL, "2017",
	"Black Box Challenge (HB)\0", NULL, "Sly Dog Studios", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_blackboxchaRomInfo, nes_blackboxchaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Black Hole - Czarna Dziura (HB, v0.20)
static struct BurnRomInfo nes_blackholRomDesc[] = {
	{ "Black Hole - Czarna Dziura v0.20 (2021)(Siudym).nes",          131088, 0x8fd3a9a7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_blackhol)
STD_ROM_FN(nes_blackhol)

struct BurnDriver BurnDrvnes_blackhol = {
	"nes_blackhol", NULL, NULL, NULL, "2021",
	"Black Hole - Czarna Dziura (HB, v0.20)\0", NULL, "Siudym", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_blackholRomInfo, nes_blackholRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Blade Buster (HB)
static struct BurnRomInfo nes_bladebusterRomDesc[] = {
	{ "Blade Buster (2011)(HLC! Project).nes",          393232, 0x3aba6565, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bladebuster)
STD_ROM_FN(nes_bladebuster)

struct BurnDriver BurnDrvnes_bladebuster = {
	"nes_bladebuster", NULL, NULL, NULL, "2011",
	"Blade Buster (HB)\0", NULL, "HLC! Project (tm)", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_bladebusterRomInfo, nes_bladebusterRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Blaster Master - The Lost Key (Hack, v1.06)
// https://www.romhacking.net/hacks/8494/
static struct BurnRomInfo nes_blastermasterlkRomDesc[] = {
	{ "Blaster Master - The Lost Key v1.06 (2014-2024)(climax, HalDanGhor).nes",          262160, 0x56935623, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_blastermasterlk)
STD_ROM_FN(nes_blastermasterlk)

struct BurnDriver BurnDrvnes_blastermasterlk = {
	"nes_blastermasterlk", "nes_blastermaster", NULL, NULL, "2014-2024",
	"Blaster Master - The Lost Key (Hack, v1.06)\0", NULL, "climax, HalDanGhor", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_blastermasterlkRomInfo, nes_blastermasterlkRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Blazing Blocks (HB)
static struct BurnRomInfo nes_blazblocksRomDesc[] = {
	{ "Blazing Blocks (2023)(FG Software).nes",          65552, 0x3a8f9933, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_blazblocks)
STD_ROM_FN(nes_blazblocks)

struct BurnDriver BurnDrvnes_blazblocks = {
	"nes_blazblocks", NULL, NULL, NULL, "2023",
	"Blazing Blocks (HB)\0", NULL, "FG Software", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_blazblocksRomInfo, nes_blazblocksRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Blazing Rangers (HB)
static struct BurnRomInfo nes_blazrangRomDesc[] = {
	{ "Blazing Rangers (2021)(Karu Gamo).nes",          40976, 0xf11f92b4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_blazrang)
STD_ROM_FN(nes_blazrang)

struct BurnDriver BurnDrvnes_blazrang = {
	"nes_blazrang", NULL, NULL, NULL, "2021",
	"Blazing Rangers (HB)\0", NULL, "Karu Gamo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_blazrangRomInfo, nes_blazrangRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Blob Land (HB)
static struct BurnRomInfo nes_bloblandRomDesc[] = {
	{ "Blob Land (2020)(Wendel Scardua).nes",          40976, 0x89b129ef, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_blobland)
STD_ROM_FN(nes_blobland)

struct BurnDriver BurnDrvnes_blobland = {
	"nes_blobland", NULL, NULL, NULL, "2020",
	"Blob Land (HB)\0", NULL, "Wendel Scardua", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_bloblandRomInfo, nes_bloblandRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Blob Quest (HB)
static struct BurnRomInfo nes_blobquestRomDesc[] = {
	{ "Blob Quest (HB)(2021)(Tom Livak).nes",          32784, 0xe3ac2b6d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_blobquest)
STD_ROM_FN(nes_blobquest)

struct BurnDriver BurnDrvnes_blobquest = {
	"nes_blobquest", NULL, NULL, NULL, "2021",
	"Blob Quest (HB)\0", NULL, "Tom Livak", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_blobquestRomInfo, nes_blobquestRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Blockage (HB, v0.3.2)
static struct BurnRomInfo nes_blockageRomDesc[] = {
	{ "Blockage (HB, v0.3.2).nes",          40976, 0x1c5f7bcf, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_blockage)
STD_ROM_FN(nes_blockage)

struct BurnDriver BurnDrvnes_blockage = {
	"nes_blockage", NULL, NULL, NULL, "2019",
	"Blockage (HB, v0.3.2)\0", NULL, "Scott Lowe", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_blockageRomInfo, nes_blockageRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bloodfall (HB)
static struct BurnRomInfo nes_bloodfallRomDesc[] = {
	{ "Bloodfall (2019)(Dr. Ludus).nes",          40976, 0x3c5548ef, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bloodfall)
STD_ROM_FN(nes_bloodfall)

struct BurnDriver BurnDrvnes_bloodfall = {
	"nes_bloodfall", NULL, NULL, NULL, "2019",
	"Bloodfall (HB)\0", NULL, "Dr. Ludos", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_bloodfallRomInfo, nes_bloodfallRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Blow'Em Out! (HB)
static struct BurnRomInfo nes_blowemoutRomDesc[] = {
	{ "Blow'Em Out! (2018)(Second Dimension).nes",          40976, 0xdc1468fc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_blowemout)
STD_ROM_FN(nes_blowemout)

struct BurnDriver BurnDrvnes_blowemout = {
	"nes_blowemout", NULL, NULL, NULL, "2018",
	"Blow'Em Out! (HB)\0", NULL, "Second Dimension", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_blowemoutRomInfo, nes_blowemoutRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bobby Six Seven: Time Travelling Detective (HB)
static struct BurnRomInfo nes_bobsixsevenRomDesc[] = {
	{ "Bobby Six Seven - Time Traveling Detective (2023)(Calgames).nes",          524304, 0xbc33f79b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bobsixseven)
STD_ROM_FN(nes_bobsixseven)

struct BurnDriver BurnDrvnes_bobsixseven = {
	"nes_bobsixseven", NULL, NULL, NULL, "2022-23",
	"Bobby Six Seven: Time Travelling Detective (HB)\0", NULL, "CalGames", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_bobsixsevenRomInfo, nes_bobsixsevenRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// BoBL - Frog Update (HB, v1.2)
static struct BurnRomInfo nes_boblv2RomDesc[] = {
	{ "BoBL v1.2 (2021)(Morphcat Games).nes",          131088, 0x7a2efc9d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_boblv2)
STD_ROM_FN(nes_boblv2)

struct BurnDriver BurnDrvnes_boblv2 = {
	"nes_boblv2", NULL, NULL, NULL, "2021",
	"BoBL - Frog Update (HB, v1.2)\0", NULL, "Morphcat Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_boblv2RomInfo, nes_boblv2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// BoBL (HB, v1.1)
static struct BurnRomInfo nes_boblRomDesc[] = {
	{ "BoBL v1.1 (2020)(Morphcat Games).nes",          65552, 0x831956ea, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bobl)
STD_ROM_FN(nes_bobl)

struct BurnDriver BurnDrvnes_bobl = {
	"nes_bobl", "nes_boblv2", NULL, NULL, "2020",
	"BoBL (HB, v1.1)\0", NULL, "Morphcat Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_boblRomInfo, nes_boblRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bomberman - BoxArt (HB, v1.02)
static struct BurnRomInfo nes_bomberboxartRomDesc[] = {
	{ "Bomberman - BoxArt v1.02 (2017)(Corpse Grinder).nes",          32784, 0xcb68a7fc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bomberboxart)
STD_ROM_FN(nes_bomberboxart)

struct BurnDriver BurnDrvnes_bomberboxart = {
	"nes_bomberboxart", NULL, NULL, NULL, "2017",
	"Bomberman - BoxArt (HB, v1.02)\0", NULL, "Corpse Grinder", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_ACTION | GBF_MAZE, 0,
	NESGetZipName, nes_bomberboxartRomInfo, nes_bomberboxartRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bomb Sweeper (HB)
static struct BurnRomInfo nes_bombsweeperRomDesc[] = {
	{ "Bomb Sweeper (2002)(SNOWBRO).nes",          24592, 0xe667858d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bombsweeper)
STD_ROM_FN(nes_bombsweeper)

struct BurnDriver BurnDrvnes_bombsweeper = {
	"nes_bombsweeper", NULL, NULL, NULL, "2002",
	"Bomb Sweeper (HB)\0", NULL, "SNOWBRO", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_MAZE, 0,
	NESGetZipName, nes_bombsweeperRomInfo, nes_bombsweeperRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bootee (HB)
static struct BurnRomInfo nes_mojontwibooRomDesc[] = {
	{ "Bootee (2018)(The Mojon Twins).nes",          40976, 0xc71f42bc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mojontwiboo)
STD_ROM_FN(nes_mojontwiboo)

struct BurnDriver BurnDrvnes_mojontwiboo = {
	"nes_mojontwiboo", NULL, NULL, NULL, "2018",
	"Bootee (HB)\0", NULL, "The Mojon Twins", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_mojontwibooRomInfo, nes_mojontwibooRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bovinium Quest (HB)
static struct BurnRomInfo nes_boviquestRomDesc[] = {
	{ "Bovinium Quest (2019)(Grey Badge).nes",          40976, 0xdb466003, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_boviquest)
STD_ROM_FN(nes_boviquest)

struct BurnDriver BurnDrvnes_boviquest = {
	"nes_boviquest", NULL, NULL, NULL, "2019",
	"Bovinium Quest (HB)\0", NULL, "Grey Badge", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_boviquestRomInfo, nes_boviquestRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bowels of the Beast (HB)
static struct BurnRomInfo nes_bowbeastRomDesc[] = {
	{ "Bowels of the Beast (2021)(T-bone).nes",          524304, 0x2002b239, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bowbeast)
STD_ROM_FN(nes_bowbeast)

struct BurnDriver BurnDrvnes_bowbeast = {
	"nes_bowbeast", NULL, NULL, NULL, "2021",
	"Bowels of the Beast (HB)\0", NULL, "T-Bone Studios", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_bowbeastRomInfo, nes_bowbeastRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bubble Bobble Deluxe (Hack)
static struct BurnRomInfo nes_bubblebobbledxRomDesc[] = {
	{ "Bubble Bobble Deluxe (2021)(Polar Hacker).nes",          163856, 0x198125ce, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bubblebobbledx)
STD_ROM_FN(nes_bubblebobbledx)

struct BurnDriver BurnDrvnes_bubblebobbledx = {
	"nes_bubblebobbledx", "nes_bubblebobble", NULL, NULL, "2018",
	"Bubble Bobble Deluxe (Hack)\0", NULL, "Polar Hacker", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_bubblebobbledxRomInfo, nes_bubblebobbledxRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Burn'em Down (HB)
static struct BurnRomInfo nes_burndownRomDesc[] = {
	{ "Burn'em Down (2024)(Dr. Colossus).nes",          524304, 0xb535324b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_burndown)
STD_ROM_FN(nes_burndown)

struct BurnDriver BurnDrvnes_burndown = {
	"nes_burndown", NULL, NULL, NULL, "2024",
	"Burn'em Down (HB)\0", NULL, "Dr. Colossus", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_burndownRomInfo, nes_burndownRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bustina (HB, v1.04)
static struct BurnRomInfo nes_bustinaRomDesc[] = {
	{ "Bustina v1.04 (2022-24)(Adam Holmes).nes",          524304, 0xb82ed907, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bustina)
STD_ROM_FN(nes_bustina)

struct BurnDriver BurnDrvnes_bustina = {
	"nes_bustina", NULL, NULL, NULL, "2022-24",
	"Bustina (HB, v1.04)\0", NULL, "Adam Holmes", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_bustinaRomInfo, nes_bustinaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cadaverion (HB)
static struct BurnRomInfo nes_cadaverionRomDesc[] = {
	{ "Cadaverion (2018)(The Mojon Twins).nes",          40976, 0x6a45c96a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cadaverion)
STD_ROM_FN(nes_cadaverion)

struct BurnDriver BurnDrvnes_cadaverion = {
	"nes_cadaverion", NULL, NULL, NULL, "2018",
	"Cadaverion (HB)\0", NULL, "The Mojon Twins", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE | GBF_ADV, 0,
	NESGetZipName, nes_cadaverionRomInfo, nes_cadaverionRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Carpet Shark (HB)
static struct BurnRomInfo nes_carpetsharkRomDesc[] = {
	{ "Carpet Shark (2021)(Fista Productions).nes",          524304, 0x8ab5f2e0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_carpetshark)
STD_ROM_FN(nes_carpetshark)

struct BurnDriver BurnDrvnes_carpetshark = {
	"nes_carpetshark", NULL, NULL, NULL, "2021",
	"Carpet Shark (HB)\0", NULL, "Fista Productions", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_carpetsharkRomInfo, nes_carpetsharkRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Catmercs - Big Bug Invasion (HB, RC1)
static struct BurnRomInfo nes_catmercsRomDesc[] = {
	{ "Catmercs - Big Bug Invasion RC1 (2023)(Team Disposable).nes",          65552, 0xa0f31631, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_catmercs)
STD_ROM_FN(nes_catmercs)

struct BurnDriver BurnDrvnes_catmercs = {
	"nes_catmercs", NULL, NULL, NULL, "2023",
	"Catmercs - Big Bug Invasion (HB, RC1)\0", NULL, "Team Disposable", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_catmercsRomInfo, nes_catmercsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cave (HB)
static struct BurnRomInfo nes_caveRomDesc[] = {
	{ "Cave (2017)(The Mojon Twins).nes",          49168, 0xb86ce86b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cave)
STD_ROM_FN(nes_cave)

struct BurnDriver BurnDrvnes_cave = {
	"nes_cave", NULL, NULL, NULL, "2017",
	"Cave (HB)\0", NULL, "The Mojon Twins", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_caveRomInfo, nes_caveRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cave Driller (HB, v2.2)
static struct BurnRomInfo nes_cavedrillRomDesc[] = {
	{ "Cave Driller v2.2 (2021)(Mazionach).nes",          40976, 0xf11b4a70, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cavedrill)
STD_ROM_FN(nes_cavedrill)

struct BurnDriver BurnDrvnes_cavedrill = {
	"nes_cavedrill", "nes_cavedrillv3", NULL, NULL, "2021",
	"Cave Driller (HB, v2.2)\0", NULL, "Mazionach", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_cavedrillRomInfo, nes_cavedrillRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cave Driller (HB, v3.0)
static struct BurnRomInfo nes_cavedrillv3RomDesc[] = {
	{ "Cave Driller v3.0 (2023)(Mazionach).nes",          40976, 0x084d86c8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cavedrillv3)
STD_ROM_FN(nes_cavedrillv3)

struct BurnDriver BurnDrvnes_cavedrillv3 = {
	"nes_cavedrillv3", NULL, NULL, NULL, "2023",
	"Cave Driller (HB, v3.0)\0", NULL, "Mazionach", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_cavedrillv3RomInfo, nes_cavedrillv3RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Celeste Mario's Zap & Dash! (Hack)
// https://www.romhacking.net/hacks/7915/
static struct BurnRomInfo nes_celestemarioRomDesc[] = {
	{ "Celeste Mario's Zap & Dash! (2023)(w7n).nes",          393232, 0xabc3bc39, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_celestemario)
STD_ROM_FN(nes_celestemario)

struct BurnDriver BurnDrvnes_celestemario = {
	"nes_celestemario", "nes_smb", NULL, NULL, "2023",
	"Celeste Mario's Zap & Dash! (Hack)\0", NULL, "w7n", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_celestemarioRomInfo, nes_celestemarioRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Chase (HB)
static struct BurnRomInfo nes_chaseRomDesc[] = {
	{ "Chase (2012)(shiru).nes",          24592, 0xb887529d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_chase)
STD_ROM_FN(nes_chase)

struct BurnDriver BurnDrvnes_chase = {
	"nes_chase", NULL, NULL, NULL, "2012",
	"Chase (HB)\0", NULL, "Shiru", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION | GBF_MAZE, 0,
	NESGetZipName, nes_chaseRomInfo, nes_chaseRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Che-Man (HB)
static struct BurnRomInfo nes_chemanRomDesc[] = {
	{ "Che-Man (HB).nes",          40976, 0x9677c8a1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cheman)
STD_ROM_FN(nes_cheman)

struct BurnDriver BurnDrvnes_cheman = {
	"nes_cheman", NULL, NULL, NULL, "2018",
	"Che-Man (HB)\0", NULL, "The Mojon Twins", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_chemanRomInfo, nes_chemanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cheril Perils Classic (HB)
static struct BurnRomInfo nes_cherilpcRomDesc[] = {
	{ "Cheril Perils Classic (2018)(The Mojon Twins).nes",          40976, 0x8132afd5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cherilpc)
STD_ROM_FN(nes_cherilpc)

struct BurnDriver BurnDrvnes_cherilpc = {
	"nes_cherilpc", NULL, NULL, NULL, "2018",
	"Cheril Perils Classic (HB)\0", NULL, "The Mojon Twins", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_cherilpcRomInfo, nes_cherilpcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cheril The Goddess (HB)
static struct BurnRomInfo nes_mojontwichegodRomDesc[] = {
	{ "Cheril The Goddess (2017)(The Mojon Twins).nes",          65552, 0xe7c81856, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mojontwichegod)
STD_ROM_FN(nes_mojontwichegod)

struct BurnDriver BurnDrvnes_mojontwichegod = {
	"nes_mojontwichegod", NULL, NULL, NULL, "2017",
	"Cheril The Goddess (HB)\0", NULL, "The Mojon Twins", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_mojontwichegodRomInfo, nes_mojontwichegodRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cheril The Writer (HB)
static struct BurnRomInfo nes_mojontwichewriRomDesc[] = {
	{ "Cheril The Writer (2018)(The Mojon Twins).nes",          131088, 0x2405a68f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mojontwichewri)
STD_ROM_FN(nes_mojontwichewri)

struct BurnDriver BurnDrvnes_mojontwichewri = {
	"nes_mojontwichewri", NULL, NULL, NULL, "2018",
	"Cheril The Writer (HB)\0", NULL, "The Mojon Twins", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_mojontwichewriRomInfo, nes_mojontwichewriRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Chibi Monster Br4wl (HB)
static struct BurnRomInfo nes_cmbr4wlRomDesc[] = {
	{ "Chibi Monster Br4wl (2022)(dalecoop Studio).nes",          524304, 0x0eaa7806, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cmbr4wl)
STD_ROM_FN(nes_cmbr4wl)

struct BurnDriver BurnDrvnes_cmbr4wl = {
	"nes_cmbr4wl", NULL, NULL, NULL, "2022",
	"Chibi Monster Br4wl (HB)\0", NULL, "dalecoop Studio", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 4, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_cmbr4wlRomInfo, nes_cmbr4wlRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Chicken Of The Farm (HB)
static struct BurnRomInfo nes_chickenfarmRomDesc[] = {
	{ "Chicken Of The Farm (2019)(mitch3a and link_7777).nes",          40976, 0x60e65140, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_chickenfarm)
STD_ROM_FN(nes_chickenfarm)

struct BurnDriver BurnDrvnes_chickenfarm = {
	"nes_chickenfarm", NULL, NULL, NULL, "2019",
	"Chicken Of The Farm (HB)\0", NULL, "mitch3a, link_7777", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_chickenfarmRomInfo, nes_chickenfarmRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Chrono Knight (HB)
static struct BurnRomInfo nes_chknightRomDesc[] = {
	{ "Chrono Knight (2020)(Artix Games).nes",          524304, 0x88a47918, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_chknight)
STD_ROM_FN(nes_chknight)

struct BurnDriver BurnDrvnes_chknight = {
	"nes_chknight", NULL, NULL, NULL, "2020",
	"Chrono Knight (HB)\0", NULL, "Artix Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_chknightRomInfo, nes_chknightRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// ChuChu Rocket! (HB, v. alpha)
static struct BurnRomInfo nes_chuchuaRomDesc[] = {
	{ "ChuChu Rocket! (v.alpha)(2010)(Dwedit).nes",          163856, 0xac44ecdc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_chuchua)
STD_ROM_FN(nes_chuchua)

struct BurnDriver BurnDrvnes_chuchua = {
	"nes_chuchua", NULL, NULL, NULL, "2010",
	"ChuChu Rocket! (HB, v. alpha)\0", NULL, "Dwedit", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 4, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_chuchuaRomInfo, nes_chuchuaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Chumlee's Adventure - The Quest for Pinky (HB)
static struct BurnRomInfo nes_chumleeadvRomDesc[] = {
	{ "Chumlee Adventure (2020)(Khan Games).nes",          131088, 0x0f81f876, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_chumleeadv)
STD_ROM_FN(nes_chumleeadv)

struct BurnDriver BurnDrvnes_chumleeadv = {
	"nes_chumleeadv", NULL, NULL, NULL, "2020",
	"Chumlee's Adventure - The Quest for Pinky (HB)\0", NULL, "Khan Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_chumleeadvRomInfo, nes_chumleeadvRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// City Trouble (HB)
static struct BurnRomInfo nes_citytroubleRomDesc[] = {
	{ "City Trouble (2016)(Den Kat Games).nes",          40976, 0x2481be7e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_citytrouble)
STD_ROM_FN(nes_citytrouble)

struct BurnDriver BurnDrvnes_citytrouble = {
	"nes_citytrouble", NULL, NULL, NULL, "2016",
	"City Trouble (HB)\0", NULL, "Den Kat Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_citytroubleRomInfo, nes_citytroubleRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Coin World (HB)
static struct BurnRomInfo nes_coinworldRomDesc[] = {
	{ "Coin World (2021)(CMYKSoft).nes",          40976, 0x6775b5d1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_coinworld)
STD_ROM_FN(nes_coinworld)

struct BurnDriver BurnDrvnes_coinworld = {
	"nes_coinworld", NULL, NULL, NULL, "2021",
	"Coin World (HB)\0", NULL, "CMYKSoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_coinworldRomInfo, nes_coinworldRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Copper Jacket (HB)
static struct BurnRomInfo nes_copjackRomDesc[] = {
	{ "Copper Jacket - Digital Release (2023)(Monsoon Studios).nes",           65552, 0xf88202b0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_copjack)
STD_ROM_FN(nes_copjack)

struct BurnDriver BurnDrvnes_copjack = {
	"nes_copjack", NULL, NULL, NULL, "2023",
	"Copper Jacket (HB)\0", NULL, "Monsoon Studios", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_copjackRomInfo, nes_copjackRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Convoy, The (HB)
static struct BurnRomInfo nes_convoyRomDesc[] = {
	{ "Convoy, The (2023)(FG Software).nes",          24592, 0xe187eabf, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_convoy)
STD_ROM_FN(nes_convoy)

struct BurnDriver BurnDrvnes_convoy = {
	"nes_convoy", NULL, NULL, NULL, "2023",
	"Convoy, The (HB)\0", NULL, "FG Software", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_convoyRomInfo, nes_convoyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Courier (HB)
static struct BurnRomInfo nes_courierRomDesc[] = {
	{ "Courier (2024)(Khan Games).nes",          262160, 0x6e4284ac, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_courier)
STD_ROM_FN(nes_courier)

struct BurnDriver BurnDrvnes_courier = {
	"nes_courier", NULL, NULL, NULL, "2024",
	"Courier (HB)\0", NULL, "Khan Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_courierRomInfo, nes_courierRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cowlitz Gamers 2nd Adventure (HB)
static struct BurnRomInfo nes_cowligam2ndadvRomDesc[] = {
	{ "Cowlitz Gamers 2nd Adventure (2017)(Cowlitz).nes",          131088, 0x0db2dd59, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cowligam2ndadv)
STD_ROM_FN(nes_cowligam2ndadv)

struct BurnDriver BurnDrvnes_cowligam2ndadv = {
	"nes_cowligam2ndadv", NULL, NULL, NULL, "2017",
	"Cowlitz Gamers 2nd Adventure (HB)\0", NULL, "Cowlitz", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_cowligam2ndadvRomInfo, nes_cowligam2ndadvRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cowlitz Gamers Adventure (HB)
static struct BurnRomInfo nes_cowligamadvRomDesc[] = {
	{ "Cowlitz Gamers Adventure (2016)(Cowlitz).nes",          32784, 0x0ae2354b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cowligamadv)
STD_ROM_FN(nes_cowligamadv)

struct BurnDriver BurnDrvnes_cowligamadv = {
	"nes_cowligamadv", NULL, NULL, NULL, "2016",
	"Cowlitz Gamers Adventure (HB)\0", NULL, "Cowlitz", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_cowligamadvRomInfo, nes_cowligamadvRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cowlitz Gamers Lost Adventure (HB)
static struct BurnRomInfo nes_cowligamlostadvRomDesc[] = {
	{ "Cowlitz Gamers Lost Adventure (2020)(Cowlitz).nes",          65552, 0x6ded904f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cowligamlostadv)
STD_ROM_FN(nes_cowligamlostadv)

struct BurnDriver BurnDrvnes_cowligamlostadv = {
	"nes_cowligamlostadv", NULL, NULL, NULL, "2020",
	"Cowlitz Gamers Lost Adventure (HB)\0", NULL, "Cowlitz", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_cowligamlostadvRomInfo, nes_cowligamlostadvRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Crabbie Attack! (HB)
static struct BurnRomInfo nes_crabbieatkRomDesc[] = {
	{ "Crabbie Attack! (2023)(TurtleRescueNES).nes",          524304, 0x9838a3d0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_crabbieatk)
STD_ROM_FN(nes_crabbieatk)

struct BurnDriver BurnDrvnes_crabbieatk = {
	"nes_crabbieatk", NULL, NULL, NULL, "2023",
	"Crabbie Attack! (HB)\0", NULL, "TurtleRescueNES", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_crabbieatkRomInfo, nes_crabbieatkRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Crap Job (HB)
static struct BurnRomInfo nes_crapjobRomDesc[] = {
	{ "Crap Job (2021)(Oniric Factor).nes",          524304, 0xcfa265ab, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_crapjob)
STD_ROM_FN(nes_crapjob)

struct BurnDriver BurnDrvnes_crapjob = {
	"nes_crapjob", NULL, NULL, NULL, "2021",
	"Crap Job (HB)\0", NULL, "Oniric Factor", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_crapjobRomInfo, nes_crapjobRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Crater Song (HB, v1.03)
static struct BurnRomInfo nes_cratersongRomDesc[] = {
	{ "Crater Song v1.03 (2024)(John Vanderhoef).nes",          524304, 0x48df7653, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cratersong)
STD_ROM_FN(nes_cratersong)

struct BurnDriver BurnDrvnes_cratersong = {
	"nes_cratersong", NULL, NULL, NULL, "2024",
	"Crater Song (HB, v1.03)\0", NULL, "John Vanderhoef", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_cratersongRomInfo, nes_cratersongRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Creepy Brawlers (HB)
static struct BurnRomInfo nes_creepybrawlersRomDesc[] = {
	{ "Creepy Brawlers (2017)(Mega Cat Studios).nes",          524304, 0xc8f05be4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_creepybrawlers)
STD_ROM_FN(nes_creepybrawlers)

struct BurnDriver BurnDrvnes_creepybrawlers = {
	"nes_creepybrawlers", NULL, NULL, NULL, "2017",
	"Creepy Brawlers (HB)\0", NULL, "Mega Cat Studios", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_creepybrawlersRomInfo, nes_creepybrawlersRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Crillion (HB, v1.1)
static struct BurnRomInfo nes_crillionRomDesc[] = {
	{ "Crillion v1.1 (2023)(kevin81).nes",          24592, 0x3eaa1bb9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_crillion)
STD_ROM_FN(nes_crillion)

struct BurnDriver BurnDrvnes_crillion = {
	"nes_crillion", NULL, NULL, NULL, "2023",
	"Crillion (HB, v1.1)\0", NULL, "kevin81", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_crillionRomInfo, nes_crillionRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Crypto (HB)
static struct BurnRomInfo nes_cryptoRomDesc[] = {
	{ "Crypto (HB).nes",          49168, 0x45aaa381, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_crypto)
STD_ROM_FN(nes_crypto)

struct BurnDriver BurnDrvnes_crypto = {
	"nes_crypto", NULL, NULL, NULL, "2016",
	"Crypto (HB)\0", NULL, "EEMU", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_cryptoRomInfo, nes_cryptoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cursed Crown (HB)
static struct BurnRomInfo nes_cursedcrownRomDesc[] = {
	{ "Cursed Crown (2024)(Martin Reimer).nes",          131088, 0x3b4f3b90, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cursedcrown)
STD_ROM_FN(nes_cursedcrown)

struct BurnDriver BurnDrvnes_cursedcrown = {
	"nes_cursedcrown", NULL, NULL, NULL, "2024",
	"Cursed Crown (HB)\0", NULL, "Martin Reimer", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_cursedcrownRomInfo, nes_cursedcrownRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// DataMan (HB)
static struct BurnRomInfo nes_datamanRomDesc[] = {
	{ "DataMan (2024)(Darkbits, Broke Studio).nes",          131088, 0xefde1705, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dataman)
STD_ROM_FN(nes_dataman)

struct BurnDriver BurnDrvnes_dataman = {
	"nes_dataman", NULL, NULL, NULL, "2024",
	"DataMan (HB)\0", NULL, "Darkbits - Broke Studio", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_datamanRomInfo, nes_datamanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dark Gimmick (GlobalHack, v1.1)
static struct BurnRomInfo nes_dgimmickRomDesc[] = {
	{ "Dark Gimmick v1.1 (2014).nes",          393232, 0xd7ddb1d6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dgimmick)
STD_ROM_FN(nes_dgimmick)

struct BurnDriver BurnDrvnes_dgimmick = {
	"nes_dgimmick", "nes_gimmick", NULL, NULL, "2014",
	"Dark Gimmick (GlobalHack, v1.1)\0", NULL, "Berion - Dizzy9", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_dgimmickRomInfo, nes_dgimmickRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ddream Ddiver (HB)
static struct BurnRomInfo nes_ddreamddiverRomDesc[] = {
	{ "Ddream Ddiver (2022)(Game Losers).nes",          524304, 0x26943006, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ddreamddiver)
STD_ROM_FN(nes_ddreamddiver)

struct BurnDriver BurnDrvnes_ddreamddiver = {
	"nes_ddreamddiver", NULL, NULL, NULL, "2022",
	"Ddream Ddiver (HB)\0", NULL, "Game Losers", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_ddreamddiverRomInfo, nes_ddreamddiverRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Deadpool (GlobalHack)
// https://www.romhacking.net/hacks/4723/
static struct BurnRomInfo nes_deadpoolRomDesc[] = {
	{ "Deadpool Globalhack (2019)(Techmoon).nes",          786448, 0x5e36e542, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_deadpool)
STD_ROM_FN(nes_deadpool)

struct BurnDriver BurnDrvnes_deadpool = {
	"nes_deadpool", "nes_ninjagaiden", NULL, NULL, "2019",
	"Deadpool (GlobalHack)\0", NULL, "Techmoon", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW | BDF_HACK, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, nes_deadpoolRomInfo, nes_deadpoolRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Deadpool Special Mission (GlobalHack, v1.3, Alt 1)
// https://www.romhacking.net/hacks/8291/
static struct BurnRomInfo nes_deadpoolsm1RomDesc[] = {
	{ "Deadpool Special Mission v1.3 MMC3 (2023)(Techmoon).nes",          393232, 0xf5565dab, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_deadpoolsm1)
STD_ROM_FN(nes_deadpoolsm1)

struct BurnDriver BurnDrvnes_deadpoolsm1 = {
	"nes_deadpoolsm1", "nes_contra", NULL, NULL, "2023",
	"Deadpool Special Mission (GlobalHack, v1.3, Alt 1)\0", NULL, "Techmoon", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW | BDF_HACK, 2, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_deadpoolsm1RomInfo, nes_deadpoolsm1RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Deadpool Special Mission (GlobalHack, v1.3, Alt 2)
// https://www.romhacking.net/hacks/8291/
static struct BurnRomInfo nes_deadpoolsm2RomDesc[] = {
	{ "Deadpool Special Mission v1.3 VCR2 (2023)(Techmoon).nes",          262160, 0x245b8aa0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_deadpoolsm2)
STD_ROM_FN(nes_deadpoolsm2)

struct BurnDriver BurnDrvnes_deadpoolsm2 = {
	"nes_deadpoolsm2", "nes_contra", NULL, NULL, "2023",
	"Deadpool Special Mission (GlobalHack, v1.3, Alt 2)\0", NULL, "Techmoon", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW | BDF_HACK, 2, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_deadpoolsm2RomInfo, nes_deadpoolsm2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dead Tomb (HB)
static struct BurnRomInfo nes_deadtombRomDesc[] = {
	{ "Dead Tomb (2020)(CollectorVision).nes",          262160, 0x0ab3480b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_deadtomb)
STD_ROM_FN(nes_deadtomb)

struct BurnDriver BurnDrvnes_deadtomb = {
	"nes_deadtomb", NULL, NULL, NULL, "2020",
	"Dead Tomb (HB)\0", NULL, "CollectorVision Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_deadtombRomInfo, nes_deadtombRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Demon District (HB)
static struct BurnRomInfo nes_demondistrictRomDesc[] = {
	{ "Demon District (HB).nes",          319504, 0x33e22dcb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_demondistrict)
STD_ROM_FN(nes_demondistrict)

struct BurnDriver BurnDrvnes_demondistrict = {
	"nes_demondistrict", NULL, NULL, NULL, "2019",
	"Demon District (HB)\0", NULL, "Klonoa", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_demondistrictRomInfo, nes_demondistrictRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Deth Complex (HB)
static struct BurnRomInfo nes_dethcomplexRomDesc[] = {
	{ "Deth Complex (2022)(T-bone).nes",          524304, 0x7b213380, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dethcomplex)
STD_ROM_FN(nes_dethcomplex)

struct BurnDriver BurnDrvnes_dethcomplex = {
	"nes_dethcomplex", NULL, NULL, NULL, "2022",
	"Deth Complex (HB)\0", NULL, "T-Bone Studios", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_dethcomplexRomInfo, nes_dethcomplexRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Deth Complex 2 (HB)
static struct BurnRomInfo nes_dethcomplex2RomDesc[] = {
	{ "Deth Complex 2 (2022)(T-bone).nes",          524304, 0xaf32771c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dethcomplex2)
STD_ROM_FN(nes_dethcomplex2)

struct BurnDriver BurnDrvnes_dethcomplex2 = {
	"nes_dethcomplex2", NULL, NULL, NULL, "2022",
	"Deth Complex 2 (HB)\0", NULL, "T-Bone Studios", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_dethcomplex2RomInfo, nes_dethcomplex2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dimension Shift (HB)
static struct BurnRomInfo nes_dimshiftRomDesc[] = {
	{ "Dimension Shift (2020)(Fix94, Mugi).nes",          524304, 0xcfaf9acd, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dimshift)
STD_ROM_FN(nes_dimshift)

struct BurnDriver BurnDrvnes_dimshift = {
	"nes_dimshift", NULL, NULL, NULL, "2020",
	"Dimension Shift (HB)\0", NULL, "Fix94, Mugi", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_dimshiftRomInfo, nes_dimshiftRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Donsol (HB, v15)
static struct BurnRomInfo nes_donsolRomDesc[] = {
	{ "Donsol v.15 (2017)(Rek & Devine).nes",          24592, 0xa140826e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_donsol)
STD_ROM_FN(nes_donsol)

struct BurnDriver BurnDrvnes_donsol = {
	"nes_donsol", NULL, NULL, NULL, "2017",
	"Donsol (HB, v15)\0", NULL, "Rek & Devine", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_CARD | GBF_RPG, 0,
	NESGetZipName, nes_donsolRomInfo, nes_donsolRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Doodle World (HB)
static struct BurnRomInfo nes_doodleworldRomDesc[] = {
	{ "Doodle World (2020)(Nate Peters).nes",          524304, 0x6c71a681, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_doodleworld)
STD_ROM_FN(nes_doodleworld)

struct BurnDriver BurnDrvnes_doodleworld = {
	"nes_doodleworld", NULL, NULL, NULL, "2020",
	"Doodle World (HB)\0", NULL, "Nate Peters", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_doodleworldRomInfo, nes_doodleworldRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Doodle World Redrawn (HB)
static struct BurnRomInfo nes_doodleworldrdwRomDesc[] = {
	{ "Doodle World Redrawn (2022)(Nate Peters).nes",          524304, 0x1fb01c4f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_doodleworldrdw)
STD_ROM_FN(nes_doodleworldrdw)

struct BurnDriver BurnDrvnes_doodleworldrdw = {
	"nes_doodleworldrdw", NULL, NULL, NULL, "2022",
	"Doodle World Redrawn (HB)\0", NULL, "Nate Peters", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_doodleworldrdwRomInfo, nes_doodleworldrdwRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Draiocht (HB)
static struct BurnRomInfo nes_draiochtRomDesc[] = {
	{ "Draiocht (HB).nes",          40976, 0x3e7aa82d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_draiocht)
STD_ROM_FN(nes_draiocht)

struct BurnDriver BurnDrvnes_draiocht = {
	"nes_draiocht", NULL, NULL, NULL, "2019",
	"Draiocht (HB)\0", NULL, "Mega Cat Studios", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_draiochtRomInfo, nes_draiochtRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dr. Garfield (Hack, v22)
static struct BurnRomInfo nes_drgarfieldRomDesc[] = {
	{ "Dr. Garfield hack v22 (2022)(Pangent Technologies).nes",          114704, 0xfdd0a135, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_drgarfield)
STD_ROM_FN(nes_drgarfield)

struct BurnDriver BurnDrvnes_drgarfield = {
	"nes_drgarfield", "nes_drmario", NULL, NULL, "2022",
	"Dr. Garfield (Hack, v22)\0", NULL, "Pangent Technologies", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_drgarfieldRomInfo, nes_drgarfieldRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Driar (HB)
static struct BurnRomInfo nes_driarRomDesc[] = {
	{ "Driar (2012)(Eriksson & Adolfsson).nes",          131088, 0x2c31ce23, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_driar)
STD_ROM_FN(nes_driar)

struct BurnDriver BurnDrvnes_driar = {
	"nes_driar", NULL, NULL, NULL, "2018",
	"Driar (HB)\0", NULL, "Eriksson & Adolfsson", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_driarRomInfo, nes_driarRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dude - The Deck Swabber (HB)
static struct BurnRomInfo nes_dudeRomDesc[] = {
	{ "Dude - The Deck Swabber (2023)(Richard Oz).nes",          131088, 0x521570ed, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dude)
STD_ROM_FN(nes_dude)

struct BurnDriver BurnDrvnes_dude = {
	"nes_dude", NULL, NULL, NULL, "2023",
	"Dude - The Deck Swabber (HB)\0", NULL, "Richard Oz", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_dudeRomInfo, nes_dudeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dungeons & Doomknights (HB)
static struct BurnRomInfo nes_dungdoomRomDesc[] = {
	{ "Dungeons & Doomknights (2021)(Artix Ent.).nes",          524304, 0xd4e96569, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dungdoom)
STD_ROM_FN(nes_dungdoom)

struct BurnDriver BurnDrvnes_dungdoom = {
	"nes_dungdoom", NULL, NULL, NULL, "2021",
	"Dungeons & Doomknights (HB)\0", NULL, "Artix Entertainment", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_dungdoomRomInfo, nes_dungdoomRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dushlan (HB)
static struct BurnRomInfo nes_dushlanRomDesc[] = {
	{ "Dushlan (2016)(Peter McQuillan).nes",          40976, 0x07614f71, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dushlan)
STD_ROM_FN(nes_dushlan)

struct BurnDriver BurnDrvnes_dushlan = {
	"nes_dushlan", NULL, NULL, NULL, "2016",
	"Dushlan (HB)\0", NULL, "Peter McQuillan", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_dushlanRomInfo, nes_dushlanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// D'Veel'Ng (HB)
static struct BurnRomInfo nes_dveelngRomDesc[] = {
	{ "D'Veel'Ng (2015)(The Mojon Twins).nes",          40976, 0x7a810742, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dveelng)
STD_ROM_FN(nes_dveelng)

struct BurnDriver BurnDrvnes_dveelng = {
	"nes_dveelng", NULL, NULL, NULL, "2015",
	"D'Veel'Ng (HB)\0", NULL, "The Mojon Twins", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_dveelngRomInfo, nes_dveelngRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// E.T. - The Extra Terrestrial (HB)
static struct BurnRomInfo nes_etRomDesc[] = {
	{ "E.T. (2014)(Khan Games).nes",          131088, 0xc1878830, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_et)
STD_ROM_FN(nes_et)

struct BurnDriver BurnDrvnes_et = {
	"nes_et", NULL, NULL, NULL, "2014",
	"E.T. - The Extra Terrestrial (HB)\0", NULL, "Khan Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_etRomInfo, nes_etRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// E.T. - The Extra Terrestrial DX (HB)
static struct BurnRomInfo nes_etdxRomDesc[] = {
	{ "E.T. The Extra Terrestrial DX (2019)(pacnsacdave).nes",          524304, 0xac82d2b4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_etdx)
STD_ROM_FN(nes_etdx)

struct BurnDriver BurnDrvnes_etdx = {
	"nes_etdx", "nes_et", NULL, NULL, "2019",
	"E.T. - The Extra Terrestrial DX (HB)\0", NULL, "Khan Games - pacnsacdave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW | BDF_HACK, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_etdxRomInfo, nes_etdxRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// EEEAAAOOO - aka AAAEEEOOO (HB, Tech-Demo)
static struct BurnRomInfo nes_eeeaaaoooRomDesc[] = {
	{ "EEEAAAOOO (HB).nes",          589840, 0xea1cb7b6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_eeeaaaooo)
STD_ROM_FN(nes_eeeaaaooo)

struct BurnDriver BurnDrvnes_eeeaaaooo = {
	"nes_eeeaaaooo", NULL, NULL, NULL, "2020",
	"EEEAAAOOO - aka AAAEEEOOO (HB, Tech-Demo)\0", NULL, "N.K", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW | BDF_DEMO, 1, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_eeeaaaoooRomInfo, nes_eeeaaaoooRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Enigmacore (HB)
static struct BurnRomInfo nes_enigmacoreRomDesc[] = {
	{ "Enigmacore (2015)(J. Kane & K. Hanley).nes",          40976, 0xcf680195, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_enigmacore)
STD_ROM_FN(nes_enigmacore)

struct BurnDriver BurnDrvnes_enigmacore = {
	"nes_enigmacore", NULL, NULL, NULL, "2015",
	"Enigmacore (HB)\0", NULL, "J. Kane & K. Hanley", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_enigmacoreRomInfo, nes_enigmacoreRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Enormous Adventures (HB, v1.1)
static struct BurnRomInfo nes_enormadvRomDesc[] = {
	{ "Enormous Adventures v1.1 (2021)(Game Losers).nes",          524304, 0xc237464e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_enormadv)
STD_ROM_FN(nes_enormadv)

struct BurnDriver BurnDrvnes_enormadv = {
	"nes_enormadv", NULL, NULL, NULL, "2021",
	"Enormous Adventures (HB, v1.1)\0", NULL, "Game Losers", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_enormadvRomInfo, nes_enormadvRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Eskimo Bob, Starring Alfonzo - Deluxe Edition (HB, v1.2)
static struct BurnRomInfo nes_eskimbobdelediRomDesc[] = {
	{ "Eskimo Bob Starring Alfonzo - Deluxe Edition v1.2 (2019)(Spoony Bard Productions).nes",          65552, 0xbc38ac6b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_eskimbobdeledi)
STD_ROM_FN(nes_eskimbobdeledi)

struct BurnDriver BurnDrvnes_eskimbobdeledi = {
	"nes_eskimbobdeledi", NULL, NULL, NULL, "2019",
	"Eskimo Bob, Starring Alfonzo - Deluxe Edition (HB, v1.2)\0", NULL, "Spoony Bard Productions", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_eskimbobdelediRomInfo, nes_eskimbobdelediRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Espitene (HB)
static struct BurnRomInfo nes_espiteneRomDesc[] = {
	{ "Espitene (2018)(The Mojon Twins).nes",          65552, 0x1f80c94e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_espitene)
STD_ROM_FN(nes_espitene)

struct BurnDriver BurnDrvnes_espitene = {
	"nes_espitene", NULL, NULL, NULL, "2018",
	"Espitene (HB)\0", NULL, "The Mojon Twins", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_espiteneRomInfo, nes_espiteneRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Espitenen und herr Pimponen (HB)
static struct BurnRomInfo nes_espitundherpimRomDesc[] = {
	{ "Espitenen und herr Pimponen (2019)(The Mojon Twins).nes",          65552, 0xea5fa8a8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_espitundherpim)
STD_ROM_FN(nes_espitundherpim)

struct BurnDriver BurnDrvnes_espitundherpim = {
	"nes_espitundherpim", NULL, NULL, NULL, "2019",
	"Espitenen und herr Pimponen (HB)\0", NULL, "The Mojon Twins", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_espitundherpimRomInfo, nes_espitundherpimRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Evil Dead - Ash lives! (GlobalHack)
static struct BurnRomInfo nes_evildeadRomDesc[] = {
	{ "Evil Dead Ash lives! (2020)(Crying Onion).nes",          262160, 0x2ce2ead0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_evildead)
STD_ROM_FN(nes_evildead)

struct BurnDriver BurnDrvnes_evildead = {
	"nes_evildead", NULL, NULL, NULL, "2020",
	"Evil Dead - Ash lives! (GlobalHack)\0", NULL, "Crying Onion", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_evildeadRomInfo, nes_evildeadRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Exploding Fist (HB)
static struct BurnRomInfo nes_explodingfistpiRomDesc[] = {
	{ "Exploding Fist (2018)(Piko Interactive).nes",          65552, 0x4017b398, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_explodingfistpi)
STD_ROM_FN(nes_explodingfistpi)

struct BurnDriver BurnDrvnes_explodingfistpi = {
	"nes_explodingfistpi", "nes_explodingfist", NULL, NULL, "2018",
	"Exploding Fist (HB)\0", NULL, "Piko Interactive", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 3, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_explodingfistpiRomInfo, nes_explodingfistpiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Eyra - The Crow Maiden (HB)
static struct BurnRomInfo nes_eyraRomDesc[] = {
	{ "Eyra the Crow Maiden (2020)(Second Dimension).nes",          40976, 0x1415153d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_eyra)
STD_ROM_FN(nes_eyra)

struct BurnDriver BurnDrvnes_eyra = {
	"nes_eyra", NULL, NULL, NULL, "2020",
	"Eyra - The Crow Maiden (HB)\0", NULL, "Second Dimension", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_eyraRomInfo, nes_eyraRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Falling Tiles (HB, Rev B)
static struct BurnRomInfo nes_fallingtilesRomDesc[] = {
	{ "Falling Tiles (Rev B)(2020)(Doug Fraker).nes",          40976, 0x5b8fcd00, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_fallingtiles)
STD_ROM_FN(nes_fallingtiles)

struct BurnDriver BurnDrvnes_fallingtiles = {
	"nes_fallingtiles", NULL, NULL, NULL, "2020",
	"Falling Tiles (HB, Rev B)\0", NULL, "Doug Fraker", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_fallingtilesRomInfo, nes_fallingtilesRomName, NULL, NULL, NULL, NULL, NESZapperInputInfo, NESZapperDIPInfo,
	NESZapperInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Machine Cave (HB, v1.9)
static struct BurnRomInfo nes_machinecaveRomDesc[] = {
	{ "Machine Cave v1.9 (2018)(Simo Sievanen).nes",          40976, 0x2d904baf, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_machinecave)
STD_ROM_FN(nes_machinecave)

struct BurnDriver BurnDrvnes_machinecave = {
	"nes_machinecave", NULL, NULL, NULL, "2018",
	"Machine Cave (HB, v1.9)\0", NULL, "Simo Sievanen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_SHOOT | GBF_PUZZLE, 0,
	NESGetZipName, nes_machinecaveRomInfo, nes_machinecaveRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Famicom De Pon (HB)
static struct BurnRomInfo nes_famdeponRomDesc[] = {
	{ "Famicom De Pon (2020)(Okunyon).nes",          40976, 0xe2f88d81, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_famdepon)
STD_ROM_FN(nes_famdepon)

struct BurnDriver BurnDrvnes_famdepon = {
	"nes_famdepon", NULL, NULL, NULL, "2020",
	"Famicom De Pon (HB)\0", NULL, "Okunyon", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_famdeponRomInfo, nes_famdeponRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Filthy Kitchen (HB)
static struct BurnRomInfo nes_filthyktcnRomDesc[] = {
	{ "Filthy Kitchen (2016)(Dustmop).nes",          65552, 0xa22cdf8a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_filthyktcn)
STD_ROM_FN(nes_filthyktcn)

struct BurnDriver BurnDrvnes_filthyktcn = {
	"nes_filthyktcn", NULL, NULL, NULL, "2016",
	"Filthy Kitchen (HB)\0", NULL, "Dustmop", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_filthyktcnRomInfo, nes_filthyktcnRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Fire and Rescue (HB, v2.0)
static struct BurnRomInfo nes_firerescuev2RomDesc[] = {
	{ "Fire and Rescue v2.0 (2021)(Skyboy Games).nes",          40976, 0x156ff8ee, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_firerescuev2)
STD_ROM_FN(nes_firerescuev2)

struct BurnDriver BurnDrvnes_firerescuev2 = {
	"nes_firerescuev2", NULL, NULL, NULL, "2021",
	"Fire and Rescue (HB, v2.0)\0", NULL, "Skyboy Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_firerescuev2RomInfo, nes_firerescuev2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Fire and Rescue (HB, v1.1)
static struct BurnRomInfo nes_firerescueRomDesc[] = {
	{ "Fire and Rescue v1.1 (2021)(Skyboy Games).nes",          40976, 0x3a233cd9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_firerescue)
STD_ROM_FN(nes_firerescue)

struct BurnDriver BurnDrvnes_firerescue = {
	"nes_firerescue", "nes_firerescuev2", NULL, NULL, "2021",
	"Fire and Rescue (HB, v1.1)\0", NULL, "Skyboy Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_firerescueRomInfo, nes_firerescueRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Flappy Bird (HB)
static struct BurnRomInfo nes_flappybirdRomDesc[] = {
	{ "Flappy Bird (2014)(Nioreh).nes",          24592, 0x3653c07d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_flappybird)
STD_ROM_FN(nes_flappybird)

struct BurnDriver BurnDrvnes_flappybird = {
	"nes_flappybird", NULL, NULL, NULL, "2014",
	"Flappy Bird (HB)\0", NULL, "Nioreh", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_flappybirdRomInfo, nes_flappybirdRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// FLEA! (HB)
static struct BurnRomInfo nes_fleaRomDesc[] = {
	{ "FLEA! (2020)(Lowtek Games).nes",          524304, 0xd208c6da, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_flea)
STD_ROM_FN(nes_flea)

struct BurnDriver BurnDrvnes_flea = {
	"nes_flea", NULL, NULL, NULL, "2020",
	"FLEA! (HB)\0", NULL, "Lowtek Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_fleaRomInfo, nes_fleaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// FLEA! Demo (HB)
static struct BurnRomInfo nes_fleademoRomDesc[] = {
	{ "FLEA! Demo (2019)(Lowtek Games).nes",          524304, 0x6d18f7c4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_fleademo)
STD_ROM_FN(nes_fleademo)

struct BurnDriver BurnDrvnes_fleademo = {
	"nes_fleademo", "nes_flea", NULL, NULL, "2019",
	"FLEA! Demo (HB)\0", NULL, "Lowtek Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_fleademoRomInfo, nes_fleademoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Fluffy Space Escape (HB)
static struct BurnRomInfo nes_fluffyRomDesc[] = {
	{ "Fluffy Space Escape (2018)(Ludum Dare 40).nes",          81936, 0xddd06400, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_fluffy)
STD_ROM_FN(nes_fluffy)

struct BurnDriver BurnDrvnes_fluffy = {
	"nes_fluffy", NULL, NULL, NULL, "2018",
	"Fluffy Space Escape (HB)\0", NULL, "Ludum Dare 40", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_fluffyRomInfo, nes_fluffyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Fly a Way (HB)
static struct BurnRomInfo nes_flyawayRomDesc[] = {
	{ "Fly a Way (2020)(Okunyon).nes",          40976, 0x81e30194, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_flyaway)
STD_ROM_FN(nes_flyaway)

struct BurnDriver BurnDrvnes_flyaway = {
	"nes_flyaway", NULL, NULL, NULL, "2020",
	"Fly a Way (HB)\0", NULL, "Okunyon", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_flyawayRomInfo, nes_flyawayRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Foals Creek (Russia) (HB)
static struct BurnRomInfo nes_foalscreekRomDesc[] = {
	{ "Foals Creek RU (2023)(Guyver).nes",          262160, 0x0f549415, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_foalscreek)
STD_ROM_FN(nes_foalscreek)

struct BurnDriver BurnDrvnes_foalscreek = {
	"nes_foalscreek", NULL, NULL, NULL, "2023",
	"Foals Creek (Russia) (HB)\0", NULL, "Guyver", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_foalscreekRomInfo, nes_foalscreekRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Force Bot (HB)
static struct BurnRomInfo nes_forcebotRomDesc[] = {
	{ "Force Bot (2022)(erockbrox).nes",          262160, 0x4418bbb3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_forcebot)
STD_ROM_FN(nes_forcebot)

struct BurnDriver BurnDrvnes_forcebot = {
	"nes_forcebot", NULL, NULL, NULL, "2022",
	"Force Bot (HB)\0", NULL, "erockbrox", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_forcebotRomInfo, nes_forcebotRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Frenzy A7800 (HB)
static struct BurnRomInfo nes_frenzyRomDesc[] = {
	{ "Frenzy A7800 (2016)(Bob Decrescenzo).nes",          40976, 0x82b0f8f4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_frenzy)
STD_ROM_FN(nes_frenzy)

struct BurnDriver BurnDrvnes_frenzy = {
	"nes_frenzy", NULL, NULL, NULL, "2016",
	"Frenzy A7800 (HB)\0", "The Atari 7800 Frenzy on NES (conversion)", "Bob Decrescenzo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_frenzyRomInfo, nes_frenzyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Frog (HB)
static struct BurnRomInfo nes_frogRomDesc[] = {
	{ "Frog (2020)(Boston Breams).nes",          393232, 0x06d96b55, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_frog)
STD_ROM_FN(nes_frog)

struct BurnDriver BurnDrvnes_frog = {
	"nes_frog", NULL, NULL, NULL, "2020",
	"Frog (HB)\0", NULL, "Boston Breams", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_frogRomInfo, nes_frogRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// From Below (HB, v1.0)
static struct BurnRomInfo nes_frombelowRomDesc[] = {
	{ "From Below (HB, v1.0).nes",          40976, 0x8ce49adb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_frombelow)
STD_ROM_FN(nes_frombelow)

struct BurnDriver BurnDrvnes_frombelow = {
	"nes_frombelow", NULL, NULL, NULL, "2020",
	"From Below (HB, v1.0)\0", NULL, "Goose2k", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_frombelowRomInfo, nes_frombelowRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// F-Theta (HB)
static struct BurnRomInfo nes_fthetaRomDesc[] = {
	{ "F-Theta (2021)(Little Sound)_MirroringFix.nes",          262160, 0x7bd2813c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ftheta)
STD_ROM_FN(nes_ftheta)

struct BurnDriver BurnDrvnes_ftheta = {
	"nes_ftheta", NULL, NULL, NULL, "2021",
	"F-Theta (HB)\0", NULL, "Little Sound Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_fthetaRomInfo, nes_fthetaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Full Quiet (HB)
static struct BurnRomInfo nes_fullquietrvRomDesc[] = {
	{ "Full Quiet (2022)(Retrotainment Games).nes",          524304, 0x45d166dd, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_fullquietrv)
STD_ROM_FN(nes_fullquietrv)

struct BurnDriver BurnDrvnes_fullquietrv = {
	"nes_fullquietrv", NULL, NULL, NULL, "2022",
	"Full Quiet (HB)\0", NULL, "Retrotainment Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_fullquietrvRomInfo, nes_fullquietrvRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Full Quiet (Test Cart) (HB, Prototype)
static struct BurnRomInfo nes_fullquietRomDesc[] = {
	{ "Full Quiet (Test Cart)(2021)(Retrotainment Games).nes",          524304, 0x03055116, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_fullquiet)
STD_ROM_FN(nes_fullquiet)

struct BurnDriver BurnDrvnes_fullquiet = {
	"nes_fullquiet", "nes_fullquietrv", NULL, NULL, "2021",
	"Full Quiet (Test Cart) (HB, Prototype)\0", NULL, "Retrotainment Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW | BDF_PROTOTYPE, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_fullquietRomInfo, nes_fullquietRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Galf (HB)
static struct BurnRomInfo nes_galfRomDesc[] = {
	{ "Galf (2018)(Limited Run Games).nes",          262160, 0x52340070, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_galf)
STD_ROM_FN(nes_galf)

struct BurnDriver BurnDrvnes_galf = {
	"nes_galf", NULL, NULL, NULL, "2018",
	"Galf (HB)\0", NULL, "Limited Run Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_galfRomInfo, nes_galfRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gaplus (World)
static struct BurnRomInfo nes_gaplusRomDesc[] = {
	{ "Gaplus (2020)(Namco - BNEI).nes",          262160, 0x60811720, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gaplus)
STD_ROM_FN(nes_gaplus)

struct BurnDriver BurnDrvnes_gaplus = {
	"nes_gaplus", NULL, NULL, NULL, "2020",
	"Gaplus (World)\0", NULL, "Namco - BNEI", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_gaplusRomInfo, nes_gaplusRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Garbage Pail Kids Mad Mike and the Quest for Stale Gum (HB)
static struct BurnRomInfo nes_garbpailkidsRomDesc[] = {
	{ "Garbage Pail Kids Mad Mike and the Quest for Stale Gum (2022)(iam8bit).nes",          526080, 0x3d110c09, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_garbpailkids)
STD_ROM_FN(nes_garbpailkids)

struct BurnDriver BurnDrvnes_garbpailkids = {
	"nes_garbpailkids", NULL, NULL, NULL, "2022",
	"Garbage Pail Kids Mad Mike and the Quest for Stale Gum (HB)\0", NULL, "iam8bit", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_garbpailkidsRomInfo, nes_garbpailkidsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// GemVenture (HB)
static struct BurnRomInfo nes_gemventureRomDesc[] = {
	{ "GemVenture (2010)(Tom Livac).nes",          32784, 0x2b8eae32, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gemventure)
STD_ROM_FN(nes_gemventure)

struct BurnDriver BurnDrvnes_gemventure = {
	"nes_gemventure", NULL, NULL, NULL, "2010",
	"GemVenture (HB)\0", NULL, "Tom Livac", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_gemventureRomInfo, nes_gemventureRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Germ Squashers (HB)
static struct BurnRomInfo nes_germsquashRomDesc[] = {
	{ "Germ Squashers (2015)(8bit Evolution).nes",          65552, 0xcd6349b4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_germsquash)
STD_ROM_FN(nes_germsquash)

struct BurnDriver BurnDrvnes_germsquash = {
	"nes_germsquash", NULL, NULL, NULL, "2015",
	"Germ Squashers (HB)\0", NULL, "8bit Evolution", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_germsquashRomInfo, nes_germsquashRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Get'Em Gary (HB)
static struct BurnRomInfo nes_getemgaryRomDesc[] = {
	{ "Get'Em Gary (2016)(Second Dimension).nes",          40976, 0xb559ce3e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_getemgary)
STD_ROM_FN(nes_getemgary)

struct BurnDriver BurnDrvnes_getemgary = {
	"nes_getemgary", NULL, NULL, NULL, "2016",
	"Get'Em Gary (HB)\0", NULL, "Second Dimension", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_getemgaryRomInfo, nes_getemgaryRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ghostbusters Remastered (HB, v1.1)
static struct BurnRomInfo nes_ghostbrmRomDesc[] = {
	{ "Ghostbusters Remastered v1.1 (2019)(Nesrocks).nes",          98320, 0x29c2e0d0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ghostbrm)
STD_ROM_FN(nes_ghostbrm)

struct BurnDriver BurnDrvnes_ghostbrm = {
	"nes_ghostbrm", NULL, NULL, NULL, "2019",
	"Ghostbusters Remastered (HB, v1.1)\0", NULL, "NesRocks", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW | BDF_HACK, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_ghostbrmRomInfo, nes_ghostbrmRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ghoul Grind Night of the Necromancer (HB)
static struct BurnRomInfo nes_ghoulgrindRomDesc[] = {
	{ "Ghoul Grind Night of the Necromancer (2021)(WoogWorx).nes",          524304, 0x3557252e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ghoulgrind)
STD_ROM_FN(nes_ghoulgrind)

struct BurnDriver BurnDrvnes_ghoulgrind = {
	"nes_ghoulgrind", NULL, NULL, NULL, "2021",
	"Ghoul Grind Night of the Necromancer (HB)\0", NULL, "WoogWorx", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_ghoulgrindRomInfo, nes_ghoulgrindRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gold Guardian Gun Girl (HB)
static struct BurnRomInfo nes_ggggRomDesc[] = {
	{ "Gold Guardian Gun Girl (2020)(Good Tune).nes",          40976, 0xa0e59e67, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gggg)
STD_ROM_FN(nes_gggg)

struct BurnDriver BurnDrvnes_gggg = {
	"nes_gggg", NULL, NULL, NULL, "2020",
	"Gold Guardian Gun Girl (HB)\0", NULL, "Good Tune", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_ggggRomInfo, nes_ggggRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gradius II - Arrangement Chronicle Death (Hack, v2.0)
// https://www.romhacking.net/hacks/1574/
static struct BurnRomInfo nes_gradiusiiacdRomDesc[] = {
	{ "Gradius II - Arrangement Chronicle Death v2.0 (2019)(Messatu).nes",          524304, 0xe27f3192, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gradiusiiacd)
STD_ROM_FN(nes_gradiusiiacd)

struct BurnDriver BurnDrvnes_gradiusiiacd = {
	"nes_gradiusiiacd", "nes_gradiusii", NULL, NULL, "2019",
	"Gradius II - Arrangement Chronicle Death (Hack, v2.0)\0", NULL, "Messatu", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_gradiusiiacdRomInfo, nes_gradiusiiacdRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Graveyard Dude (HB)
static struct BurnRomInfo nes_gravedudeRomDesc[] = {
	{ "Graveyard Dude (2022)(Rani Baker).nes",          40976, 0xb0c5ff55, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gravedude)
STD_ROM_FN(nes_gravedude)

struct BurnDriver BurnDrvnes_gravedude = {
	"nes_gravedude", NULL, NULL, NULL, "2022",
	"Graveyard Dude (HB)\0", NULL, "Rani Baker", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_gravedudeRomInfo, nes_gravedudeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gremlins (GlobalHack)
static struct BurnRomInfo nes_gremlinsRomDesc[] = {
	{ "Gremlins GlobalHack (2016)(pacnsacdave).nes",          262160, 0xf6d5d3e3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gremlins)
STD_ROM_FN(nes_gremlins)

struct BurnDriver BurnDrvnes_gremlins = {
	"nes_gremlins", "nes_hudsonhawk", NULL, NULL, "2016",
	"Gremlins (GlobalHack)\0", NULL, "pacnsacdave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_gremlinsRomInfo, nes_gremlinsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gruniozerca (HB)
static struct BurnRomInfo nes_gruniRomDesc[] = {
	{ "Gruniozerca (2017)(Lukasz Kur).nes",          40976, 0x2ea66761, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gruni)
STD_ROM_FN(nes_gruni)

struct BurnDriver BurnDrvnes_gruni = {
	"nes_gruni", NULL, NULL, NULL, "2017",
	"Gruniozerca (HB)\0", NULL, "Lukasz Kur", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_gruniRomInfo, nes_gruniRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gruniozerca 2 - The Great Cavy Rescue! (HB)
static struct BurnRomInfo nes_gruni2RomDesc[] = {
	{ "Gruniozerca 2 - The Great Cavy Rescue! (2019)(Lukasz Kur & M-Tee).nes",          65552, 0x911a2917, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gruni2)
STD_ROM_FN(nes_gruni2)

struct BurnDriver BurnDrvnes_gruni2 = {
	"nes_gruni2", NULL, NULL, NULL, "2019",
	"Gruniozerca 2 - The Great Cavy Rescue! (HB)\0", NULL, "Lukasz Kur & M-Tee", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_gruni2RomInfo, nes_gruni2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gruniozerca 3 - The Great Cavy Clean-Up! (HB)
static struct BurnRomInfo nes_gruni3RomDesc[] = {
	{ "Gruniozerca 3 - The Great Cavy Clean-Up! (2019)(Lukasz Kur & M-Tee).nes",          65552, 0xa92f5930, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gruni3)
STD_ROM_FN(nes_gruni3)

struct BurnDriver BurnDrvnes_gruni3 = {
	"nes_gruni3", NULL, NULL, NULL, "2019",
	"Gruniozerca 3 - The Great Cavy Clean-Up! (HB)\0", NULL, "Lukasz Kur & M-Tee", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_gruni3RomInfo, nes_gruni3RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gunhawk (HB, v1.1)
static struct BurnRomInfo nes_gunhawkRomDesc[] = {
	{ "Gunhawk v1.1 (2023)(Skyboy Games).nes",          40976, 0x8d9175f9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gunhawk)
STD_ROM_FN(nes_gunhawk)

struct BurnDriver BurnDrvnes_gunhawk = {
	"nes_gunhawk", NULL, NULL, NULL, "2023",
	"Gunhawk (HB, v1.1)\0", NULL, "Skyboy Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_gunhawkRomInfo, nes_gunhawkRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// GunTneR (HB)
static struct BurnRomInfo nes_guntnerRomDesc[] = {
	{ "GunTneR (2022)(langel).nes",          24592, 0x170e5f53, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_guntner)
STD_ROM_FN(nes_guntner)

struct BurnDriver BurnDrvnes_guntner = {
	"nes_guntner", NULL, NULL, NULL, "2022",
	"GunTneR (HB)\0", NULL, "langel", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_guntnerRomInfo, nes_guntnerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hack*Match (HB)
static struct BurnRomInfo nes_hackmatchRomDesc[] = {
	{ "Hack Match (2021)(Zachtronics).nes",          40976, 0x94554d49, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hackmatch)
STD_ROM_FN(nes_hackmatch)

struct BurnDriver BurnDrvnes_hackmatch = {
	"nes_hackmatch", NULL, NULL, NULL, "2021",
	"Hack*Match (HB)\0", "Original game by Juice (1990)", "Zachtronics", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_hackmatchRomInfo, nes_hackmatchRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Haradius Zero (HB, v1.2a)
static struct BurnRomInfo nes_haradiuszeroRomDesc[] = {
	{ "Haradius Zero (HB).nes",          786448, 0x5ae4ccff, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_haradiuszero)
STD_ROM_FN(nes_haradiuszero)

struct BurnDriver BurnDrvnes_haradiuszero = {
	"nes_haradiuszero", NULL, NULL, NULL, "2019",
	"Haradius Zero (HB, v1.2a)\0", NULL, "Impact Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_haradiuszeroRomInfo, nes_haradiuszeroRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// HaraForce (HB, v1.00)
static struct BurnRomInfo nes_haraforceRomDesc[] = {
	{ "HaraForce v1.00 (2022)(Impact Soft).nes",          73744, 0x7a6faca7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_haraforce)
STD_ROM_FN(nes_haraforce)

struct BurnDriver BurnDrvnes_haraforce = {
	"nes_haraforce", NULL, NULL, NULL, "2022",
	"HaraForce (HB, v1.00)\0", NULL, "Impact Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_haraforceRomInfo, nes_haraforceRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// HaraForce (HB, v1.00, MMC5)
static struct BurnRomInfo nes_haraforcemmc5RomDesc[] = {
	{ "HaraForce v1.00 (2022)(Impact Soft)[MMC5].nes",          73744, 0x79cf8db1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_haraforcemmc5)
STD_ROM_FN(nes_haraforcemmc5)

struct BurnDriver BurnDrvnes_haraforcemmc5 = {
	"nes_haraforcemmc5", "nes_haraforce", NULL, NULL, "2022",
	"HaraForce (HB, v1.00, MMC5)\0", NULL, "Impact Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_haraforcemmc5RomInfo, nes_haraforcemmc5RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Haratyler HG (HB, v1.10)
static struct BurnRomInfo nes_haratylerhgRomDesc[] = {
	{ "Haratyler HG (2020)(Impact Soft).nes",          524304, 0xfd024bc4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_haratylerhg)
STD_ROM_FN(nes_haratylerhg)

struct BurnDriver BurnDrvnes_haratylerhg = {
	"nes_haratylerhg", NULL, NULL, NULL, "2020-21",
	"Haratyler HG (HB, v1.10)\0", NULL, "Impact Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_haratylerhgRomInfo, nes_haratylerhgRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Harry Dwarf (HB)
static struct BurnRomInfo nes_harrydwarfRomDesc[] = {
	{ "Harry Dwarf (2019)(Byte-off).nes",          524304, 0xf51e13d4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_harrydwarf)
STD_ROM_FN(nes_harrydwarf)

struct BurnDriver BurnDrvnes_harrydwarf = {
	"nes_harrydwarf", NULL, NULL, NULL, "2019",
	"Harry Dwarf (HB)\0", NULL, "Byte-off", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM | GBF_PUZZLE, 0,
	NESGetZipName, nes_harrydwarfRomInfo, nes_harrydwarfRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Haunted Halloween '85 (HB)
static struct BurnRomInfo nes_halloween85RomDesc[] = {
	{ "Haunted Halloween'85 (2015)(Retrotainment Games).nes",          524304, 0x4bcf7ae5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_halloween85)
STD_ROM_FN(nes_halloween85)

struct BurnDriver BurnDrvnes_halloween85 = {
	"nes_halloween85", NULL, NULL, NULL, "2015",
	"Haunted Halloween '85 (HB)\0", NULL, "Retrotainment Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_halloween85RomInfo, nes_halloween85RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Haunted Halloween '86 (HB)
static struct BurnRomInfo nes_halloween86RomDesc[] = {
	{ "Haunted Halloween '86 (2016)(Retrotainment Games).nes",          524304, 0x454252a4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_halloween86)
STD_ROM_FN(nes_halloween86)

struct BurnDriver BurnDrvnes_halloween86 = {
	"nes_halloween86", NULL, NULL, NULL, "2016",
	"Haunted Halloween '86 (HB)\0", NULL, "Retrotainment Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_halloween86RomInfo, nes_halloween86RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Haunted Halloween '86 (HB, Alt)
static struct BurnRomInfo nes_halloween86aRomDesc[] = {
	{ "Haunted Halloween '86 (2016)(Alt)(Retrotainment Games).nes",          524304, 0xd008091a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_halloween86a)
STD_ROM_FN(nes_halloween86a)

struct BurnDriver BurnDrvnes_halloween86a = {
	"nes_halloween86a", "nes_halloween86", NULL, NULL, "2016",
	"Haunted Halloween '86 (HB, Alt)\0", NULL, "Retrotainment Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_halloween86aRomInfo, nes_halloween86aRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Haunted Halloween '86 - Remastered Onslaught Edition (HB)
static struct BurnRomInfo nes_halloween86roeRomDesc[] = {
	{ "Haunted Halloween '86 - Remastered Onslaught Edition (2018)(Retrotainment Games).nes",          524304, 0x94f92f7c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_halloween86roe)
STD_ROM_FN(nes_halloween86roe)

struct BurnDriver BurnDrvnes_halloween86roe = {
	"nes_halloween86roe", NULL, NULL, NULL, "2018",
	"Haunted Halloween '86 - Remastered Onslaught Edition (HB)\0", NULL, "Retrotainment Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_halloween86roeRomInfo, nes_halloween86roeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Haunted House Adventure (HB)
static struct BurnRomInfo nes_hauntedadvRomDesc[] = {
	{ "Haunted House Adventure (2019)(M. Stave).nes",          524304, 0xd0c3acbc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hauntedadv)
STD_ROM_FN(nes_hauntedadv)

struct BurnDriver BurnDrvnes_hauntedadv = {
	"nes_hauntedadv", NULL, NULL, NULL, "2019",
	"Haunted House Adventure (HB)\0", NULL, "M. Stave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_hauntedadvRomInfo, nes_hauntedadvRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// HBC Phutball (HB)
static struct BurnRomInfo nes_hbcpballRomDesc[] = {
	{ "HBC Phutball (2022)(Wendel Scardua).nes",          65552, 0xb2f98884, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hbcpball)
STD_ROM_FN(nes_hbcpball)

struct BurnDriver BurnDrvnes_hbcpball = {
	"nes_hbcpball", NULL, NULL, NULL, "2022",
	"HBC Phutball (HB)\0", NULL, "Wendel Scardua", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_hbcpballRomInfo, nes_hbcpballRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Heist (HB)
static struct BurnRomInfo nes_heistRomDesc[] = {
	{ "Heist (2022)(Johnybot).nes",          40976, 0x75c942f5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_heist)
STD_ROM_FN(nes_heist)

struct BurnDriver BurnDrvnes_heist = {
	"nes_heist", NULL, NULL, NULL, "2022",
	"Heist (HB)\0", NULL, "Johnybot", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_heistRomInfo, nes_heistRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// HEOH demo (HB, Tech-Demo)
static struct BurnRomInfo nes_heohdemoRomDesc[] = {
	{ "HEOH demo (2019)(shiru).nes",          524304, 0x4fcd5116, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_heohdemo)
STD_ROM_FN(nes_heohdemo)

struct BurnDriver BurnDrvnes_heohdemo = {
	"nes_heohdemo", NULL, NULL, NULL, "2019",
	"HEOH demo (HB, Tech-Demo)\0", NULL, "shiru", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW | BDF_DEMO, 1, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_heohdemoRomInfo, nes_heohdemoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hollow Knight Grab Grub (HB)
static struct BurnRomInfo nes_hollowkggRomDesc[] = {
	{ "Hollow Knight Grab Grub (2022)(Elvies).nes",          40976, 0x7218e26f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hollowkgg)
STD_ROM_FN(nes_hollowkgg)

struct BurnDriver BurnDrvnes_hollowkgg = {
	"nes_hollowkgg", NULL, NULL, NULL, "2022",
	"Hollow Knight Grab Grub (HB)\0", NULL, "Elvies", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_hollowkggRomInfo, nes_hollowkggRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Indivisible (HB)
static struct BurnRomInfo nes_indivisibleRomDesc[] = {
	{ "Indivisible (2017)(Lab Zero Games).nes",          262160, 0x9f304e88, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_indivisible)
STD_ROM_FN(nes_indivisible)

struct BurnDriver BurnDrvnes_indivisible = {
	"nes_indivisible", NULL, NULL, NULL, "2017",
	"Indivisible (HB)\0", NULL, "Lab Zero Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_indivisibleRomInfo, nes_indivisibleRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Interglactic Transmissing (HB)
static struct BurnRomInfo nes_inttransRomDesc[] = {
	{ "Interglactic Transmissing (2018)(GGJ).nes",          40976, 0xe13adc0c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_inttrans)
STD_ROM_FN(nes_inttrans)

struct BurnDriver BurnDrvnes_inttrans = {
	"nes_inttrans", NULL, NULL, NULL, "2018",
	"Interglactic Transmissing (HB)\0", NULL, "GGJ", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_inttransRomInfo, nes_inttransRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Inversion (HB, v1.4)
static struct BurnRomInfo nes_inversionRomDesc[] = {
	{ "Inversion v1.4 (2013)(Red Moon Games).nes",          40976, 0xd61c6b3b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_inversion)
STD_ROM_FN(nes_inversion)

struct BurnDriver BurnDrvnes_inversion = {
	"nes_inversion", NULL, NULL, NULL, "2013",
	"Inversion (HB, v1.4)\0", NULL, "Red Moon Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_inversionRomInfo, nes_inversionRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Irritating Ship (HB)
static struct BurnRomInfo nes_irritshipRomDesc[] = {
	{ "Irritating Ship (2022)(Fiskbit).nes",          40976, 0xacab29f4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_irritship)
STD_ROM_FN(nes_irritship)

struct BurnDriver BurnDrvnes_irritship = {
	"nes_irritship", NULL, NULL, NULL, "2022",
	"Irritating Ship (HB)\0", NULL, "Fiskbit", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_irritshipRomInfo, nes_irritshipRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Jane Austen's 8-bit Adventure (HB, v1.0.538)
static struct BurnRomInfo nes_ja8bitadvRomDesc[] = {
	{ "Jane Austen's 8-bit Adventure v1.0.538 (2023)(Bitwise Reprise).nes",          262160, 0xd7ea1034, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ja8bitadv)
STD_ROM_FN(nes_ja8bitadv)

struct BurnDriver BurnDrvnes_ja8bitadv = {
	"nes_ja8bitadv", NULL, NULL, NULL, "2023",
	"Jane Austen's 8-bit Adventure (HB, v1.0.538)\0", NULL, "Bitwise Reprise", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_ja8bitadvRomInfo, nes_ja8bitadvRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Jay and Silent Bob Mall Brawl (HB)
static struct BurnRomInfo nes_jaysilentRomDesc[] = {
	{ "Jay and Silent Bob Mall Brawl (2020)(Interabang Entertainment).nes",          393232, 0xf167590d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jaysilent)
STD_ROM_FN(nes_jaysilent)

struct BurnDriver BurnDrvnes_jaysilent = {
	"nes_jaysilent", NULL, NULL, NULL, "2020",
	"Jay and Silent Bob Mall Brawl (HB)\0", NULL, "Interabang Entertainment", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_jaysilentRomInfo, nes_jaysilentRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Jester (HB)
static struct BurnRomInfo nes_jesterRomDesc[] = {
	{ "Jester (2020)(Acclaim - CollectorVision).nes",          40976, 0x60f4d45c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jester)
STD_ROM_FN(nes_jester)

struct BurnDriver BurnDrvnes_jester = {
	"nes_jester", NULL, NULL, NULL, "2020",
	"Jester (HB)\0", NULL, "Acclaim - CollectorVision", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION | GBF_MAZE, 0,
	NESGetZipName, nes_jesterRomInfo, nes_jesterRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Jester (HB, Alt)
static struct BurnRomInfo nes_jesterv2RomDesc[] = {
	{ "Jester (Alt)(2023)(Acclaim - Mega Cat Studios).nes",          40976, 0xcc1762b6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jesterv2)
STD_ROM_FN(nes_jesterv2)

struct BurnDriver BurnDrvnes_jesterv2 = {
	"nes_jesterv2", "nes_jester", NULL, NULL, "2023",
	"Jester (HB, Alt)\0", NULL, "Acclaim - Mega Cat Studios", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION | GBF_MAZE, 0,
	NESGetZipName, nes_jesterv2RomInfo, nes_jesterv2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Jim Power - The Lost Dimension (HB)
static struct BurnRomInfo nes_jimpowerRomDesc[] = {
	{ "Jim Power - The Lost Dimension (2020)(Piko).nes",          524304, 0x3f088114, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jimpower)
STD_ROM_FN(nes_jimpower)

struct BurnDriver BurnDrvnes_jimpower = {
	"nes_jimpower", NULL, NULL, NULL, "2020",
	"Jim Power - The Lost Dimension (HB)\0", NULL, "Piko Interactive", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM | GBF_RUNGUN, 0,
	NESGetZipName, nes_jimpowerRomInfo, nes_jimpowerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Journey to the Center of the Alien (HB, English)
static struct BurnRomInfo nes_journeyalRomDesc[] = {
	{ "Journey to the Center of the Alien EN (2019)(The Mojon Twins).nes",          73744, 0xede880e6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_journeyal)
STD_ROM_FN(nes_journeyal)

struct BurnDriver BurnDrvnes_journeyal = {
	"nes_journeyal", NULL, NULL, NULL, "2019",
	"Journey to the Center of the Alien (HB, English)\0", NULL, "The Mojon Twins", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_journeyalRomInfo, nes_journeyalRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Journey to the Center of the Alien (HB, Spanish)
static struct BurnRomInfo nes_journeyalsRomDesc[] = {
	{ "Journey to the Center of the Alien ES (2019)(The Mojon Twins).nes",          73744, 0x0d68dad3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_journeyals)
STD_ROM_FN(nes_journeyals)

struct BurnDriver BurnDrvnes_journeyals = {
	"nes_journeyals", "nes_journeyal", NULL, NULL, "2019",
	"Journey to the Center of the Alien (HB, Spanish)\0", NULL, "The Mojon Twins", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_journeyalsRomInfo, nes_journeyalsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Junkoid (GlobalHack, v1.1)
static struct BurnRomInfo nes_junkoidRomDesc[] = {
	{ "Junkoid GlobalHack v1.1 (2022)(P. Yoshi).nes",          393232, 0xf7747212, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_junkoid)
STD_ROM_FN(nes_junkoid)

struct BurnDriver BurnDrvnes_junkoid = {
	"nes_junkoid", "nes_metroid", NULL, NULL, "2022",
	"Junkoid (GlobalHack, v1.1)\0", NULL, "P. Yoshi", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_junkoidRomInfo, nes_junkoidRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Justice (HB)
static struct BurnRomInfo nes_justiceRomDesc[] = {
	{ "Justice (2020)(Unknown).nes",          196624, 0x5a8b8f13, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_justice)
STD_ROM_FN(nes_justice)

struct BurnDriver BurnDrvnes_justice = {
	"nes_justice", NULL, NULL, NULL, "2020",
	"Justice (HB)\0", NULL, "<unknown>", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, nes_justiceRomInfo, nes_justiceRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Justice Duel (HB)
static struct BurnRomInfo nes_justiceduelRomDesc[] = {
	{ "Justice Duel (2019)(Mega Cat Studios).nes",          196624, 0xada8853b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_justiceduel)
STD_ROM_FN(nes_justiceduel)

struct BurnDriver BurnDrvnes_justiceduel = {
	"nes_justiceduel", NULL, NULL, NULL, "2019",
	"Justice Duel (HB)\0", NULL, "Mega Cat Studios", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 4, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_justiceduelRomInfo, nes_justiceduelRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Karate Kick (HB)
static struct BurnRomInfo nes_karatekickRomDesc[] = {
	{ "Karate Kick (2017)(Mike Moffitt).nes",          40976, 0xda688ee1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_karatekick)
STD_ROM_FN(nes_karatekick)

struct BurnDriver BurnDrvnes_karatekick = {
	"nes_karatekick", NULL, NULL, NULL, "2017",
	"Karate Kick (HB)\0", NULL, "Mike Moffitt", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_karatekickRomInfo, nes_karatekickRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kamikaze Mario DX+ (GlobalHack, v1.9)
// https://www.romhacking.net/hacks/6373/
static struct BurnRomInfo nes_kamimariodxRomDesc[] = {
	{ "Kamikaze Mario DX+ v1.9 (2021)(79).nes",          147472, 0xb7518c16, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kamimariodx)
STD_ROM_FN(nes_kamimariodx)

struct BurnDriver BurnDrvnes_kamimariodx = {
	"nes_kamimariodx", "nes_smb", NULL, NULL, "2021",
	"Kamikaze Mario DX+ (GlobalHack, v1.9)\0", NULL, "79", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_kamimariodxRomInfo, nes_kamimariodxRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kosmity Atakujo (HB, v10.07.2020)
static struct BurnRomInfo nes_kosatakRomDesc[] = {
	{ "Kosmity Atakujo (HB, v10.07.2020).nes",          131088, 0x0570865c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kosatak)
STD_ROM_FN(nes_kosatak)

struct BurnDriver BurnDrvnes_kosatak = {
	"nes_kosatak", NULL, NULL, NULL, "2020",
	"Kosmity Atakujo (HB, v10.07.2020)\0", NULL, "sdm2", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_kosatakRomInfo, nes_kosatakRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// L'Abbaye des Morts (HB)
static struct BurnRomInfo nes_labbayeRomDesc[] = {
	{ "L'Abbaye des Morts (2021)(Broke Studios).nes",          131088, 0xa032a1f6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_labbaye)
STD_ROM_FN(nes_labbaye)

struct BurnDriver BurnDrvnes_labbaye = {
	"nes_labbaye", NULL, NULL, NULL, "2021",
	"L'Abbaye des Morts (HB)\0", NULL, "Broke Studio", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_labbayeRomInfo, nes_labbayeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lala the Magical (HB)
static struct BurnRomInfo nes_lalathemagicalRomDesc[] = {
	{ "Lala the Magical (2016)(The Mojon Twins).nes",          81936, 0x496c2e59, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lalathemagical)
STD_ROM_FN(nes_lalathemagical)

struct BurnDriver BurnDrvnes_lalathemagical = {
	"nes_lalathemagical", NULL, NULL, NULL, "2016",
	"Lala the Magical (HB)\0", NULL, "The Mojon Twins", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_lalathemagicalRomInfo, nes_lalathemagicalRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lan Master (HB)
static struct BurnRomInfo nes_lanmasterRomDesc[] = {
	{ "Lan Master (2011)(Shiru).nes",          40976, 0x32d113b5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lanmaster)
STD_ROM_FN(nes_lanmaster)

struct BurnDriver BurnDrvnes_lanmaster = {
	"nes_lanmaster", NULL, NULL, NULL, "2011",
	"Lan Master (HB)\0", NULL, "Shiru", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_lanmasterRomInfo, nes_lanmasterRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Larry (HB)
static struct BurnRomInfo nes_larryRomDesc[] = {
	{ "Larry (2014)(Khan Games).nes",          524304, 0x96f31fb9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_larry)
STD_ROM_FN(nes_larry)

struct BurnDriver BurnDrvnes_larry = {
	"nes_larry", NULL, NULL, NULL, "2014",
	"Larry (HB)\0", NULL, "Khan Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_larryRomInfo, nes_larryRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Larry (HB, Alt)
static struct BurnRomInfo nes_larryaRomDesc[] = {
	{ "Larry (Alt)(2014)(Khan Games).nes",          524304, 0x2c8d188e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_larrya)
STD_ROM_FN(nes_larrya)

struct BurnDriver BurnDrvnes_larrya = {
	"nes_larrya", "nes_larry", NULL, NULL, "2014",
	"Larry (HB, Alt)\0", NULL, "Khan Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_larryaRomInfo, nes_larryaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lawn Mower (HB)
static struct BurnRomInfo nes_lawnmowerRomDesc[] = {
	{ "Lawn Mower (2011)(Shiru).nes",          24592, 0x2e03cb7f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lawnmower)
STD_ROM_FN(nes_lawnmower)

struct BurnDriver BurnDrvnes_lawnmower = {
	"nes_lawnmower", NULL, NULL, NULL, "2011",
	"Lawn Mower (HB)\0", NULL, "Shiru", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_lawnmowerRomInfo, nes_lawnmowerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Legend of Weed N' Stiff, The (HB)
static struct BurnRomInfo nes_legwnsRomDesc[] = {
	{ "Legend of Weed N' Stiff, The (2020)(CalGames).nes",          524304, 0x3e8c0fe5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_legwns)
STD_ROM_FN(nes_legwns)

struct BurnDriver BurnDrvnes_legwns = {
	"nes_legwns", "nes_legwnssdx", NULL, NULL, "2020",
	"Legend of Weed N' Stiff, The (HB)\0", NULL, "CalGames", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_legwnsRomInfo, nes_legwnsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Legend of Weed N' Stiff DX, The (HB)
static struct BurnRomInfo nes_legwnsdxRomDesc[] = {
	{ "Legend of Weed N' Stiff DX, The (2021)(CalGames).nes",          524304, 0xf2e59dc7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_legwnsdx)
STD_ROM_FN(nes_legwnsdx)

struct BurnDriver BurnDrvnes_legwnsdx = {
	"nes_legwnsdx", "nes_legwnssdx", NULL, NULL, "2020",
	"Legend of Weed N' Stiff DX, The (HB)\0", NULL, "CalGames", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_legwnsdxRomInfo, nes_legwnsdxRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Legend of Weed N' Stiff SDX, The (HB)
static struct BurnRomInfo nes_legwnssdxRomDesc[] = {
	{ "Legend of Weed N' Stiff SDX, The (2021)(CalGames).nes",          524304, 0xe59b7fa0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_legwnssdx)
STD_ROM_FN(nes_legwnssdx)

struct BurnDriver BurnDrvnes_legwnssdx = {
	"nes_legwnssdx", NULL, NULL, NULL, "2021",
	"Legend of Weed N' Stiff SDX, The (HB)\0", NULL, "CalGames", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_legwnssdxRomInfo, nes_legwnssdxRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Legend of Zelda DX, The (Graphics Hack)
static struct BurnRomInfo nes_legenzeldxRomDesc[] = {
	{ "legend of zelda dx (2014)(pacnsacdave).nes",          131088, 0x0698579d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_legenzeldx)
STD_ROM_FN(nes_legenzeldx)

struct BurnDriver BurnDrvnes_legenzeldx = {
	"nes_legenzeldx", "nes_legenzel", NULL, NULL, "2014",
	"Legend of Zelda DX, The (Graphics Hack)\0", NULL, "pacnsacdave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_legenzeldxRomInfo, nes_legenzeldxRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Leggite Luta Livre (HB)
static struct BurnRomInfo nes_leglutlivRomDesc[] = {
	{ "Leggite Luta Livre (2021)(John Vanderhoef).nes",          524304, 0xbcbc972c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_leglutliv)
STD_ROM_FN(nes_leglutliv)

struct BurnDriver BurnDrvnes_leglutliv = {
	"nes_leglutliv", "nes_leglutlivr", NULL, NULL, "2021",
	"Leggite Luta Livre (HB)\0", NULL, "John Vanderhoef", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_leglutlivRomInfo, nes_leglutlivRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Leggite Luta Livre Remaster (HB)
static struct BurnRomInfo nes_leglutlivrRomDesc[] = {
	{ "Leggite Luta Livre Remaster (2022)(John Vanderhoef).nes",          524304, 0x73bf3d14, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_leglutlivr)
STD_ROM_FN(nes_leglutlivr)

struct BurnDriver BurnDrvnes_leglutlivr = {
	"nes_leglutlivr", NULL, NULL, NULL, "2021-22",
	"Leggite Luta Livre Remaster (HB)\0", NULL, "John Vanderhoef", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_leglutlivrRomInfo, nes_leglutlivrRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lights Out (HB)
static struct BurnRomInfo nes_lightsoutRomDesc[] = {
	{ "Lights Out (2017)(Mika Haarahiltunen).nes",          24592, 0x3d4ab74b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lightsout)
STD_ROM_FN(nes_lightsout)

struct BurnDriver BurnDrvnes_lightsout = {
	"nes_lightsout", NULL, NULL, NULL, "2017",
	"Lights Out (HB)\0", NULL, "Mika Haarahiltunen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_lightsoutRomInfo, nes_lightsoutRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Little Lancelot (HB)
static struct BurnRomInfo nes_littlelancRomDesc[] = {
	{ "Little Lancelot (2019)(Piko Int).nes",          262160, 0x65e1bc64, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_littlelanc)
STD_ROM_FN(nes_littlelanc)

struct BurnDriver BurnDrvnes_littlelanc = {
	"nes_littlelanc", NULL, NULL, NULL, "2019",
	"Little Lancelot (HB)\0", "Developed by Ocean", "Piko Interactive", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_littlelancRomInfo, nes_littlelancRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Little Medusa (HB)
static struct BurnRomInfo nes_littlemedusaRomDesc[] = {
	{ "Little Medusa (2018)(Mega Cat Studios).nes",          524304, 0x126b5927, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_littlemedusa)
STD_ROM_FN(nes_littlemedusa)

struct BurnDriver BurnDrvnes_littlemedusa = {
	"nes_littlemedusa", NULL, NULL, NULL, "2018",
	"Little Medusa (HB)\0", NULL, "Mega Cat Studios", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_littlemedusaRomInfo, nes_littlemedusaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Little Sisyphus (HB)
static struct BurnRomInfo nes_lsisyphusRomDesc[] = {
	{ "Little Sisyphus (2023)(Pubby Games).nes",          65552, 0x29d4aa43, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lsisyphus)
STD_ROM_FN(nes_lsisyphus)

struct BurnDriver BurnDrvnes_lsisyphus = {
	"nes_lsisyphus", NULL, NULL, NULL, "2023",
	"Little Sisyphus (HB)\0", NULL, "Pubby Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_lsisyphusRomInfo, nes_lsisyphusRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lizard (HB, English)
static struct BurnRomInfo nes_lizardRomDesc[] = {
	{ "Lizard EN (2018)(Brad Smith).nes",          524304, 0xe36fc0c0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lizard)
STD_ROM_FN(nes_lizard)

struct BurnDriver BurnDrvnes_lizard = {
	"nes_lizard", NULL, NULL, NULL, "2018",
	"Lizard (HB, English)\0", NULL, "Brad Smith", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_lizardRomInfo, nes_lizardRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lizard (HB, Japan)
static struct BurnRomInfo nes_lizardjRomDesc[] = {
	{ "Lizard JP (2018)(Brad Smith).nes",          524304, 0xf7f0c2b6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lizardj)
STD_ROM_FN(nes_lizardj)

struct BurnDriver BurnDrvnes_lizardj = {
	"nes_lizardj", "nes_lizard", NULL, NULL, "2018",
	"Lizard (HB, Japan)\0", NULL, "Brad Smith", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_lizardjRomInfo, nes_lizardjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lizard (HB, Portuguese)
static struct BurnRomInfo nes_lizardpRomDesc[] = {
	{ "Lizard PT (2018)(Brad Smith).nes",          524304, 0x0e2192d0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lizardp)
STD_ROM_FN(nes_lizardp)

struct BurnDriver BurnDrvnes_lizardp = {
	"nes_lizardp", "nes_lizard", NULL, NULL, "2018",
	"Lizard (HB, Portuguese)\0", NULL, "Brad Smith", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_lizardpRomInfo, nes_lizardpRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lizard (HB, Spanish)
static struct BurnRomInfo nes_lizardsRomDesc[] = {
	{ "Lizard ES (2018)(Brad Smith).nes",          524304, 0x96d800d4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lizards)
STD_ROM_FN(nes_lizards)

struct BurnDriver BurnDrvnes_lizards = {
	"nes_lizards", "nes_lizard", NULL, NULL, "2018",
	"Lizard (HB, Spanish)\0", NULL, "Brad Smith", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_lizardsRomInfo, nes_lizardsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Log Jammers (HB)
static struct BurnRomInfo nes_logjammersRomDesc[] = {
	{ "Log Jammers (2017)(Mega Cat Studios).nes",          393232, 0x451dd988, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_logjammers)
STD_ROM_FN(nes_logjammers)

struct BurnDriver BurnDrvnes_logjammers = {
	"nes_logjammers", NULL, NULL, NULL, "2017",
	"Log Jammers (HB)\0", NULL, "Mega Cat Studios", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_BALLPADDLE, 0,
	NESGetZipName, nes_logjammersRomInfo, nes_logjammersRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lucky Penguin (HB)
static struct BurnRomInfo nes_luckypenguinRomDesc[] = {
	{ "Lucky Penguin (2019)(Mega Cat Studios).nes",          65552, 0x2a4c310b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_luckypenguin)
STD_ROM_FN(nes_luckypenguin)

struct BurnDriver BurnDrvnes_luckypenguin = {
	"nes_luckypenguin", NULL, NULL, NULL, "2019",
	"Lucky Penguin (HB)\0", NULL, "Mega Cat Studios", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_luckypenguinRomInfo, nes_luckypenguinRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lunar Limit (HB)
static struct BurnRomInfo nes_lunarlimitRomDesc[] = {
	{ "Lunar Limit (2017)(Pubby).nes",          40976, 0xeb26681e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lunarlimit)
STD_ROM_FN(nes_lunarlimit)

struct BurnDriver BurnDrvnes_lunarlimit = {
	"nes_lunarlimit", NULL, NULL, NULL, "2017",
	"Lunar Limit (HB)\0", NULL, "Pubby", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_lunarlimitRomInfo, nes_lunarlimitRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lunar Limit - Star Wars Edition (HB)
static struct BurnRomInfo nes_lunarlimitswRomDesc[] = {
	{ "Lunar Limit - Star Wars Edition (2021)(Pubby).nes",          40976, 0xc130d230, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lunarlimitsw)
STD_ROM_FN(nes_lunarlimitsw)

struct BurnDriver BurnDrvnes_lunarlimitsw = {
	"nes_lunarlimitsw", "nes_lunarlimit", NULL, NULL, "2021",
	"Lunar Limit - Star Wars Edition (HB)\0", NULL, "Pubby", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_lunarlimitswRomInfo, nes_lunarlimitswRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lupin III: Gentle Thief (GlobalHack)
// https://www.romhacking.net/hacks/7803/
static struct BurnRomInfo nes_lupin3gtRomDesc[] = {
	{ "Lupin III Gentle Thief (GlobHack)(2023)(ProtoPixel).nes",          24592, 0xc5671156, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lupin3gt)
STD_ROM_FN(nes_lupin3gt)

struct BurnDriver BurnDrvnes_lupin3gt = {
	"nes_lupin3gt", "nes_mappy", NULL, NULL, "2023",
	"Lupin III: Gentle Thief (GlobalHack)\0", NULL, "ProtoPixel", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_ACTION | GBF_PLATFORM, 0,
	NESGetZipName, nes_lupin3gtRomInfo, nes_lupin3gtRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mad Wizard, The - A Candelabra Chronicle (HB) (Sly Dog Studios)
static struct BurnRomInfo nes_madwizsdsRomDesc[] = {
	{ "Mad Wizard, The - A Candelabra Chronicle (2014)(Sly Dog Studios).nes",          131088, 0x5481d022, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_madwizsds)
STD_ROM_FN(nes_madwizsds)

struct BurnDriver BurnDrvnes_madwizsds = {
	"nes_madwizsds", NULL, NULL, NULL, "2014",
	"Mad Wizard, The - A Candelabra Chronicle (HB) (Sly Dog Studios)\0", NULL, "Sly Dog Studios", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_madwizsdsRomInfo, nes_madwizsdsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mad Wizard, The - A Candelabra Chronicle (HB)
static struct BurnRomInfo nes_madwizRomDesc[] = {
	{ "Mad Wizard, The - A Candelabra Chronicle (2014)(Robert L. Bryant).nes",          131088, 0x7750dac6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_madwiz)
STD_ROM_FN(nes_madwiz)

struct BurnDriver BurnDrvnes_madwiz = {
	"nes_madwiz", "nes_madwizsds", NULL, NULL, "2014",
	"Mad Wizard, The - A Candelabra Chronicle (HB)\0", NULL, "Robert L. Bryant", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_madwizRomInfo, nes_madwizRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Magical Control (HB)
static struct BurnRomInfo nes_magictrlRomDesc[] = {
	{ "Magical Control (2020)(Closet).nes",          40976, 0xb456441b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_magictrl)
STD_ROM_FN(nes_magictrl)

struct BurnDriver BurnDrvnes_magictrl = {
	"nes_magictrl", NULL, NULL, NULL, "2020",
	"Magical Control (HB)\0", NULL, "Closet", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_magictrlRomInfo, nes_magictrlRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Magnilo Case, The (HB, v1.11)
static struct BurnRomInfo nes_magnilocaseRomDesc[] = {
	{ "Magnilo Case, The v1.11 (2023)(Dalyen RetroGames).nes",          524304, 0xdb8e4ea4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_magnilocase)
STD_ROM_FN(nes_magnilocase)

struct BurnDriver BurnDrvnes_magnilocase = {
	"nes_magnilocase", NULL, NULL, NULL, "2021-23",
	"Magnilo Case, The (HB, v1.11)\0", NULL, "Dalyen RetroGames", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_magnilocaseRomInfo, nes_magnilocaseRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mario Adventure (Hack)
static struct BurnRomInfo nes_marioadventureRomDesc[] = {
	{ "Mario Adventure (Hack).nes",          426000, 0x2e6d3fdc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_marioadventure)
STD_ROM_FN(nes_marioadventure)

struct BurnDriver BurnDrvnes_marioadventure = {
	"nes_marioadventure", "nes_smb3", NULL, NULL, "2004",
	"Mario Adventure (Hack)\0", NULL, "DahrkDaiz", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_marioadventureRomInfo, nes_marioadventureRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mario Kart (GlobalHack)
static struct BurnRomInfo nes_mariokartRomDesc[] = {
	{ "Mario Kart GlobHack (2017)(pacnsacdave).nes",          65552, 0xca29d3f0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mariokart)
STD_ROM_FN(nes_mariokart)

struct BurnDriver BurnDrvnes_mariokart = {
	"nes_mariokart", "nes_rcproam", NULL, NULL, "2017",
	"Mario Kart (GlobalHack)\0", NULL, "pacnsacdave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW | BDF_HACK, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_mariokartRomInfo, nes_mariokartRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mario Quest (GlobalHack)
static struct BurnRomInfo nes_marioquestRomDesc[] = {
	{ "Mario Quest (2021)(Kitsunefox).nes",          40976, 0xed5be20d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_marioquest)
STD_ROM_FN(nes_marioquest)

struct BurnDriver BurnDrvnes_marioquest = {
	"nes_marioquest", "nes_smb", NULL, NULL, "2021",
	"Mario Quest (GlobalHack)\0", NULL, "Kitsunefox", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_marioquestRomInfo, nes_marioquestRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mattock Mike - The Legend of Pete (HB)
static struct BurnRomInfo nes_mattockmikeRomDesc[] = {
	{ "Mattock Mike - The Legend of Pete (2023)(NESLurker).nes",          524304, 0xb0c8187a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mattockmike)
STD_ROM_FN(nes_mattockmike)

struct BurnDriver BurnDrvnes_mattockmike = {
	"nes_mattockmike", NULL, NULL, NULL, "2023",
	"Mattock Mike - The Legend of Pete (HB)\0", NULL, "NESLurker", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_mattockmikeRomInfo, nes_mattockmikeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mawthorne (USA) (HB)
static struct BurnRomInfo nes_mawthorneRomDesc[] = {
	{ "Mawthorne (USA, Europe)(2022)(CGT Games).nes",          524304, 0x447bec5d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mawthorne)
STD_ROM_FN(nes_mawthorne)

struct BurnDriver BurnDrvnes_mawthorne = {
	"nes_mawthorne", NULL, NULL, NULL, "2022",
	"Mawthorne (USA) (HB)\0", NULL, "CGT Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_mawthorneRomInfo, nes_mawthorneRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mawthorne (Japan) (HB)
static struct BurnRomInfo nes_mawthornejRomDesc[] = {
	{ "Mawthorne (Japan)(2022)(CGT Games).nes",          524304, 0x471ddcbf, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mawthornej)
STD_ROM_FN(nes_mawthornej)

struct BurnDriver BurnDrvnes_mawthornej = {
	"nes_mawthornej", "nes_mawthorne", NULL, NULL, "2022",
	"Mawthorne (Japan) (HB)\0", NULL, "CGT Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_mawthornejRomInfo, nes_mawthornejRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mauri Mursu's Hangover (HB)
static struct BurnRomInfo nes_maurimursuRomDesc[] = {
	{ "Mauri Mursu's Hangover (2022)(Nervanti).nes",          524304, 0xa5fac69c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_maurimursu)
STD_ROM_FN(nes_maurimursu)

struct BurnDriver BurnDrvnes_maurimursu = {
	"nes_maurimursu", NULL, NULL, NULL, "2022",
	"Mauri Mursu's Hangover (HB)\0", NULL, "Nervanti", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_maurimursuRomInfo, nes_maurimursuRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Meating, The (HB)
static struct BurnRomInfo nes_meatingRomDesc[] = {
	{ "Meating, The (2023)(Mega Cat Studios).nes",          262160, 0xf9e9d432, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_meating)
STD_ROM_FN(nes_meating)

struct BurnDriver BurnDrvnes_meating = {
	"nes_meating", NULL, NULL, NULL, "2023",
	"Meating, The (HB)\0", NULL, "Mega Cat Studios", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_meatingRomInfo, nes_meatingRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Meating, The - Cafeparty (HB, Demo)
static struct BurnRomInfo nes_meatingcpRomDesc[] = {
	{ "Meating, The - Cafeparty Demo (2019)(Mega Cat Studios).nes",          262160, 0xe704ef0a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_meatingcp)
STD_ROM_FN(nes_meatingcp)

struct BurnDriver BurnDrvnes_meatingcp = {
	"nes_meatingcp", "nes_meating", NULL, NULL, "2019",
	"Meating, The - Cafeparty (HB, Demo)\0", NULL, "Mega Cat Studios", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_meatingcpRomInfo, nes_meatingcpRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mega Man Age of Wily (GlobalHack)
static struct BurnRomInfo nes_megamanxRomDesc[] = {
	{ "Mega Man Age of Wily GlobalHack (2015)(pacnsacdave).nes",          524304, 0x9414c14f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_megamanx)
STD_ROM_FN(nes_megamanx)

struct BurnDriver BurnDrvnes_megamanx = {
	"nes_megamanx", "nes_megaman", NULL, NULL, "2015",
	"Mega Man Age of Wily (GlobalHack)\0", NULL, "pacnsacdave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_megamanxRomInfo, nes_megamanxRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Metroid - Origin Enhanced (GlobalHack, v2.1.2)
// https://www.romhacking.net/hacks/1147/
static struct BurnRomInfo nes_metroorienhRomDesc[] = {
	{ "Metroid - Origin Enhanced (Hack, v2.1.2)(2016)(JoQualian).nes",          393232, 0xa81055ab, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_metroorienh)
STD_ROM_FN(nes_metroorienh)

struct BurnDriver BurnDrvnes_metroorienh = {
	"nes_metroorienh", "nes_metroid", NULL, NULL, "2016",
	"Metroid - Origin Enhanced (GlobalHack, v2.1.2)\0", NULL, "JoQualian", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_metroorienhRomInfo, nes_metroorienhRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Metroid - Rogue Dawn (GlobalHack, v1.21)
// https://www.romhacking.net/hacks/3280/
static struct BurnRomInfo nes_metrorogdawRomDesc[] = {
	{ "Metroid - Rogue Dawn (Hack, v1.21)(2022)(snarfblam).nes",          786448, 0x5cc08cb1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_metrorogdaw)
STD_ROM_FN(nes_metrorogdaw)

struct BurnDriver BurnDrvnes_metrorogdaw = {
	"nes_metrorogdaw", "nes_metroid", NULL, NULL, "2022",
	"Metroid - Rogue Dawn (GlobalHack, v1.21)\0", NULL, "snarfblam, Optomon, Grimlock", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_metrorogdawRomInfo, nes_metrorogdawRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Metroid mOTHER (GlobalHack)
// https://www.romhacking.net/hacks/1988/
static struct BurnRomInfo nes_metroidmotherRomDesc[] = {
	{ "Metroid Mother (GlobalHack)(2014)(dACE).nes",          393232, 0x04819e27, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_metroidmother)
STD_ROM_FN(nes_metroidmother)

struct BurnDriver BurnDrvnes_metroidmother = {
	"nes_metroidmother", "nes_metroid", NULL, NULL, "2014",
	"Metroid mOTHER (GlobalHack)\0", NULL, "dACE", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_metroidmotherRomInfo, nes_metroidmotherRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Micro Knight - Revenge of the Four Skulls (HB)
static struct BurnRomInfo nes_mkrotfsRomDesc[] = {
	{ "Micro Knight RotFS (2017)(Unknown).nes",          131088, 0xbc44af32, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mkrotfs)
STD_ROM_FN(nes_mkrotfs)

struct BurnDriver BurnDrvnes_mkrotfs = {
	"nes_mkrotfs", NULL, NULL, NULL, "2017",
	"Micro Knight - Revenge of the Four Skulls (HB)\0", NULL, "<unknown>", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_mkrotfsRomInfo, nes_mkrotfsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Micro Mages (HB)
static struct BurnRomInfo nes_micromagesRomDesc[] = {
	{ "Micro Mages (2019)(Morphcat Games).nes",          40976, 0xb0b6b5e4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_micromages)
STD_ROM_FN(nes_micromages)

struct BurnDriver BurnDrvnes_micromages = {
	"nes_micromages", NULL, NULL, NULL, "2019",
	"Micro Mages (HB)\0", NULL, "Morphcat Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 4, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_micromagesRomInfo, nes_micromagesRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Micro Mages - Second Quest (HB)
static struct BurnRomInfo nes_micromages2RomDesc[] = {
	{ "Micro Mages - Second Quest (2022)(Morphcat Games).nes",          40976, 0xbbc0ef28, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_micromages2)
STD_ROM_FN(nes_micromages2)

struct BurnDriver BurnDrvnes_micromages2 = {
	"nes_micromages2", NULL, NULL, NULL, "2022",
	"Micro Mages - Second Quest (HB)\0", NULL, "Morphcat Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 4, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_micromages2RomInfo, nes_micromages2RomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Miedow (HB)
static struct BurnRomInfo nes_miedowRomDesc[] = {
	{ "Miedow (2018)(The Mojon Twins).nes",          65552, 0x6389b721, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_miedow)
STD_ROM_FN(nes_miedow)

struct BurnDriver BurnDrvnes_miedow = {
	"nes_miedow", NULL, NULL, NULL, "2018",
	"Miedow (HB)\0", NULL, "The Mojon Twins", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_MAZE | GBF_ACTION, 0,
	NESGetZipName, nes_miedowRomInfo, nes_miedowRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Minekart Madness (HB)
static struct BurnRomInfo nes_mkmadnessRomDesc[] = {
	{ "Minekart Madness (2022)(Matt Hughson).nes",          65552, 0x165519c7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mkmadness)
STD_ROM_FN(nes_mkmadness)

struct BurnDriver BurnDrvnes_mkmadness = {
	"nes_mkmadness", NULL, NULL, NULL, "2022",
	"Minekart Madness (HB)\0", NULL, "Matt Hughson", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_mkmadnessRomInfo, nes_mkmadnessRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Minekart Madness (HB, MMC1 ver.)
static struct BurnRomInfo nes_mkmadnessmmc1RomDesc[] = {
	{ "Minekart Madness mmc1 (2022)(Matt Hughson).nes",          262160, 0x14297e1e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mkmadnessmmc1)
STD_ROM_FN(nes_mkmadnessmmc1)

struct BurnDriver BurnDrvnes_mkmadnessmmc1 = {
	"nes_mkmadnessmmc1", "nes_mkmadness", NULL, NULL, "2022",
	"Minekart Madness (HB, MMC1 ver.)\0", NULL, "Matt Hughson", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_mkmadnessmmc1RomInfo, nes_mkmadnessmmc1RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mine Mayhem (HB)
static struct BurnRomInfo nes_mnmayhemRomDesc[] = {
	{ "Mine Mayhem (2021)(Vectrex28).nes",          65552, 0xc6b47cca, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mnmayhem)
STD_ROM_FN(nes_mnmayhem)

struct BurnDriver BurnDrvnes_mnmayhem = {
	"nes_mnmayhem", NULL, NULL, NULL, "2021",
	"Mine Mayhem (HB)\0", NULL, "FG Software", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_mnmayhemRomInfo, nes_mnmayhemRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mini Brix Battle (HB)
static struct BurnRomInfo nes_minibrixRomDesc[] = {
	{ "Mini Brix Battle (2016)(Aleff Correa).nes",          40976, 0x07781bee, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_minibrix)
STD_ROM_FN(nes_minibrix)

struct BurnDriver BurnDrvnes_minibrix = {
	"nes_minibrix", NULL, NULL, NULL, "2016",
	"Mini Brix Battle (HB)\0", NULL, "Aleff Correa", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_BREAKOUT, 0,
	NESGetZipName, nes_minibrixRomInfo, nes_minibrixRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Miroh (HB, v2.0.1)
static struct BurnRomInfo nes_mirohv2RomDesc[] = {
	{ "Miroh v2.0.1 (2023)(Wendel Scardua).nes",          65552, 0xa3b6f766, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mirohv2)
STD_ROM_FN(nes_mirohv2)

struct BurnDriver BurnDrvnes_mirohv2 = {
	"nes_mirohv2", NULL, NULL, NULL, "2023",
	"Miroh (HB, v2.0.1)\0", NULL, "Wendel Scardua", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION | GBF_PUZZLE, 0,
	NESGetZipName, nes_mirohv2RomInfo, nes_mirohv2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Miroh (HB, v1.0.1)
static struct BurnRomInfo nes_mirohv1RomDesc[] = {
	{ "Miroh v1.0.1 (2023)(Wendel Scardua).nes",          65552, 0xec4ef53c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mirohv1)
STD_ROM_FN(nes_mirohv1)

struct BurnDriver BurnDrvnes_mirohv1 = {
	"nes_mirohv1", "nes_mirohv2", NULL, NULL, "2023",
	"Miroh (HB, v1.0.1)\0", NULL, "Wendel Scardua", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION | GBF_PUZZLE, 0,
	NESGetZipName, nes_mirohv1RomInfo, nes_mirohv1RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Miroh Jr. (HB)
static struct BurnRomInfo nes_mirohjrRomDesc[] = {
	{ "Miroh Jr. (2023)(Wendel Scardua).nes",          65552, 0xcb64f80d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mirohjr)
STD_ROM_FN(nes_mirohjr)

struct BurnDriver BurnDrvnes_mirohjr = {
	"nes_mirohjr", NULL, NULL, NULL, "2023",
	"Miroh Jr. (HB)\0", NULL, "Wendel Scardua", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_ACTION | GBF_PUZZLE, 0,
	NESGetZipName, nes_mirohjrRomInfo, nes_mirohjrRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mischief Castle (HB)
static struct BurnRomInfo nes_miscastleRomDesc[] = {
	{ "Mischief Castle (2024)(kn56k).nes",          524304, 0x73e3120b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_miscastle)
STD_ROM_FN(nes_miscastle)

struct BurnDriver BurnDrvnes_miscastle = {
	"nes_miscastle", NULL, NULL, NULL, "2024",
	"Mischief Castle (HB)\0", NULL, "kn56k", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_miscastleRomInfo, nes_miscastleRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mogura Mines (HB)
static struct BurnRomInfo nes_mogminesRomDesc[] = {
	{ "Mogura Mines (2022)(8Bitalo).nes",          524304, 0xf8d0825d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mogmines)
STD_ROM_FN(nes_mogmines)

struct BurnDriver BurnDrvnes_mogmines = {
	"nes_mogmines", NULL, NULL, NULL, "2022",
	"Mogura Mines (HB)\0", NULL, "8Bitalo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_mogminesRomInfo, nes_mogminesRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Montezuma's Revenge (HB, v1.1)
static struct BurnRomInfo nes_monterevRomDesc[] = {
	{ "Montezuma's Revenge v1.1 (2022)(Second Dimension).nes",          40976, 0x161baad2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_monterev)
STD_ROM_FN(nes_monterev)

struct BurnDriver BurnDrvnes_monterev = {
	"nes_monterev", NULL, NULL, NULL, "2022",
	"Montezuma's Revenge (HB, v1.1)\0", NULL, "Second Dimension", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_monterevRomInfo, nes_monterevRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Moonglow (HB)
static struct BurnRomInfo nes_moonglowRomDesc[] = {
	{ "Moonglow (2021)(Yurt Fiend).nes",          40976, 0xb4255e99, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_moonglow)
STD_ROM_FN(nes_moonglow)

struct BurnDriver BurnDrvnes_moonglow = {
	"nes_moonglow", NULL, NULL, NULL, "2021",
	"Moonglow (HB)\0", NULL, "Yurt Fiend", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_moonglowRomInfo, nes_moonglowRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL+8, SCREEN_WIDTH, SCREEN_HEIGHT_PAL+8
};

// More Glider (HB)
static struct BurnRomInfo nes_moregliderRomDesc[] = {
	{ "More Glider (2009)(Retro USB).nes",          524304, 0x4ed588ce, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_moreglider)
STD_ROM_FN(nes_moreglider)

struct BurnDriver BurnDrvnes_moreglider = {
	"nes_moreglider", NULL, NULL, NULL, "2009",
	"More Glider (HB)\0", NULL, "Retro USB", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_moregliderRomInfo, nes_moregliderRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mosh Lift (HB)
static struct BurnRomInfo nes_moshliftRomDesc[] = {
	{ "Mosh Lift (2023)(Morphcat Games).nes",          65552, 0xc6ab4c44, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_moshlift)
STD_ROM_FN(nes_moshlift)

struct BurnDriver BurnDrvnes_moshlift = {
	"nes_moshlift", NULL, NULL, NULL, "2023",
	"Mosh Lift (HB)\0", NULL, "Morphcat Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_moshliftRomInfo, nes_moshliftRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mr. Maymunshines Christmas Land (HB)
static struct BurnRomInfo nes_mrmayclRomDesc[] = {
	{ "Mr. Maymunshines Christmas Land (2020)(Calgames).nes",          524304, 0x36fe2a47, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mrmaycl)
STD_ROM_FN(nes_mrmaycl)

struct BurnDriver BurnDrvnes_mrmaycl = {
	"nes_mrmaycl", NULL, NULL, NULL, "2020",
	"Mr. Maymunshines Christmas Land (HB)\0", NULL, "Calgames", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_mrmayclRomInfo, nes_mrmayclRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mr. Splash (HB)
static struct BurnRomInfo nes_mrsplashRomDesc[] = {
	{ "Mr. Splash (2008)(Project F).nes",          750052, 0x8b86978b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mrsplash)
STD_ROM_FN(nes_mrsplash)

struct BurnDriver BurnDrvnes_mrsplash = {
	"nes_mrsplash", NULL, NULL, NULL, "2008",
	"Mr. Splash (HB)\0", "2 player mode only", "Project F", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_mrsplashRomInfo, nes_mrsplashRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Nova the Squirrel (HB)
static struct BurnRomInfo nes_novasquRomDesc[] = {
	{ "Nova the Squirrel (2018)(NovaSquirrel).nes",          262160, 0x0b752bee, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_novasqu)
STD_ROM_FN(nes_novasqu)

struct BurnDriver BurnDrvnes_novasqu = {
	"nes_novasqu", NULL, NULL, NULL, "2018",
	"Nova the Squirrel (HB)\0", NULL, "NovaSquirrel", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_novasquRomInfo, nes_novasquRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Multidude (HB)
static struct BurnRomInfo nes_multidudeRomDesc[] = {
	{ "Multidude (2014)(RetroSouls).nes",          40976, 0x154af940, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_multidude)
STD_ROM_FN(nes_multidude)

struct BurnDriver BurnDrvnes_multidude = {
	"nes_multidude", NULL, NULL, NULL, "2014",
	"Multidude (HB)\0", NULL, "RetroSouls", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_multidudeRomInfo, nes_multidudeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mushroom Heaven (Hack)
// https://www.romhacking.net/hacks/6803/
static struct BurnRomInfo nes_musheavenRomDesc[] = {
	{ "Mushroom Heaven (2022)(sinksadventure).nes",          40976, 0xd5ce9457, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_musheaven)
STD_ROM_FN(nes_musheaven)

struct BurnDriver BurnDrvnes_musheaven = {
	"nes_musheaven", "nes_smb", NULL, NULL, "2022",
	"Mushroom Heaven (Hack)\0", NULL, "sinksadventure", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_musheavenRomInfo, nes_musheavenRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mystic Origins (HB)
static struct BurnRomInfo nes_mysticoriginsRomDesc[] = {
	{ "Mystic Origins (2019)(New 8-bit Heroes).nes",          524304, 0x249c666e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mysticorigins)
STD_ROM_FN(nes_mysticorigins)

struct BurnDriver BurnDrvnes_mysticorigins = {
	"nes_mysticorigins", NULL, NULL, NULL, "2019",
	"Mystic Origins (HB)\0", NULL, "New 8-bit Heroes", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_mysticoriginsRomInfo, nes_mysticoriginsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mystic Pillars (HB)
static struct BurnRomInfo nes_mystpillarsRomDesc[] = {
	{ "Mystic Pillars (2008)(Sivak Games).nes",          524304, 0x420f1b1a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mystpillars)
STD_ROM_FN(nes_mystpillars)

struct BurnDriver BurnDrvnes_mystpillars = {
	"nes_mystpillars", NULL, NULL, NULL, "2008",
	"Mystic Pillars (HB)\0", NULL, "Sivak Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_mystpillarsRomInfo, nes_mystpillarsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Nalle Land (HB, v0.4.0)
static struct BurnRomInfo nes_nallelandRomDesc[] = {
	{ "Nalle Land (HB, v040).nes",          49168, 0xc1a447b0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_nalleland)
STD_ROM_FN(nes_nalleland)

struct BurnDriver BurnDrvnes_nalleland = {
	"nes_nalleland", NULL, NULL, NULL, "2020",
	"Nalle Land (HB, v0.4.0)\0", NULL, "Benjamin Larsson", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_nallelandRomInfo, nes_nallelandRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Nebs and Debs (HB)
static struct BurnRomInfo nes_nebsanddebsRomDesc[] = {
	{ "Nebs and Debs (2018)(Dullahan).nes",          40976, 0x570383a9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_nebsanddebs)
STD_ROM_FN(nes_nebsanddebs)

struct BurnDriver BurnDrvnes_nebsanddebs = {
	"nes_nebsanddebs", NULL, NULL, NULL, "2018",
	"Nebs and Debs (HB)\0", NULL, "Dullahan", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_nebsanddebsRomInfo, nes_nebsanddebsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// neMULEsis (HB, v2.25.23)
static struct BurnRomInfo nes_nemulesisRomDesc[] = {
	{ "neMULEsis v2.25.23 (2023)(John Vanderhoef).nes",          524304, 0x9982f1b7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_nemulesis)
STD_ROM_FN(nes_nemulesis)

struct BurnDriver BurnDrvnes_nemulesis = {
	"nes_nemulesis", NULL, NULL, NULL, "2021-23",
	"neMULEsis (HB, v2.25.23)\0", NULL, "John Vanderhoef", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_nemulesisRomInfo, nes_nemulesisRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// NEO Heiankyo Alien (HB)
static struct BurnRomInfo nes_neoheialiRomDesc[] = {
	{ "NEO Heiankyo Alien (2017)(Hyperware Co.).nes",          655376, 0xf9450fc9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_neoheiali)
STD_ROM_FN(nes_neoheiali)

struct BurnDriver BurnDrvnes_neoheiali = {
	"nes_neoheiali", NULL, NULL, NULL, "2017",
	"NEO Heiankyo Alien (HB)\0", NULL, "Hyperware Co.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_MAZE, 0,
	NESGetZipName, nes_neoheialiRomInfo, nes_neoheialiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// NEScape (HB)
static struct BurnRomInfo nes_nescapeRomDesc[] = {
	{ "NEScape (2019)(Khan Games).nes",          524304, 0x60b6ad99, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_nescape)
STD_ROM_FN(nes_nescape)

struct BurnDriver BurnDrvnes_nescape = {
	"nes_nescape", NULL, NULL, NULL, "2019",
	"NEScape (HB)\0", NULL, "Khan Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_nescapeRomInfo, nes_nescapeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// NESert Golfing (HB)
static struct BurnRomInfo nes_nesertgolfRomDesc[] = {
	{ "NESert Golfing (2019)(Unknown).nes",          32784, 0xcb43ec95, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_nesertgolf)
STD_ROM_FN(nes_nesertgolf)

struct BurnDriver BurnDrvnes_nesertgolf = {
	"nes_nesertgolf", NULL, NULL, NULL, "2019",
	"NESert Golfing (HB)\0", NULL, "<unknown>", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 4, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_nesertgolfRomInfo, nes_nesertgolfRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// NESert Golfing - Tournament Edition (HB)
static struct BurnRomInfo nes_nesertgolfteRomDesc[] = {
	{ "NESert Golfing - Tournament Edition (2019)(Unknown).nes",          32784, 0xdb28a4e8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_nesertgolfte)
STD_ROM_FN(nes_nesertgolfte)

struct BurnDriver BurnDrvnes_nesertgolfte = {
	"nes_nesertgolfte", "nes_nesertgolf", NULL, NULL, "2019",
	"NESert Golfing - Tournament Edition (HB)\0", NULL, "<unknown>", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 4, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_nesertgolfteRomInfo, nes_nesertgolfteRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// NES Hangman (HB)
static struct BurnRomInfo nes_hangmanRomDesc[] = {
	{ "NES Hangman (2015)(FG Software).nes",          40976, 0xb0500cd4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hangman)
STD_ROM_FN(nes_hangman)

struct BurnDriver BurnDrvnes_hangman = {
	"nes_hangman", NULL, NULL, NULL, "2015",
	"NES Hangman (HB)\0", NULL, "FG Software", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_hangmanRomInfo, nes_hangmanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Nessy the NES Robot (HB, v1.30)
static struct BurnRomInfo nes_nessyrobotRomDesc[] = {
	{ "Nessy the NES Robot v1.30 (2021)(Daniel T. Gaming).nes",          524304, 0x709d7dcf, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_nessyrobot)
STD_ROM_FN(nes_nessyrobot)

struct BurnDriver BurnDrvnes_nessyrobot = {
	"nes_nessyrobot", NULL, NULL, NULL, "2021",
	"Nessy the NES Robot (HB, v1.30)\0", NULL, "Daniel T. Gaming", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_nessyrobotRomInfo, nes_nessyrobotRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Nightmare on Elm Street, A - Son of a Hundred Maniacs Demake (HB)
static struct BurnRomInfo nes_nightelmstreetdmkRomDesc[] = {
	{ "Nightmare on Elm Street, A - Son of a Hundred Maniacs Demake (1999-2022)(Fista Productions).nes",          524304, 0x7c6b0b6c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_nightelmstreetdmk)
STD_ROM_FN(nes_nightelmstreetdmk)

struct BurnDriver BurnDrvnes_nightelmstreetdmk = {
	"nes_nightelmstreetdmk", NULL, NULL, NULL, "1999-2022",
	"Nightmare on Elm Street, A - Son of a Hundred Maniacs Demake (HB)\0", NULL, "Fista Productions", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_nightelmstreetdmkRomInfo, nes_nightelmstreetdmkRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Nim & Nom (HB, v1.2)
static struct BurnRomInfo nes_nimnomRomDesc[] = {
	{ "Nim and Nom v1.2 (2018)(Metakrill).nes",          40976, 0xe0096736, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_nimnom)
STD_ROM_FN(nes_nimnom)

struct BurnDriver BurnDrvnes_nimnom = {
	"nes_nimnom", NULL, NULL, NULL, "2018",
	"Nim & Nom (HB, v1.2)\0", NULL, "Metakrill", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_nimnomRomInfo, nes_nimnomRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ninja of the 4 Seasons (HB)
static struct BurnRomInfo nes_ninja4sRomDesc[] = {
	{ "Ninja of the 4 Seasons (2021)(Kool Doob).nes",          524304, 0x3943cf5f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ninja4s)
STD_ROM_FN(nes_ninja4s)

struct BurnDriver BurnDrvnes_ninja4s = {
	"nes_ninja4s", NULL, NULL, NULL, "2021",
	"Ninja of the 4 Seasons (HB)\0", NULL, "Kool Doob", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_ninja4sRomInfo, nes_ninja4sRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Nin-Nin (HB, v1)
static struct BurnRomInfo nes_ninninRomDesc[] = {
	{ "Nin-Nin v1 (2020)(The Mojon Twins).nes",          65552, 0xd46b4955, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ninnin)
STD_ROM_FN(nes_ninnin)

struct BurnDriver BurnDrvnes_ninnin = {
	"nes_ninnin", NULL, NULL, NULL, "2020",
	"Nin-Nin (HB, v1)\0", NULL, "The Mojon Twins", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_ninninRomInfo, nes_ninninRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Nix: the Paradox Relic (HB, v1.9)
static struct BurnRomInfo nes_nixrelicRomDesc[] = {
	{ "Nix Paradox Relic v1.9 (2020)(Dustin Huddleston).nes",          524304, 0xc85e7bcd, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_nixrelic)
STD_ROM_FN(nes_nixrelic)

struct BurnDriver BurnDrvnes_nixrelic = {
	"nes_nixrelic", NULL, NULL, NULL, "2020",
	"Nix: the Paradox Relic (HB, v1.9)\0", NULL, "Dustin Huddleston", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_nixrelicRomInfo, nes_nixrelicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Nosey Joe - The Power Mystery (HB, v1.2)
static struct BurnRomInfo nes_noseyjoeRomDesc[] = {
	{ "Nosey Joe - The Power Mystery v1.2 (2023)(baardbi).nes",          524304, 0xca912d20, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_noseyjoe)
STD_ROM_FN(nes_noseyjoe)

struct BurnDriver BurnDrvnes_noseyjoe = {
	"nes_noseyjoe", NULL, NULL, NULL, "2023",
	"Nosey Joe - The Power Mystery (HB, v1.2)\0", NULL, "baardbi", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_noseyjoeRomInfo, nes_noseyjoeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Oopi's Quest (HB, v1.2.0)
static struct BurnRomInfo nes_oopiquestRomDesc[] = {
	{ "Oopi's Quest v1.2.0 (2022)(Kenney).nes",          40976, 0x34de6da0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_oopiquest)
STD_ROM_FN(nes_oopiquest)

struct BurnDriver BurnDrvnes_oopiquest = {
	"nes_oopiquest", NULL, NULL, NULL, "2022",
	"Oopi's Quest (HB, v1.2.0)\0", NULL, "Kenney", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_oopiquestRomInfo, nes_oopiquestRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ooze Redux (HB)
static struct BurnRomInfo nes_oozerdxRomDesc[] = {
	{ "Ooze Redux (2021)(Hippokittie Prod.).nes",          524304, 0x047a83d5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_oozerdx)
STD_ROM_FN(nes_oozerdx)

struct BurnDriver BurnDrvnes_oozerdx = {
	"nes_oozerdx", NULL, NULL, NULL, "2021",
	"Ooze Redux (HB)\0", NULL, "Hippokittie Productions", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_oozerdxRomInfo, nes_oozerdxRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Oratorio (HB)
static struct BurnRomInfo nes_oratorioRomDesc[] = {
	{ "Oratorio (2023)(John Vanderhoef).nes",          524304, 0x785e1b67, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_oratorio)
STD_ROM_FN(nes_oratorio)

struct BurnDriver BurnDrvnes_oratorio = {
	"nes_oratorio", NULL, NULL, NULL, "2023",
	"Oratorio (HB)\0", NULL, "John Vanderhoef", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_oratorioRomInfo, nes_oratorioRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Orebody - Binder's Tale (HB, v1.x)
static struct BurnRomInfo nes_orebodybtRomDesc[] = {
	{ "Orebody - Binder's Tale v1.x (2022)(John Vanderhoef).nes",          524304, 0x45e91f5a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_orebodybt)
STD_ROM_FN(nes_orebodybt)

struct BurnDriver BurnDrvnes_orebodybt = {
	"nes_orebodybt", "nes_orebodybtr", NULL, NULL, "2022",
	"Orebody - Binder's Tale (HB, v1.x)\0", NULL, "John Vanderhoef", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_orebodybtRomInfo, nes_orebodybtRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Orebody - Binder's Tale (HB, v1.0)
static struct BurnRomInfo nes_orebodybtrRomDesc[] = {
	{ "Orebody Binder's Tale v1.0 (2022)(John Vanderhoef).nes",          524304, 0x4b39e16b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_orebodybtr)
STD_ROM_FN(nes_orebodybtr)

struct BurnDriver BurnDrvnes_orebodybtr = {
	"nes_orebodybtr", NULL, NULL, NULL, "2022-23",
	"Orebody - Binder's Tale (HB, v1.0)\0", NULL, "John Vanderhoef", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_orebodybtrRomInfo, nes_orebodybtrRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Orebody - Sand Ripples (HB)
static struct BurnRomInfo nes_orebodysrRomDesc[] = {
	{ "Orebody - Sand Ripples (2022)(Orebody Inc.).nes",          40976, 0xb7917a5f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_orebodysr)
STD_ROM_FN(nes_orebodysr)

struct BurnDriver BurnDrvnes_orebodysr = {
	"nes_orebodysr", NULL, NULL, NULL, "2022",
	"Orebody - Sand Ripples (HB)\0", NULL, "Orebody Inc.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_orebodysrRomInfo, nes_orebodysrRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Orphan Moon (GlobalHack)
// https://www.romhacking.net/hacks/8475/
static struct BurnRomInfo nes_orphanmoonRomDesc[] = {
	{ "Orphan Moon (2024)(Doc Remedy).nes",          393232, 0xbab230fa, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_orphanmoon)
STD_ROM_FN(nes_orphanmoon)

struct BurnDriver BurnDrvnes_orphanmoon = {
	"nes_orphanmoon", "nes_metroid", NULL, NULL, "2024",
	"Orphan Moon (GlobalHack)\0", NULL, "Doc Remedy", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_orphanmoonRomInfo, nes_orphanmoonRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Orphea (HB, v1.1)
static struct BurnRomInfo nes_orpheaRomDesc[] = {
	{ "Orphea v1.1 (2021)(SkyBoy Games).nes",          40976, 0x7d8a4906, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_orphea)
STD_ROM_FN(nes_orphea)

struct BurnDriver BurnDrvnes_orphea = {
	"nes_orphea", NULL, NULL, NULL, "2021",
	"Orphea (HB, v1.1)\0", NULL, "Skyboy Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_orpheaRomInfo, nes_orpheaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Over Obj (HB)
static struct BurnRomInfo nes_overobjRomDesc[] = {
	{ "Over Obj (2023)(Little Sound).nes",          262160, 0xb9fd4de8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_overobj)
STD_ROM_FN(nes_overobj)

struct BurnDriver BurnDrvnes_overobj = {
	"nes_overobj", NULL, NULL, NULL, "2023",
	"Over Obj (HB)\0", NULL, "Little Sound", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_overobjRomInfo, nes_overobjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Pac-Man Championship Edition (World)
static struct BurnRomInfo nes_pacmanceRomDesc[] = {
	{ "Pac-Man CE (2020)(Namco - BNEI).nes",          262160, 0xb86c09af, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pacmance)
STD_ROM_FN(nes_pacmance)

struct BurnDriver BurnDrvnes_pacmance = {
	"nes_pacmance", NULL, NULL, NULL, "2020",
	"Pac-Man Championship Edition (World)\0", NULL, "Namco - BNEI", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_MAZE | GBF_ACTION, 0,
	NESGetZipName, nes_pacmanceRomInfo, nes_pacmanceRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Pac-Man Xtreme (Hack)
static struct BurnRomInfo nes_pacmanxRomDesc[] = {
	{ "Pac-Man Xtreme (2016)(KaBooM!).nes",          40976, 0xee653ac8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pacmanx)
STD_ROM_FN(nes_pacmanx)

struct BurnDriver BurnDrvnes_pacmanx = {
	"nes_pacmanx", NULL, NULL, NULL, "2016",
	"Pac-Man Xtreme (Hack)\0", NULL, "KaBooM!", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_MAZE | GBF_ACTION, 0,
	NESGetZipName, nes_pacmanxRomInfo, nes_pacmanxRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Paper Plane, The (HB, v2)
static struct BurnRomInfo nes_pplanev2RomDesc[] = {
	{ "Paper Plane, The v2 (2022)(5cinq).nes",          524304, 0x9fe3d96e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pplanev2)
STD_ROM_FN(nes_pplanev2)

struct BurnDriver BurnDrvnes_pplanev2 = {
	"nes_pplanev2", NULL, NULL, NULL, "2022",
	"Paper Plane, The (HB, v2)\0", NULL, "5cinq", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_pplanev2RomInfo, nes_pplanev2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Pelusa Saga - Kaji's Trials (HB)
static struct BurnRomInfo nes_pelusagaRomDesc[] = {
	{ "Pelusa Saga - Kaji's Trials (2023)(Broke Studio).nes",          524304, 0xbc461bfe, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pelusaga)
STD_ROM_FN(nes_pelusaga)

struct BurnDriver BurnDrvnes_pelusaga = {
	"nes_pelusaga", NULL, NULL, NULL, "2023",
	"Pelusa Saga - Kaji's Trials (HB)\0", NULL, "Broke Studio", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_pelusagaRomInfo, nes_pelusagaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Pentablocat (HB)
static struct BurnRomInfo nes_pentablocatRomDesc[] = {
	{ "Pentablocat (2023)(Pineberry fox).nes",          24592, 0x27a14751, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pentablocat)
STD_ROM_FN(nes_pentablocat)

struct BurnDriver BurnDrvnes_pentablocat = {
	"nes_pentablocat", NULL, NULL, NULL, "2023",
	"Pentablocat (HB)\0", NULL, "Pineberry fox", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_pentablocatRomInfo, nes_pentablocatRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Perfect Pair (HB)
static struct BurnRomInfo nes_perfectpairRomDesc[] = {
	{ "Perfect Pair (2016)(Second Dimension).nes",          40976, 0xefef8b35, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_perfectpair)
STD_ROM_FN(nes_perfectpair)

struct BurnDriver BurnDrvnes_perfectpair = {
	"nes_perfectpair", NULL, NULL, NULL, "2016",
	"Perfect Pair (HB)\0", NULL, "Second Dimension", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_perfectpairRomInfo, nes_perfectpairRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// PERKELE! Suomi 100 vuotta - 5th anniversary edition (HB)
static struct BurnRomInfo nes_perkeleRomDesc[] = {
	{ "PERKELE! Suomi 100 vuotta 5th anniversary edition (2022)(AasiPelit).nes",          393232, 0xbec64871, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_perkele)
STD_ROM_FN(nes_perkele)

struct BurnDriver BurnDrvnes_perkele = {
	"nes_perkele", NULL, NULL, NULL, "2022",
	"PERKELE! Suomi 100 vuotta - 5th anniversary edition (HB)\0", NULL, "AasiPelit", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_perkeleRomInfo, nes_perkeleRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Pinky (HB)
static struct BurnRomInfo nes_pinkyRomDesc[] = {
	{ "Pinky (2020)(Axbakk Games).nes",          524304, 0xcb0bcb5d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pinky)
STD_ROM_FN(nes_pinky)

struct BurnDriver BurnDrvnes_pinky = {
	"nes_pinky", NULL, NULL, NULL, "2020",
	"Pinky (HB)\0", NULL, "Axbakk Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_pinkyRomInfo, nes_pinkyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Pinky Xmas (HB)
static struct BurnRomInfo nes_pinkyxmasRomDesc[] = {
	{ "Pinky Xmas (2020)(Axbakk Games).nes",          524304, 0xc1d80a1d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pinkyxmas)
STD_ROM_FN(nes_pinkyxmas)

struct BurnDriver BurnDrvnes_pinkyxmas = {
	"nes_pinkyxmas", NULL, NULL, NULL, "2020",
	"Pinky Xmas (HB)\0", NULL, "Axbakk Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_pinkyxmasRomInfo, nes_pinkyxmasRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Pixel Poops Number Two (HB)
static struct BurnRomInfo nes_pixelpoopsRomDesc[] = {
	{ "Pixel Poops Number Two (2021)(Techmaster Games).nes",          524304, 0x17812952, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pixelpoops)
STD_ROM_FN(nes_pixelpoops)

struct BurnDriver BurnDrvnes_pixelpoops = {
	"nes_pixelpoops", NULL, NULL, NULL, "2021",
	"Pixel Poops Number Two (HB)\0", NULL, "Techmaster Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_pixelpoopsRomInfo, nes_pixelpoopsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ploid (HB)
static struct BurnRomInfo nes_ploidRomDesc[] = {
	{ "Ploid (2020)(NAPE Games).nes",          524304, 0xc7567823, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ploid)
STD_ROM_FN(nes_ploid)

struct BurnDriver BurnDrvnes_ploid = {
	"nes_ploid", NULL, NULL, NULL, "2020",
	"Ploid (HB)\0", NULL, "NAPE Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_ploidRomInfo, nes_ploidRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Plummet Challenge Game (HB)
static struct BurnRomInfo nes_plumchalRomDesc[] = {
	{ "Plummet Challenge Game (2021)(Fista Productions).nes",          524304, 0x7ec3675e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_plumchal)
STD_ROM_FN(nes_plumchal)

struct BurnDriver BurnDrvnes_plumchal = {
	"nes_plumchal", NULL, NULL, NULL, "2021",
	"Plummet Challenge Game (HB)\0", NULL, "Fista Productions", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_plumchalRomInfo, nes_plumchalRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Pogo Cats (HB)
static struct BurnRomInfo nes_pogocatsRomDesc[] = {
	{ "Pogo Cats (2012)(YGGI).nes",          24592, 0x57fc5391, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pogocats)
STD_ROM_FN(nes_pogocats)

struct BurnDriver BurnDrvnes_pogocats = {
	"nes_pogocats", NULL, NULL, NULL, "2012",
	"Pogo Cats (HB)\0", NULL, "YGGI", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_pogocatsRomInfo, nes_pogocatsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Porun-chan No Onigiri Daisuki (HB, v1.1)
static struct BurnRomInfo nes_porunchanRomDesc[] = {
	{ "Porun-chan no onigiri daisuki v1.1 (2019)(mook-tv).nes",          262160, 0xe15026cd, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_porunchan)
STD_ROM_FN(nes_porunchan)

struct BurnDriver BurnDrvnes_porunchan = {
	"nes_porunchan", NULL, NULL, NULL, "2019",
	"Porun-chan No Onigiri Daisuki (HB, v1.1)\0", NULL, "Mook-TV", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_porunchanRomInfo, nes_porunchanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Porun-chan no Onigiri Daisuki - Amabie (HB)
static struct BurnRomInfo nes_porunamabieRomDesc[] = {
	{ "Porun-chan no Onigiri Daisuki - Amabie (2020)(Mook-TV).nes",          262160, 0xc2c2e17a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_porunamabie)
STD_ROM_FN(nes_porunamabie)

struct BurnDriver BurnDrvnes_porunamabie = {
	"nes_porunamabie", NULL, NULL, NULL, "2020",
	"Porun-chan no Onigiri Daisuki - Amabie (HB)\0", NULL, "Mook-TV", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_porunamabieRomInfo, nes_porunamabieRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Project Blue (HB)
// Project Blue ROM @ https://toggleswitch.itch.io/projectblue
static struct BurnRomInfo nes_projectblueRomDesc[] = {
	{ "Project Blue (2019)(Toggle Switch).nes",          524304, 0x43b9e57e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_projectblue)
STD_ROM_FN(nes_projectblue)

struct BurnDriver BurnDrvnes_projectblue = {
	"nes_projectblue", NULL, NULL, NULL, "2019",
	"Project Blue (HB)\0", NULL, "Toggle Switch", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_projectblueRomInfo, nes_projectblueRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Purple Cape Man (HB)
static struct BurnRomInfo nes_purplecapemanRomDesc[] = {
	{ "Purple Cape Man (2015)(Vigilante Ninja).nes",          24592, 0xd8a7825b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_purplecapeman)
STD_ROM_FN(nes_purplecapeman)

struct BurnDriver BurnDrvnes_purplecapeman = {
	"nes_purplecapeman", NULL, NULL, NULL, "2015",
	"Purple Cape Man (HB)\0", NULL, "Vigilante Ninja", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_purplecapemanRomInfo, nes_purplecapemanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Pyramids of Ra (HB)
static struct BurnRomInfo nes_pyramidsraRomDesc[] = {
	{ "Pyramids of Ra (2019)(Piko Interactive).nes",          393232, 0x0bcee664, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pyramidsra)
STD_ROM_FN(nes_pyramidsra)

struct BurnDriver BurnDrvnes_pyramidsra = {
	"nes_pyramidsra", NULL, NULL, NULL, "2019",
	"Pyramids of Ra (HB)\0", NULL, "Piko Interactive", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_pyramidsraRomInfo, nes_pyramidsraRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Quadralords (HB)
static struct BurnRomInfo nes_quadralordsRomDesc[] = {
	{ "Quadralords (2016)(RetroUSB).nes",          524304, 0x88b407f7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_quadralords)
STD_ROM_FN(nes_quadralords)

struct BurnDriver BurnDrvnes_quadralords = {
	"nes_quadralords", NULL, NULL, NULL, "2016",
	"Quadralords (HB)\0", NULL, "retroUSB", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 4, HARDWARE_NES, GBF_ACTION | GBF_BREAKOUT, 0,
	NESGetZipName, nes_quadralordsRomInfo, nes_quadralordsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Quest Forge (HB)
static struct BurnRomInfo nes_questforgeRomDesc[] = {
	{ "Quest Forge (2016)(Ludosity).nes",          40976, 0xe81cba21, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_questforge)
STD_ROM_FN(nes_questforge)

struct BurnDriver BurnDrvnes_questforge = {
	"nes_questforge", NULL, NULL, NULL, "2016",
	"Quest Forge (HB)\0", NULL, "Ludosity", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_questforgeRomInfo, nes_questforgeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rainbow Brite - Journey to Rainbow Land (HB)
static struct BurnRomInfo nes_rainbriteRomDesc[] = {
	{ "Rainbow Brite - Journey to Rainbow Land (2017)(Hallmark).nes",          524304, 0x8902cf08, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rainbrite)
STD_ROM_FN(nes_rainbrite)

struct BurnDriver BurnDrvnes_rainbrite = {
	"nes_rainbrite", NULL, NULL, NULL, "2017",
	"Rainbow Brite - Journey to Rainbow Land (HB)\0", NULL, "Hallmark", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_rainbriteRomInfo, nes_rainbriteRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rainbow Catcher (HB)
static struct BurnRomInfo nes_rainbowcatcherRomDesc[] = {
	{ "Rainbow Catcher (2023)(Sleepy Bits Games).nes",          40976, 0x8dc5267e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rainbowcatcher)
STD_ROM_FN(nes_rainbowcatcher)

struct BurnDriver BurnDrvnes_rainbowcatcher = {
	"nes_rainbowcatcher", NULL, NULL, NULL, "2023",
	"Rainbow Catcher (HB)\0", NULL, "Sleepy Bits Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_rainbowcatcherRomInfo, nes_rainbowcatcherRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ralph 4 (HB)
static struct BurnRomInfo nes_ralph4RomDesc[] = {
	{ "Ralph 4 (2016)(Pubby).nes",          24592, 0xaf85d620, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ralph4)
STD_ROM_FN(nes_ralph4)

struct BurnDriver BurnDrvnes_ralph4 = {
	"nes_ralph4", NULL, NULL, NULL, "2016",
	"Ralph 4 (HB)\0", NULL, "Pubby", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_ralph4RomInfo, nes_ralph4RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ranma vs. Ranma! - Ranma-chan Edition (Hack, v2.2)
// https://www.romhacking.net/hacks/4290/
static struct BurnRomInfo nes_ranmachanRomDesc[] = {
	{ "Ranma vs. Ranma! v2.2 Ranma-chan Ed. (2023)(Crying Onion).nes",          40976, 0xcdfbe3f9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ranmachan)
STD_ROM_FN(nes_ranmachan)

struct BurnDriver BurnDrvnes_ranmachan = {
	"nes_ranmachan", "nes_kungfu", NULL, NULL, "2023",
	"Ranma vs. Ranma! - Ranma-chan Edition (Hack, v2.2)\0", NULL, "Crying Onion", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_ranmachanRomInfo, nes_ranmachanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ranma vs. Ranma! - Ranma-kun Edition (Hack, v2.2)
// https://www.romhacking.net/hacks/4290/
static struct BurnRomInfo nes_ranmakunRomDesc[] = {
	{ "Ranma vs. Ranma! v2.2 Ranma-kun Ed. (2023)(Crying Onion).nes",          40976, 0x1f3ad591, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ranmakun)
STD_ROM_FN(nes_ranmakun)

struct BurnDriver BurnDrvnes_ranmakun = {
	"nes_ranmakun", "nes_kungfu", NULL, NULL, "2023",
	"Ranma vs. Ranma! - Ranma-kun Edition (Hack, v2.2)\0", NULL, "Crying Onion", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_ranmakunRomInfo, nes_ranmakunRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rapid Cycling (HB)
static struct BurnRomInfo nes_rapidcyclingRomDesc[] = {
	{ "Rapid Cycling (2022)(Game Losers).nes",          524304, 0x4abb94f0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rapidcycling)
STD_ROM_FN(nes_rapidcycling)

struct BurnDriver BurnDrvnes_rapidcycling = {
	"nes_rapidcycling", NULL, NULL, NULL, "2022",
	"Rapid Cycling (HB)\0", NULL, "Game Losers", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_rapidcyclingRomInfo, nes_rapidcyclingRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Raven's Gate (HB)
static struct BurnRomInfo nes_ravensgateRomDesc[] = {
	{ "Ravens Gate (2022)(MercuryBD).nes",          65552, 0x3911f904, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ravensgate)
STD_ROM_FN(nes_ravensgate)

struct BurnDriver BurnDrvnes_ravensgate = {
	"nes_ravensgate", NULL, NULL, NULL, "2022",
	"Raven's Gate (HB)\0", NULL, "MercuryBD", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_ravensgateRomInfo, nes_ravensgateRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Raven's Gate (HB, MMC1 ver.)
static struct BurnRomInfo nes_ravensgatemmc1RomDesc[] = {
	{ "Raven's Gate mmc1 (2022)(MercuryBD).nes",          262160, 0xd2389326, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ravensgatemmc1)
STD_ROM_FN(nes_ravensgatemmc1)

struct BurnDriver BurnDrvnes_ravensgatemmc1 = {
	"nes_ravensgatemmc1", "nes_ravensgate", NULL, NULL, "2022",
	"Raven's Gate (HB, MMC1 ver.)\0", NULL, "MercuryBD", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_ravensgatemmc1RomInfo, nes_ravensgatemmc1RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Real Double Dragon (Hack)
// https://www.romhacking.net/hacks/8375/
static struct BurnRomInfo nes_realddragonRomDesc[] = {
	{ "Real Double Dragon (2024)(Corpse Grinder).nes",          262160, 0xc65d1a6e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_realddragon)
STD_ROM_FN(nes_realddragon)

struct BurnDriver BurnDrvnes_realddragon = {
	"nes_realddragon", "nes_doubledragon", NULL, NULL, "2024",
	"Real Double Dragon (Hack)\0", NULL, "Corpse Grinder", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_realddragonRomInfo, nes_realddragonRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Reknum - The Awakening (HB)
static struct BurnRomInfo nes_reknum1RomDesc[] = {
	{ "Reknum - The Awakening (2019)(NAPE Games).nes",          524304, 0xe2e0ea31, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_reknum1)
STD_ROM_FN(nes_reknum1)

struct BurnDriver BurnDrvnes_reknum1 = {
	"nes_reknum1", NULL, NULL, NULL, "2019",
	"Reknum - The Awakening (HB)\0", "No Sound", "NAPE Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_reknum1RomInfo, nes_reknum1RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Reknum - Souls Adventure (HB)
static struct BurnRomInfo nes_reknum2RomDesc[] = {
	{ "Reknum - Souls Adventure (2021)(NAPE Games).nes",          524304, 0xccdc9c66, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_reknum2)
STD_ROM_FN(nes_reknum2)

struct BurnDriver BurnDrvnes_reknum2 = {
	"nes_reknum2", NULL, NULL, NULL, "2021",
	"Reknum - Souls Adventure (HB)\0", NULL, "NAPE Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_reknum2RomInfo, nes_reknum2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Revolving Gems (HB)
static struct BurnRomInfo nes_revgemsRomDesc[] = {
	{ "Revolving Gems (2023)(Kyoske Maeda).nes",          65552, 0xa159af5a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_revgems)
STD_ROM_FN(nes_revgems)

struct BurnDriver BurnDrvnes_revgems = {
	"nes_revgems", NULL, NULL, NULL, "2023",
	"Revolving Gems (HB)\0", NULL, "Kyoske Maeda", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_revgemsRomInfo, nes_revgemsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rick Rolled! (HB, Tech-Demo)
static struct BurnRomInfo nes_rickrolledRomDesc[] = {
	{ "Rick Rolled! Tech-Demo (2009)(Frantik).nes",          262160, 0xc1be91f9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rickrolled)
STD_ROM_FN(nes_rickrolled)

struct BurnDriver BurnDrvnes_rickrolled = {
	"nes_rickrolled", NULL, NULL, NULL, "2009",
	"Rick Rolled! (HB, Tech-Demo)\0", NULL, "Frantik", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW | BDF_DEMO, 1, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_rickrolledRomInfo, nes_rickrolledRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rise of Amondus, The (HB) (Sly Dog Studios)
static struct BurnRomInfo nes_ramondusRomDesc[] = {
	{ "Rise of Amondus, The (2015)(Sly Dog Studios).nes",          131088, 0xc609eb0b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ramondus)
STD_ROM_FN(nes_ramondus)

struct BurnDriver BurnDrvnes_ramondus = {
	"nes_ramondus", NULL, NULL, NULL, "2015",
	"Rise of Amondus, The (HB) (Sly Dog Studios)\0", NULL, "Sly Dog Studios", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_ramondusRomInfo, nes_ramondusRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rise of Amondus, The (HB)
static struct BurnRomInfo nes_riseamoRomDesc[] = {
	{ "Rise of Amondus, The (2015)(Robert L. Bryant).nes",          131088, 0xb15ac0fe, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_riseamo)
STD_ROM_FN(nes_riseamo)

struct BurnDriver BurnDrvnes_riseamo = {
	"nes_riseamo", "nes_ramondus", NULL, NULL, "2015",
	"Rise of Amondus, The (HB)\0", NULL, "Robert L. Bryant", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_riseamoRomInfo, nes_riseamoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rockman 4 - Minus Infinity (Hack, v1.01)
// https://www.romhacking.net/hacks/910/
static struct BurnRomInfo nes_rockm4miRomDesc[] = {
	{ "Rockman 4 - Minus Infinity (Hack v1.01)(2016)(Puresabe).nes",          1048592, 0xe9887ba6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rockm4mi)
STD_ROM_FN(nes_rockm4mi)

struct BurnDriver BurnDrvnes_rockm4mi = {
	"nes_rockm4mi", "nes_megaman4", NULL, NULL, "2016",
	"Rockman 4 - Minus Infinity (Hack, v1.01)\0", NULL, "Puresabe", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_rockm4miRomInfo, nes_rockm4miRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rockman 5 - Metropolis (GlobalHack, v1.1a)
// https://www.romhacking.net/hacks/6082/
static struct BurnRomInfo nes_rockm5mpRomDesc[] = {
	{ "Rockman 5 - Metropolis v1.1a (2022)(StalkerMaestro).nes",          524304, 0xf4e22701, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rockm5mp)
STD_ROM_FN(nes_rockm5mp)

struct BurnDriver BurnDrvnes_rockm5mp = {
	"nes_rockm5mp", "nes_megaman5", NULL, NULL, "2021-22",
	"Rockman 5 - Metropolis (GlobalHack, v1.1a)\0", NULL, "StalkerMaestro", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_rockm5mpRomInfo, nes_rockm5mpRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rock Paper Scissors Lizard Sbock (HB, v0.9b)
static struct BurnRomInfo nes_roshamboRomDesc[] = {
	{ "Rock Paper Scissors Lizard Sbock v0.9b (2017)(Doug Fraker).nes",          24592, 0x8c17a094, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_roshambo)
STD_ROM_FN(nes_roshambo)

struct BurnDriver BurnDrvnes_roshambo = {
	"nes_roshambo", NULL, NULL, NULL, "2017",
	"Rock Paper Scissors Lizard Sbock (HB, v0.9b)\0", NULL, "Doug Fraker", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_roshamboRomInfo, nes_roshamboRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rollie (HB)
static struct BurnRomInfo nes_rollieRomDesc[] = {
	{ "Rollie (2019)(Optovania).nes",          40976, 0x8165c356, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rollie)
STD_ROM_FN(nes_rollie)

struct BurnDriver BurnDrvnes_rollie = {
	"nes_rollie", NULL, NULL, NULL, "2019",
	"Rollie (HB)\0", NULL, "Optovania", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_rollieRomInfo, nes_rollieRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Roniu's Tale (HB)
static struct BurnRomInfo nes_roniustaleRomDesc[] = {
	{ "Roniu's Tale (2022)(Mega Cat Studios).nes",          262160, 0xd1d75042, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_roniustale)
STD_ROM_FN(nes_roniustale)

struct BurnDriver BurnDrvnes_roniustale = {
	"nes_roniustale", NULL, NULL, NULL, "2022",
	"Roniu's Tale (HB)\0", NULL, "Mega Cat Studios", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_roniustaleRomInfo, nes_roniustaleRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Sam's Journey (HB)
static struct BurnRomInfo nes_samsjourneyRomDesc[] = {
	{ "Sam's Journey (2024)(Knights of Bytes).nes",          524304, 0xc00c4ea5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_samsjourney)
STD_ROM_FN(nes_samsjourney)

struct BurnDriver BurnDrvnes_samsjourney = {
	"nes_samsjourney", NULL, NULL, NULL, "2024",
	"Sam's Journey (HB)\0", NULL, "Knights of Bytes", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_samsjourneyRomInfo, nes_samsjourneyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Saturn Smash (HB)
static struct BurnRomInfo nes_saturnsmashRomDesc[] = {
	{ "Saturn Smash (2019)(FG Software).nes",          65552, 0xabc36edb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_saturnsmash)
STD_ROM_FN(nes_saturnsmash)

struct BurnDriver BurnDrvnes_saturnsmash = {
	"nes_saturnsmash", NULL, NULL, NULL, "2019",
	"Saturn Smash (HB)\0", NULL, "FG Software", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_saturnsmashRomInfo, nes_saturnsmashRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Scramble (HB)
static struct BurnRomInfo nes_scrambleRomDesc[] = {
	{ "Scramble (2017)(Khan Games).nes",          131088, 0xca6130a6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_scramble)
STD_ROM_FN(nes_scramble)

struct BurnDriver BurnDrvnes_scramble = {
	"nes_scramble", NULL, NULL, NULL, "2017",
	"Scramble (HB)\0", NULL, "Khan Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_scrambleRomInfo, nes_scrambleRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Senseless City (HB)
static struct BurnRomInfo nes_sensecityRomDesc[] = {
	{ "Senseless City (2022)(Rani Baker).nes",          40976, 0x70c92e3b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sensecity)
STD_ROM_FN(nes_sensecity)

struct BurnDriver BurnDrvnes_sensecity = {
	"nes_sensecity", NULL, NULL, NULL, "2022",
	"Senseless City (HB)\0", NULL, "Rani Baker", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_sensecityRomInfo, nes_sensecityRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Sgt. Helmet - Training Day (HB)
static struct BurnRomInfo nes_sgthelRomDesc[] = {
	{ "Sgt. Helmet - Training Day (2013)(The Mojon Twins).nes",          40976, 0x44c6ca4d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sgthel)
STD_ROM_FN(nes_sgthel)

struct BurnDriver BurnDrvnes_sgthel = {
	"nes_sgthel", NULL, NULL, NULL, "2013",
	"Sgt. Helmet - Training Day (HB)\0", NULL, "The Mojon Twins", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_sgthelRomInfo, nes_sgthelRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Shark! Shark! (HB)
static struct BurnRomInfo nes_sharksharkRomDesc[] = {
	{ "Shark! Shark! (2014).nes",          24592, 0x5f33e5b4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sharkshark)
STD_ROM_FN(nes_sharkshark)

struct BurnDriver BurnDrvnes_sharkshark = {
	"nes_sharkshark", NULL, NULL, NULL, "2014",
	"Shark! Shark! (HB)\0", "Original title developed for Intellivision in 1982", "<unknown>", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_sharksharkRomInfo, nes_sharksharkRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Shera & the 40 Thieves (HB)
static struct BurnRomInfo nes_sheraRomDesc[] = {
	{ "Shera & the 40 Thieves (2021)(CGT Games).nes",          524304, 0x40da8715, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_shera)
STD_ROM_FN(nes_shera)

struct BurnDriver BurnDrvnes_shera = {
	"nes_shera", NULL, NULL, NULL, "2021",
	"Shera & the 40 Thieves (HB)\0", NULL, "CGT Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_sheraRomInfo, nes_sheraRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Shoot UFO (GlobalHack)
static struct BurnRomInfo nes_shootufoRomDesc[] = {
	{ "Shoot UFO GlobalHack (2015).nes",          40976, 0xb5c91a2a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_shootufo)
STD_ROM_FN(nes_shootufo)

struct BurnDriver BurnDrvnes_shootufo = {
	"nes_shootufo", NULL, NULL, NULL, "2015",
	"Shoot UFO (GlobalHack)\0", "A GlobalHack of Duck Hunt", "<unknown>", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW | BDF_HACK, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_shootufoRomInfo, nes_shootufoRomName, NULL, NULL, NULL, NULL, NESZapperInputInfo, NESZapperDIPInfo,
	NESZapperInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Shovel Knight (GlobalHack)
// https://www.romhacking.net/hacks/7992/
static struct BurnRomInfo nes_shovelknightRomDesc[] = {
	{ "Shovel Knight GlobalHack (2023)(Roket).nes",          655376, 0x86e3c42d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_shovelknight)
STD_ROM_FN(nes_shovelknight)

struct BurnDriver BurnDrvnes_shovelknight = {
	"nes_shovelknight", NULL, NULL, NULL, "2023",
	"Shovel Knight (GlobalHack)\0", NULL, "Roket", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW | BDF_HACK, 1, HARDWARE_NES, GBF_ACTION | GBF_PLATFORM, 0,
	NESGetZipName, nes_shovelknightRomInfo, nes_shovelknightRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Sinking Feeling (HB)
static struct BurnRomInfo nes_sinkingfeelingRomDesc[] = {
	{ "Sinking Feeling (2017)(Mega Cat Studios).nes",          49168, 0xb2f79ee2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sinkingfeeling)
STD_ROM_FN(nes_sinkingfeeling)

struct BurnDriver BurnDrvnes_sinkingfeeling = {
	"nes_sinkingfeeling", NULL, NULL, NULL, "2017",
	"Sinking Feeling (HB)\0", NULL, "Mega Cat Studios", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_sinkingfeelingRomInfo, nes_sinkingfeelingRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Sir Ababol (HB)
static struct BurnRomInfo nes_sirababolRomDesc[] = {
	{ "Sir Ababol (2013)(The Mojon Twins).nes",          40976, 0x5e7e4c60, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sirababol)
STD_ROM_FN(nes_sirababol)

struct BurnDriver BurnDrvnes_sirababol = {
	"nes_sirababol", NULL, NULL, NULL, "2013",
	"Sir Ababol (HB)\0", NULL, "The Mojon Twins", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_sirababolRomInfo, nes_sirababolRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Sir Ababol Remastered Edition (HB)
static struct BurnRomInfo nes_sirababolrRomDesc[] = {
	{ "Sir Ababol Remastered Edition (2016)(The Mojon Twins).nes",          40976, 0x36d8ca2b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sirababolr)
STD_ROM_FN(nes_sirababolr)

struct BurnDriver BurnDrvnes_sirababolr = {
	"nes_sirababolr", "nes_sirababol", NULL, NULL, "2016",
	"Sir Ababol Remastered Edition (HB)\0", NULL, "The Mojon Twins", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_sirababolrRomInfo, nes_sirababolrRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// SkateCat (HB)
static struct BurnRomInfo nes_skatecatRomDesc[] = {
	{ "SkateCat (2023)(SJ Games).nes",          524304, 0x0a53ba24, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_skatecat)
STD_ROM_FN(nes_skatecat)

struct BurnDriver BurnDrvnes_skatecat = {
	"nes_skatecat", NULL, NULL, NULL, "2023",
	"SkateCat (HB)\0", NULL, "SJ Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_skatecatRomInfo, nes_skatecatRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Slow Mole (HB, v1.2b)
static struct BurnRomInfo nes_slowmoleRomDesc[] = {
	{ "Slow Mole v1.2b (2021)(Erik Rosenlund).nes",          524304, 0x61226e5f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_slowmole)
STD_ROM_FN(nes_slowmole)

struct BurnDriver BurnDrvnes_slowmole = {
	"nes_slowmole", NULL, NULL, NULL, "2021",
	"Slow Mole (HB, v1.2b)\0", NULL, "Erik Rosenlund", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_slowmoleRomInfo, nes_slowmoleRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Snail Hop (HB)
static struct BurnRomInfo nes_snailhopRomDesc[] = {
	{ "Snail Hop (2023)(Libra Bits).nes",          163856, 0xba16a036, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_snailhop)
STD_ROM_FN(nes_snailhop)

struct BurnDriver BurnDrvnes_snailhop = {
	"nes_snailhop", NULL, NULL, NULL, "2023",
	"Snail Hop (HB)\0", NULL, "Libra Bits", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_snailhopRomInfo, nes_snailhopRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Snakky (HB)
static struct BurnRomInfo nes_snakkyRomDesc[] = {
	{ "Snakky (2016)(Shiru).nes",          40976, 0xc1b8427e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_snakky)
STD_ROM_FN(nes_snakky)

struct BurnDriver BurnDrvnes_snakky = {
	"nes_snakky", NULL, NULL, NULL, "2016",
	"Snakky (HB)\0", NULL, "Shiru", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_snakkyRomInfo, nes_snakkyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Soko Banana (HB)
static struct BurnRomInfo nes_sokobananaRomDesc[] = {
	{ "Soko Banana (2023)(Flip For Fate).nes",          524304, 0xa3973b4b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sokobanana)
STD_ROM_FN(nes_sokobanana)

struct BurnDriver BurnDrvnes_sokobanana = {
	"nes_sokobanana", NULL, NULL, NULL, "2023",
	"Soko Banana (HB)\0", NULL, "Flip For Fate", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_sokobananaRomInfo, nes_sokobananaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Solstice - Return to the Kastlerock (Hack, v1.0 hotfix1)
// https://www.romhacking.net/hacks/8541/
static struct BurnRomInfo nes_solstrttkRomDesc[] = {
	{ "Solstice - Return to the Kastlerock v1.0 hotfix1 (2024)(Jp32).nes",          131088, 0x0c054e39, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_solstrttk)
STD_ROM_FN(nes_solstrttk)

struct BurnDriver BurnDrvnes_solstrttk = {
	"nes_solstrttk", "nes_solst", NULL, NULL, "2024",
	"Solstice - Return to the Kastlerock (Hack, v1.0 hotfix1)\0", NULL, "Jp32", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PUZZLE | GBF_PLATFORM, 0,
	NESGetZipName, nes_solstrttkRomInfo, nes_solstrttkRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Space Cat (HB)
static struct BurnRomInfo nes_spacecatRomDesc[] = {
	{ "Space Cat (2023).nes",          524304, 0x809a6b97, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_spacecat)
STD_ROM_FN(nes_spacecat)

struct BurnDriver BurnDrvnes_spacecat = {
	"nes_spacecat", NULL, NULL, NULL, "2023",
	"Space Cat (HB)\0", NULL, "<unknown>", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_spacecatRomInfo, nes_spacecatRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Spacegulls (HB, v1.1)
static struct BurnRomInfo nes_spacegullsRomDesc[] = {
	{ "Spacegulls (2021)(Morphcat Games).nes",          65552, 0x539f87d4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_spacegulls)
STD_ROM_FN(nes_spacegulls)

struct BurnDriver BurnDrvnes_spacegulls = {
	"nes_spacegulls", NULL, NULL, NULL, "2021",
	"Spacegulls (HB, v1.1)\0", NULL, "Morphcat Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_spacegullsRomInfo, nes_spacegullsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Space Mutants - DG BGM (HB)
static struct BurnRomInfo nes_spacemutdgRomDesc[] = {
	{ "Space Mutants DG (2023)(T-Bone).nes",          524304, 0x3f73e619, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_spacemutdg)
STD_ROM_FN(nes_spacemutdg)

struct BurnDriver BurnDrvnes_spacemutdg = {
	"nes_spacemutdg", NULL, NULL, NULL, "2023",
	"Space Mutants - DG BGM (HB)\0", NULL, "T-Bone Studios", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_spacemutdgRomInfo, nes_spacemutdgRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Space Mutants - JK BGM (HB)
static struct BurnRomInfo nes_spacemutjkRomDesc[] = {
	{ "Space Mutants JK (2023)(T-Bone).nes",          524304, 0xd202f6b6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_spacemutjk)
STD_ROM_FN(nes_spacemutjk)

struct BurnDriver BurnDrvnes_spacemutjk = {
	"nes_spacemutjk", "nes_spacemutdg", NULL, NULL, "2023",
	"Space Mutants - JK BGM (HB)\0", NULL, "T-Bone Studios", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_spacemutjkRomInfo, nes_spacemutjkRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Space Mutants - Extendo UnCut Edition (HB)
static struct BurnRomInfo nes_spacemuteueRomDesc[] = {
	{ "Space Mutants Extendo UnCut Edition (2023)(T-Bone Studios).nes",          524304, 0x1520e4b6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_spacemuteue)
STD_ROM_FN(nes_spacemuteue)

struct BurnDriver BurnDrvnes_spacemuteue = {
	"nes_spacemuteue", NULL, NULL, NULL, "2023",
	"Space Mutants - Extendo UnCut Edition (HB)\0", NULL, "T-Bone Studios", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_spacemuteueRomInfo, nes_spacemuteueRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Space Raft (HB)
static struct BurnRomInfo nes_spaceraftRomDesc[] = {
	{ "Space Raft (2020)(Raftronaut).nes",          524304, 0x03841119, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_spaceraft)
STD_ROM_FN(nes_spaceraft)

struct BurnDriver BurnDrvnes_spaceraft = {
	"nes_spaceraft", NULL, NULL, NULL, "2020",
	"Space Raft (HB)\0", NULL, "Raftronaut", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_spaceraftRomInfo, nes_spaceraftRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Spirit Impel (HB)
static struct BurnRomInfo nes_spiritimpelRomDesc[] = {
	{ "Spirit Impel (2020)(Passe Gaming).nes",          524304, 0x146f8f6c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_spiritimpel)
STD_ROM_FN(nes_spiritimpel)

struct BurnDriver BurnDrvnes_spiritimpel = {
	"nes_spiritimpel", NULL, NULL, NULL, "2020",
	"Spirit Impel (HB)\0", NULL, "Passe Gaming", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_spiritimpelRomInfo, nes_spiritimpelRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// SplatooD (HB, v1.0.6)
static struct BurnRomInfo nes_splatoodRomDesc[] = {
	{ "SplatooD v1.0.6 (2016)(John Carmackerel).nes",          40976, 0x93d17b02, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_splatood)
STD_ROM_FN(nes_splatood)

struct BurnDriver BurnDrvnes_splatood = {
	"nes_splatood", NULL, NULL, NULL, "2016",
	"SplatooD (HB, v1.0.6)\0", NULL, "John Carmackerel", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_ACTION | GBF_MAZE, 0,
	NESGetZipName, nes_splatoodRomInfo, nes_splatoodRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Split Second (HB)
static struct BurnRomInfo nes_splitsecondRomDesc[] = {
	{ "Split Second (2019)(Skadiet).nes",          24592, 0xa26a6c89, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_splitsecond)
STD_ROM_FN(nes_splitsecond)

struct BurnDriver BurnDrvnes_splitsecond = {
	"nes_splitsecond", NULL, NULL, NULL, "2019",
	"Split Second (HB)\0", NULL, "Skadiet", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_splitsecondRomInfo, nes_splitsecondRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Spooky Soccer (HB, Prototype)
static struct BurnRomInfo nes_spookysoccerRomDesc[] = {
	{ "Spooky Soccer (Proto)(2022)(Dullahan Software).nes",          40976, 0xfd22b3f3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_spookysoccer)
STD_ROM_FN(nes_spookysoccer)

struct BurnDriver BurnDrvnes_spookysoccer = {
	"nes_spookysoccer", NULL, NULL, NULL, "2022",
	"Spooky Soccer (HB, Prototype)\0", NULL, "Dullahan Software", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW | BDF_PROTOTYPE, 2, HARDWARE_NES, GBF_ACTION | GBF_SPORTSFOOTBALL, 0,
	NESGetZipName, nes_spookysoccerRomInfo, nes_spookysoccerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Squirrel Chaser (HB)
static struct BurnRomInfo nes_squirchaserRomDesc[] = {
	{ "Squirrel Chaser (2022)(Brad Hammond).nes",          524304, 0x3a48f1bd, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_squirchaser)
STD_ROM_FN(nes_squirchaser)

struct BurnDriver BurnDrvnes_squirchaser = {
	"nes_squirchaser", NULL, NULL, NULL, "2022",
	"Squirrel Chaser (HB)\0", NULL, "Brad Hammond", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_squirchaserRomInfo, nes_squirchaserRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Squirrel Domino (HB)
static struct BurnRomInfo nes_squirdominoRomDesc[] = {
	{ "Squirrel Domino (2024)(NovaSquirrel).nes",          24592, 0x08d49a13, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_squirdomino)
STD_ROM_FN(nes_squirdomino)

struct BurnDriver BurnDrvnes_squirdomino = {
	"nes_squirdomino", NULL, NULL, NULL, "2024",
	"Squirrel Domino (HB)\0", NULL, "NovaSquirrel", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_squirdominoRomInfo, nes_squirdominoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Star Evil (HB)
static struct BurnRomInfo nes_starevilRomDesc[] = {
	{ "Star Evil (2018)(PDRoms).nes",          40976, 0xfbd4ce1c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_starevil)
STD_ROM_FN(nes_starevil)

struct BurnDriver BurnDrvnes_starevil = {
	"nes_starevil", NULL, NULL, NULL, "2018",
	"Star Evil (HB)\0", NULL, "PDRoms", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_starevilRomInfo, nes_starevilRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Starlight Mario (Hack)
// https://www.romhacking.net/hacks/5245/
static struct BurnRomInfo nes_starlightmarioRomDesc[] = {
	{ "Starlight Mario (2020)(TPWC Hacks).nes",          40976, 0x7b64b618, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_starlightmario)
STD_ROM_FN(nes_starlightmario)

struct BurnDriver BurnDrvnes_starlightmario = {
	"nes_starlightmario", "nes_smb", NULL, NULL, "2020",
	"Starlight Mario (Hack)\0", NULL, "TPWC Hacks", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_starlightmarioRomInfo, nes_starlightmarioRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Starlight Mario Underworld (Hack)
// https://www.romhacking.net/hacks/7253/
static struct BurnRomInfo nes_starlightmariouRomDesc[] = {
	{ "Starlight Mario Underworld (2022)(TPWC Hacks).nes",          65552, 0xa7a313b5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_starlightmariou)
STD_ROM_FN(nes_starlightmariou)

struct BurnDriver BurnDrvnes_starlightmariou = {
	"nes_starlightmariou", "nes_smb", NULL, NULL, "2022",
	"Starlight Mario Underworld (Hack)\0", NULL, "TPWC Hacks", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_starlightmariouRomInfo, nes_starlightmariouRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Star Versus (HB)
static struct BurnRomInfo nes_starversusRomDesc[] = {
	{ "Star Versus (2015)(Dustmop).nes",          196624, 0x33e83fa5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_starversus)
STD_ROM_FN(nes_starversus)

struct BurnDriver BurnDrvnes_starversus = {
	"nes_starversus", NULL, NULL, NULL, "2015",
	"Star Versus (HB)\0", NULL, "Dustmop", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_starversusRomInfo, nes_starversusRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Steel Moons (HB)
static struct BurnRomInfo nes_steelmoonsRomDesc[] = {
	{ "Steel Moons (2022)(Mazionach).nes",          65552, 0x3dc97b51, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_steelmoons)
STD_ROM_FN(nes_steelmoons)

struct BurnDriver BurnDrvnes_steelmoons = {
	"nes_steelmoons", NULL, NULL, NULL, "2022",
	"Steel Moons (HB)\0", NULL, "Mazionach", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_steelmoonsRomInfo, nes_steelmoonsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Steins Gate (HB)
static struct BurnRomInfo nes_steinsgateRomDesc[] = {
	{ "Steins Gate (2018)(Chiyomaru Studio).nes",          786448, 0x547c4f1d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_steinsgate)
STD_ROM_FN(nes_steinsgate)

struct BurnDriver BurnDrvnes_steinsgate = {
	"nes_steinsgate", NULL, NULL, NULL, "2018",
	"Steins Gate (HB)\0", NULL, "Chiyomaru Studio", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_steinsgateRomInfo, nes_steinsgateRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// STING (HB)
static struct BurnRomInfo nes_stingRomDesc[] = {
	{ "STING (2008)(smkdan).nes",          40976, 0xf0c8191b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sting)
STD_ROM_FN(nes_sting)

struct BurnDriver BurnDrvnes_sting = {
	"nes_sting", NULL, NULL, NULL, "2008",
	"STING (HB)\0", NULL, "smkdan", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_stingRomInfo, nes_stingRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Sudoku 23 (HB)
static struct BurnRomInfo nes_sudoku23RomDesc[] = {
	{ "Sudoku 23 (2023)(Johnybot).nes",          40976, 0x914d683d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sudoku23)
STD_ROM_FN(nes_sudoku23)

struct BurnDriver BurnDrvnes_sudoku23 = {
	"nes_sudoku23", NULL, NULL, NULL, "2023",
	"Sudoku 23 (HB)\0", NULL, "Johnybot", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_sudoku23RomInfo, nes_sudoku23RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Homebrew War (HB)
static struct BurnRomInfo nes_superhomwarRomDesc[] = {
	{ "Super Homebrew War (2019)(gauauu).nes",          65552, 0x16b8d50a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_superhomwar)
STD_ROM_FN(nes_superhomwar)

struct BurnDriver BurnDrvnes_superhomwar = {
	"nes_superhomwar", NULL, NULL, NULL, "2019",
	"Super Homebrew War (HB)\0", NULL, "gauauu", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 4, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_superhomwarRomInfo, nes_superhomwarRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Mario Bros 8 (GlobalHack, English)
static struct BurnRomInfo nes_smb8enRomDesc[] = {
	{ "Super Mario Bros 8 hack eng (2021)(Crying Onion).nes",          393232, 0x1f5d9f05, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_smb8en)
STD_ROM_FN(nes_smb8en)

struct BurnDriver BurnDrvnes_smb8en = {
	"nes_smb8en", NULL, NULL, NULL, "2021",
	"Super Mario Bros 8 (GlobalHack, English)\0", NULL, "Crying Onion", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_smb8enRomInfo, nes_smb8enRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Mario Bros 8 (GlobalHack, Spanish)
static struct BurnRomInfo nes_smb8esRomDesc[] = {
	{ "Super Mario Bros 8 hack spa (2021)(Crying Onion).nes",          393232, 0xef9c0a4f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_smb8es)
STD_ROM_FN(nes_smb8es)

struct BurnDriver BurnDrvnes_smb8es = {
	"nes_smb8es", "nes_smb8en", NULL, NULL, "2021",
	"Super Mario Bros 8 (GlobalHack, Spanish)\0", NULL, "Crying Onion", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_smb8esRomInfo, nes_smb8esRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Mario Bros 8 Special Edition (GlobalHack, English)
static struct BurnRomInfo nes_smb8seRomDesc[] = {
	{ "Super Mario Bros 8 SE hack (2021)(Crying Onion).nes",          393232, 0xaa5822c0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_smb8se)
STD_ROM_FN(nes_smb8se)

struct BurnDriver BurnDrvnes_smb8se = {
	"nes_smb8se", "nes_smb8en", NULL, NULL, "2021",
	"Super Mario Bros 8 Special Edition (GlobalHack, English)\0", "Don Doko Don 2 tribute edition", "Crying Onion", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_smb8seRomInfo, nes_smb8seRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Mario Bro-Op (Hack, v1.1)
// https://www.romhacking.net/hacks/7615/
static struct BurnRomInfo nes_smbroopRomDesc[] = {
	{ "Super Mario Bro-Op v1.1 (2023)(NesDraug).nes",          73744, 0x1ce829ca, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_smbroop)
STD_ROM_FN(nes_smbroop)

struct BurnDriver BurnDrvnes_smbroop = {
	"nes_smbroop", "nes_smb", NULL, NULL, "2023",
	"Super Mario Bro-Op (Hack, v1.1)\0", NULL, "NesDraug", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_smbroopRomInfo, nes_smbroopRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Mario Bros. DX - Anniversary Edition (Hack, v4.5)
// https://www.romhacking.net/hacks/144/
static struct BurnRomInfo nes_smbdxRomDesc[] = {
	{ "Super Mario Bros. DX - Anniversary Edition v4.5 (2023)(flamepanther).nes",          40976, 0x01fa70ec, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_smbdx)
STD_ROM_FN(nes_smbdx)

struct BurnDriver BurnDrvnes_smbdx = {
	"nes_smbdx", "nes_smb", NULL, NULL, "2023",
	"Super Mario Bros. DX - Anniversary Edition (Hack, v4.5)\0", NULL, "flamephanter", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_smbdxRomInfo, nes_smbdxRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Mario Unlimited Deluxe (GlobalHack, v2.4)
// https://www.romhacking.net/hacks/5546/
static struct BurnRomInfo nes_smunlimdxRomDesc[] = {
	{ "Super Mario Unlimited Deluxe v2.4 (2021)(Frantik).nes",          196624, 0xe4198a92, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_smunlimdx)
STD_ROM_FN(nes_smunlimdx)

struct BurnDriver BurnDrvnes_smunlimdx = {
	"nes_smunlimdx", NULL, NULL, NULL, "2021",
	"Super Mario Unlimited Deluxe (GlobalHack, v2.4)\0", NULL, "Frantik", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_smunlimdxRomInfo, nes_smunlimdxRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super NeSnake 2 (HB)
static struct BurnRomInfo nes_snesnake2RomDesc[] = {
	{ "Super NeSnake 2 (2008)(RetroUSB).nes",          131088, 0xa8d9d559, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_snesnake2)
STD_ROM_FN(nes_snesnake2)

struct BurnDriver BurnDrvnes_snesnake2 = {
	"nes_snesnake2", NULL, NULL, NULL, "2008",
	"Super NeSnake 2 (HB)\0", NULL, "retroUSB", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_snesnake2RomInfo, nes_snesnake2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Painter (HB)
static struct BurnRomInfo nes_superpainterRomDesc[] = {
	{ "Super Painter (2015)(RetroSouls).nes",          40976, 0x5d483272, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_superpainter)
STD_ROM_FN(nes_superpainter)

struct BurnDriver BurnDrvnes_superpainter = {
	"nes_superpainter", NULL, NULL, NULL, "2015",
	"Super Painter (HB)\0", NULL, "RetroSouls", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_superpainterRomInfo, nes_superpainterRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Pitfall 30th Anniversary Edition (HB)
static struct BurnRomInfo nes_superpit30tRomDesc[] = {
	{ "Super Pitfall 30th AE (2016)(NESRocks).nes",          131088, 0xe55ba70d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_superpit30t)
STD_ROM_FN(nes_superpit30t)

struct BurnDriver BurnDrvnes_superpit30t = {
	"nes_superpit30t", NULL, NULL, NULL, "2016",
	"Super Pitfall 30th Anniversary Edition (HB)\0", NULL, "NESRocks", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_superpit30tRomInfo, nes_superpit30tRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Russian Roulette (HB)
static struct BurnRomInfo nes_superrusrouRomDesc[] = {
	{ "Super Russian Roulette (2017)(Andrew Reitano).nes",          8912912, 0xdde4cf55, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_superrusrou)
STD_ROM_FN(nes_superrusrou)

struct BurnDriver BurnDrvnes_superrusrou = {
	"nes_srroulette", NULL, NULL, NULL, "2017",
	"Super Russian Roulette (HB)\0", NULL, "Andrew Reitano", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 3, HARDWARE_NES, GBF_MISC | GBF_SHOOT, 0,
	NESGetZipName, nes_superrusrouRomInfo, nes_superrusrouRomName, NULL, NULL, NULL, NULL, NESZapperInputInfo, NESZapperDIPInfo,
	NESZapperInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Tetris Land - GB skin (Hack)
// https://www.romhacking.net/hacks/7583/
static struct BurnRomInfo nes_stetrislandRomDesc[] = {
	{ "Super Tetris Land - GB edition (2022)(CAndiman).nes",          163856, 0x4aaca4c2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_stetrisland)
STD_ROM_FN(nes_stetrisland)

struct BurnDriver BurnDrvnes_stetrisland = {
	"nes_stetrisland", "nes_tetris", NULL, NULL, "2022",
	"Super Tetris Land - GB skin (Hack)\0", NULL, "CAndiman", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_stetrislandRomInfo, nes_stetrislandRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Tilt Bro. (HB, v2 RC3)
static struct BurnRomInfo nes_supertiltbrorc3RomDesc[] = {
	{ "Super Tilt Bro. v2 RC3 (2023)(Broke Studio).nes",          524304, 0x5802cf20, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_supertiltbrorc3)
STD_ROM_FN(nes_supertiltbrorc3)

struct BurnDriver BurnDrvnes_supertiltbrorc3 = {
	"nes_supertiltbrorc3", NULL, NULL, NULL, "2023",
	"Super Tilt Bro. (HB, v2 RC3)\0", NULL, "Broke Studio", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_supertiltbrorc3RomInfo, nes_supertiltbrorc3RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Tilt Bro. (HB, v2 alpha1)
static struct BurnRomInfo nes_supertiltbroRomDesc[] = {
	{ "Super Tilt Bro v2 alpha1 (2018)(Broke Studio).nes",          524304, 0x58829008, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_supertiltbro)
STD_ROM_FN(nes_supertiltbro)

struct BurnDriver BurnDrvnes_supertiltbro = {
	"nes_supertiltbro", "nes_supertiltbrorc3", NULL, NULL, "2018",
	"Super Tilt Bro. (HB, v2 alpha1)\0", NULL, "Broke Studio", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_supertiltbroRomInfo, nes_supertiltbroRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super UWOL (HB)
static struct BurnRomInfo nes_superuwolRomDesc[] = {
	{ "Super UWOL (2015)(The Mojon Twins).nes",          40976, 0x9fbb9e1d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_superuwol)
STD_ROM_FN(nes_superuwol)

struct BurnDriver BurnDrvnes_superuwol = {
	"nes_superuwol", NULL, NULL, NULL, "2015",
	"Super UWOL (HB)\0", NULL, "The Mojon Twins", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_superuwolRomInfo, nes_superuwolRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Swords and Runes (HB)
static struct BurnRomInfo nes_snrRomDesc[] = {
	{ "Swords and Runes (2014)(Sole Goose Productions).nes",          524304, 0x6f596f4b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_snr)
STD_ROM_FN(nes_snr)

struct BurnDriver BurnDrvnes_snr = {
	"nes_snr", NULL, NULL, NULL, "2014",
	"Swords and Runes (HB)\0", NULL, "Sole Goose Productions", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_RPG | GBF_STRATEGY, 0,
	NESGetZipName, nes_snrRomInfo, nes_snrRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Swords and Runes Limited Edition (HB)
static struct BurnRomInfo nes_snrleRomDesc[] = {
	{ "Swords and Runes LE (2014)(Sole Goose Productions).nes",          24592, 0xea0b4a06, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_snrle)
STD_ROM_FN(nes_snrle)

struct BurnDriver BurnDrvnes_snrle = {
	"nes_snrle", "nes_snr", NULL, NULL, "2014",
	"Swords and Runes Limited Edition (HB)\0", NULL, "Sole Goose Productions", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_RPG | GBF_STRATEGY, 0,
	NESGetZipName, nes_snrleRomInfo, nes_snrleRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Swords and Runes III (HB)
static struct BurnRomInfo nes_snr3RomDesc[] = {
	{ "Swords and Runes III (2020)(Sole Goose Productions).nes",          524304, 0x5738826e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_snr3)
STD_ROM_FN(nes_snr3)

struct BurnDriver BurnDrvnes_snr3 = {
	"nes_snr3", NULL, NULL, NULL, "2020",
	"Swords and Runes III (HB)\0", NULL, "Sole Goose Productions", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_RPG | GBF_STRATEGY, 0,
	NESGetZipName, nes_snr3RomInfo, nes_snr3RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tactus (HB, Prototype)
static struct BurnRomInfo nes_tactusRomDesc[] = {
	{ "Tactus Prototype (2022)(zeta0134).nes",          65552, 0x51876b54, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tactus)
STD_ROM_FN(nes_tactus)

struct BurnDriver BurnDrvnes_tactus = {
	"nes_tactus", NULL, NULL, NULL, "2022",
	"Tactus (HB, Prototype)\0", NULL, "zeta134", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW | BDF_PROTOTYPE, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_tactusRomInfo, nes_tactusRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tapeworm Disco Puzzle (HB, v05)
static struct BurnRomInfo nes_tapewormRomDesc[] = {
	{ "Tapeworm Disco Puzzle v05 (2022)(Lowtek Games).nes",          524304, 0x3cf42935, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tapeworm)
STD_ROM_FN(nes_tapeworm)

struct BurnDriver BurnDrvnes_tapeworm = {
	"nes_tapeworm", NULL, NULL, NULL, "2021-22",
	"Tapeworm Disco Puzzle (HB, v05)\0", NULL, "Lowtek Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_tapewormRomInfo, nes_tapewormRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tapeworm Disco Puzzle (HB, Demo)
static struct BurnRomInfo nes_tapewormdRomDesc[] = {
	{ "Tapeworm Disco Puzzle (HB)(Demo).nes",          65552, 0x30e0689f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tapewormd)
STD_ROM_FN(nes_tapewormd)

struct BurnDriver BurnDrvnes_tapewormd = {
	"nes_tapewormd", "nes_tapeworm", NULL, NULL, "2020",
	"Tapeworm Disco Puzzle (HB, Demo)\0", NULL, "Lowtek Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_tapewormdRomInfo, nes_tapewormdRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tecmo Super Bowl 2020 (Hack, v3.0)
static struct BurnRomInfo nes_tsb20v3RomDesc[] = {
	{ "Tecmo Super Bowl 2020 v3.0 (2021)(SBlueman).nes",          524304, 0x24de7ae7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tsb20v3)
STD_ROM_FN(nes_tsb20v3)

struct BurnDriver BurnDrvnes_tsb20v3 = {
	"nes_tsb20v3", "nes_tecmosuperbowl", NULL, NULL, "2021",
	"Tecmo Super Bowl 2020 (Hack, v3.0)\0", NULL, "SBlueman", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_tsb20v3RomInfo, nes_tsb20v3RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tecmo Super Bowl 2021 Final Edition (Hack)
static struct BurnRomInfo nes_tsb21feRomDesc[] = {
	{ "Tecmo Super Bowl 2021 Final Edition (2022)(SBlueman).nes",          524304, 0x0557f756, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tsb21fe)
STD_ROM_FN(nes_tsb21fe)

struct BurnDriver BurnDrvnes_tsb21fe = {
	"nes_tsb21fe", "nes_tecmosuperbowl", NULL, NULL, "2022",
	"Tecmo Super Bowl 2021 Final Edition (Hack)\0", NULL, "SBlueman", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_tsb21feRomInfo, nes_tsb21feRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tecmo Super Bowl 2022 NCAA D.1 Edition (Hack)
static struct BurnRomInfo nes_tsb22ncaaRomDesc[] = {
	{ "Tecmo Super Bowl - 2022 NCAA D.1 Ed. (2022)(SBlueman).nes",          524304, 0x54133719, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tsb22ncaa)
STD_ROM_FN(nes_tsb22ncaa)

struct BurnDriver BurnDrvnes_tsb22ncaa = {
	"nes_tsb22ncaa", "nes_tecmosuperbowl", NULL, NULL, "2022",
	"Tecmo Super Bowl 2022 NCAA D.1 Edition (Hack)\0", NULL, "SBlueman", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_tsb22ncaaRomInfo, nes_tsb22ncaaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tecmo Super Bowl Tapmeter (Hack)
static struct BurnRomInfo nes_tsbtapmeterRomDesc[] = {
	{ "Tecmo Super Bowl Tapmeter v1.0.0 (2016)(Bruddog).nes",          393232, 0x18f884f0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tsbtapmeter)
STD_ROM_FN(nes_tsbtapmeter)

struct BurnDriver BurnDrvnes_tsbtapmeter = {
	"nes_tsbtapmeter", "nes_tecmosuperbowl", NULL, NULL, "2016",
	"Tecmo Super Bowl Tapmeter (Hack)\0", NULL, "Bruddog", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_tsbtapmeterRomInfo, nes_tsbtapmeterRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Temple Dilemma (HB)
static struct BurnRomInfo nes_tdilemmaRomDesc[] = {
	{ "Temple Dilemma (2019)(Oldschool Interactive).nes",          524304, 0x5e2a4eeb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tdilemma)
STD_ROM_FN(nes_tdilemma)

struct BurnDriver BurnDrvnes_tdilemma = {
	"nes_tdilemma", NULL, NULL, NULL, "2019",
	"Temple Dilemma (HB)\0", NULL, "Oldschool Interactive", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_tdilemmaRomInfo, nes_tdilemmaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tenebra (HB)
static struct BurnRomInfo nes_tenebraRomDesc[] = {
	{ "Tenebra (2023)(Haplo).nes",          40976, 0x213d756f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tenebra)
STD_ROM_FN(nes_tenebra)

struct BurnDriver BurnDrvnes_tenebra = {
	"nes_tenebra", NULL, NULL, NULL, "2023",
	"Tenebra (HB)\0", NULL, "Haplo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_MAZE, 0,
	NESGetZipName, nes_tenebraRomInfo, nes_tenebraRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tenebra 2 (HB)
static struct BurnRomInfo nes_tenebra2RomDesc[] = {
	{ "Tenebra 2 (2024)(Haplo).nes",          40976, 0xff47fb01, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tenebra2)
STD_ROM_FN(nes_tenebra2)

struct BurnDriver BurnDrvnes_tenebra2 = {
	"nes_tenebra2", NULL, NULL, NULL, "2024",
	"Tenebra 2 (HB)\0", NULL, "Haplo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_MAZE, 0,
	NESGetZipName, nes_tenebra2RomInfo, nes_tenebra2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tense Conds (HB)
static struct BurnRomInfo nes_tensecondsRomDesc[] = {
	{ "Tense Conds (2022)(Wendel Scardua).nes",          65552, 0x3e385cb0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tenseconds)
STD_ROM_FN(nes_tenseconds)

struct BurnDriver BurnDrvnes_tenseconds = {
	"nes_tenseconds", NULL, NULL, NULL, "2022",
	"Tense Conds (HB)\0", NULL, "Wendel Scardua", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_MAZE | GBF_ACTION, 0,
	NESGetZipName, nes_tensecondsRomInfo, nes_tensecondsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tesla vs Edison (HB)
static struct BurnRomInfo nes_teslavsedisonRomDesc[] = {
	{ "Tesla vs Edison (2018)(Radtek).nes",          40976, 0x7d646297, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_teslavsedison)
STD_ROM_FN(nes_teslavsedison)

struct BurnDriver BurnDrvnes_teslavsedison = {
	"nes_teslavsedison", NULL, NULL, NULL, "2018",
	"Tesla vs Edison (HB)\0", NULL, "Radnek", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_ACTION | GBF_BALLPADDLE, 0,
	NESGetZipName, nes_teslavsedisonRomInfo, nes_teslavsedisonRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// They Came To Wreak Hell (HB, v0.3a)
static struct BurnRomInfo nes_tctwhRomDesc[] = {
	{ "They Came To Wreak Hell v0.3a (2022)(Team Disposable).nes",          65552, 0x83c4b5a3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tctwh)
STD_ROM_FN(nes_tctwh)

struct BurnDriver BurnDrvnes_tctwh = {
	"nes_tctwh", NULL, NULL, NULL, "2022",
	"They Came To Wreak Hell (HB, v0.3a)\0", NULL, "Team Disposable", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_RUNGUN | GBF_MAZE, 0,
	NESGetZipName, nes_tctwhRomInfo, nes_tctwhRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Thief and the Cobbler (GlobalHack, v1.5)
// https://www.romhacking.net/hacks/6839/
static struct BurnRomInfo nes_thiefcobRomDesc[] = {
	{ "Thief and the Cobbler v1.5 (GlobalHack)(2022)(Garrett Gilchrist).nes",          262160, 0xbb8339c0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_thiefcob)
STD_ROM_FN(nes_thiefcob)

struct BurnDriver BurnDrvnes_thiefcob = {
	"nes_thiefcob", "nes_smb2", NULL, NULL, "2022",
	"Thief and the Cobbler (GlobalHack, v1.5)\0", NULL, "Garrett Gilchrist", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_thiefcobRomInfo, nes_thiefcobRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tina's Adventure Island (Hack)
static struct BurnRomInfo nes_tinasadvislRomDesc[] = {
	{ "Tina's Adventure Island (2019)(Zynk Oxhyde).nes",          65552, 0x6663d1aa, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tinasadvisl)
STD_ROM_FN(nes_tinasadvisl)

struct BurnDriver BurnDrvnes_tinasadvisl = {
	"nes_tinasadvisl", "nes_adventureisland", NULL, NULL, "2019",
	"Tina's Adventure Island (Hack)\0", NULL, "Zynk Oxhyde", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_tinasadvislRomInfo, nes_tinasadvislRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tina's Adventure Island II (Hack)
static struct BurnRomInfo nes_tinasadvisliiRomDesc[] = {
	{ "Tina's Adventure Island II (2019)(Zynk Oxhyde).nes",          262160, 0x28b36ecc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tinasadvislii)
STD_ROM_FN(nes_tinasadvislii)

struct BurnDriver BurnDrvnes_tinasadvislii = {
	"nes_tinasadvislii", "nes_advenislii", NULL, NULL, "2019",
	"Tina's Adventure Island II (Hack)\0", NULL, "Zynk Oxhyde", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_tinasadvisliiRomInfo, nes_tinasadvisliiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tina's Advanture Island III (Hack)
static struct BurnRomInfo nes_tinasadvisliiiRomDesc[] = {
	{ "Tina's Advanture Island III (2019)(Zynk Oxhyde).nes",          262160, 0x774a6c79, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tinasadvisliii)
STD_ROM_FN(nes_tinasadvisliii)

struct BurnDriver BurnDrvnes_tinasadvisliii = {
	"nes_tinasadvisliii", "nes_advenisl3", NULL, NULL, "2019",
	"Tina's Advanture Island III (Hack)\0", NULL, "Zynk Oxhyde", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_tinasadvisliiiRomInfo, nes_tinasadvisliiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tola (HB)
static struct BurnRomInfo nes_tolaRomDesc[] = {
	{ "Tola (2022)(OmniRetro Games).nes",          40976, 0x315309f6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tola)
STD_ROM_FN(nes_tola)

struct BurnDriver BurnDrvnes_tola = {
	"nes_tola", NULL, NULL, NULL, "2022",
	"Tola (HB)\0", NULL, "OmniRetro Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_tolaRomInfo, nes_tolaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tomb of Ice (HB)
static struct BurnRomInfo nes_tombiceRomDesc[] = {
	{ "Tomb of Ice (2020)(FG Software).nes",          40976, 0x426d3439, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tombice)
STD_ROM_FN(nes_tombice)

struct BurnDriver BurnDrvnes_tombice = {
	"nes_tombice", NULL, NULL, NULL, "2020",
	"Tomb of Ice (HB)\0", "No sound", "FG Software", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_tombiceRomInfo, nes_tombiceRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tortoises (HB)
static struct BurnRomInfo nes_tortoisesRomDesc[] = {
	{ "Tortoises (2017)(FG Software).nes",          65552, 0x05f4f4e2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tortoises)
STD_ROM_FN(nes_tortoises)

struct BurnDriver BurnDrvnes_tortoises = {
	"nes_tortoises", NULL, NULL, NULL, "2017",
	"Tortoises (HB)\0", NULL, "FG Software", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION | GBF_MAZE, 0,
	NESGetZipName, nes_tortoisesRomInfo, nes_tortoisesRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Totoro - Mei is Missing (GlobalHack)
// https://www.romhacking.net/hacks/8370/
static struct BurnRomInfo nes_totoroRomDesc[] = {
	{ "Totoro - Mei is Missing GlobalHack (2024)(Cakewarder).nes",          40976, 0x44f5c8be, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_totoro)
STD_ROM_FN(nes_totoro)

struct BurnDriver BurnDrvnes_totoro = {
	"nes_totoro", NULL, NULL, NULL, "2024",
	"Totoro - Mei is Missing (GlobalHack)\0", NULL, "Cakewarder", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_totoroRomInfo, nes_totoroRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Touhou Rououmu - Perfect Cherry Blossom (HB, v1.00 beta 2)
static struct BurnRomInfo nes_touhourououmuRomDesc[] = {
	{ "Touhou Rououmu v1.00 beta 2 (2023)(Kyoske Maeda).nes",          524304, 0x8208a5c3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_touhourououmu)
STD_ROM_FN(nes_touhourououmu)

struct BurnDriver BurnDrvnes_touhourououmu = {
	"nes_touhourououmu", NULL, NULL, NULL, "2023",
	"Touhou Rououmu - Perfect Cherry Blossom (HB, v1.00 beta 2)\0", NULL, "Kyoske Maeda", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_touhourououmuRomInfo, nes_touhourououmuRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tower Defense 1990 (HB)
static struct BurnRomInfo nes_td1990RomDesc[] = {
	{ "Tower Defense 1990 (2018)(Ryan Lloyd).nes",          131088, 0x403af207, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_td1990)
STD_ROM_FN(nes_td1990)

struct BurnDriver BurnDrvnes_td1990 = {
	"nes_td1990", NULL, NULL, NULL, "2018",
	"Tower Defense 1990 (HB)\0", NULL, "Ryan Lloyd", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_td1990RomInfo, nes_td1990RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tower of Turmoil (HB, v1.03)
static struct BurnRomInfo nes_towerofturmoilRomDesc[] = {
	{ "Tower of Turmoil (HB, v1.03).nes",          524304, 0x89cbd840, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_towerofturmoil)
STD_ROM_FN(nes_towerofturmoil)

struct BurnDriver BurnDrvnes_towerofturmoil = {
	"nes_towerofturmoil", NULL, NULL, NULL, "2019",
	"Tower of Turmoil (HB, v1.03)\0", NULL, "CutterCross", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_towerofturmoilRomInfo, nes_towerofturmoilRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Trophy (HB)
static struct BurnRomInfo nes_trophyRomDesc[] = {
	{ "Trophy (2020)(the 6502 collective).nes",          786448, 0x94c16bfc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_trophy)
STD_ROM_FN(nes_trophy)

struct BurnDriver BurnDrvnes_trophy = {
	"nes_trophy", NULL, NULL, NULL, "2020",
	"Trophy (HB)\0", NULL, "the 6502 collective", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_trophyRomInfo, nes_trophyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Trouble in 2a03 (HB)
static struct BurnRomInfo nes_trouble2a03RomDesc[] = {
	{ "Trouble in 2a03 (2021)(Team Disposable).nes",          65552, 0x5559e594, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_trouble2a03)
STD_ROM_FN(nes_trouble2a03)

struct BurnDriver BurnDrvnes_trouble2a03 = {
	"nes_trouble2a03", NULL, NULL, NULL, "2021",
	"Trouble in 2a03 (HB)\0", NULL, "Team Disposable", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_RUNGUN | GBF_MAZE, 0,
	NESGetZipName, nes_trouble2a03RomInfo, nes_trouble2a03RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Twin Dragons (HB)
static struct BurnRomInfo nes_twindragonsRomDesc[] = {
	{ "Twin Dragons (2018)(Broke Studio).nes",          524304, 0x0d29351e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_twindragons)
STD_ROM_FN(nes_twindragons)

struct BurnDriver BurnDrvnes_twindragons = {
	"nes_twindragons", NULL, NULL, NULL, "2018",
	"Twin Dragons (HB)\0", NULL, "Broke Studio", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_twindragonsRomInfo, nes_twindragonsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Twin Dragons Compo Edition (HB)
static struct BurnRomInfo nes_twindracomediRomDesc[] = {
	{ "Twin Dragons Compo Edition (2016)(Broke Studio).nes",          65552, 0x311cb660, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_twindracomedi)
STD_ROM_FN(nes_twindracomedi)

struct BurnDriver BurnDrvnes_twindracomedi = {
	"nes_twindracomedi", "nes_twindragons", NULL, NULL, "2016",
	"Twin Dragons Compo Edition (HB)\0", NULL, "Broke Studio", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_twindracomediRomInfo, nes_twindracomediRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Uchusen - Ultimate PLOID Battle (HB)
static struct BurnRomInfo nes_uchusenRomDesc[] = {
	{ "Uchusen - Ultimate PLOID Battle (2021)(Nape Games).nes",          524304, 0x3ec46930, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_uchusen)
STD_ROM_FN(nes_uchusen)

struct BurnDriver BurnDrvnes_uchusen = {
	"nes_uchusen", NULL, NULL, NULL, "2021",
	"Uchusen - Ultimate PLOID Battle (HB)\0", NULL, "NAPE Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_uchusenRomInfo, nes_uchusenRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Uchusen 2 - Blood Invasion Battle (HB)
static struct BurnRomInfo nes_uchusen2RomDesc[] = {
	{ "Uchusen 2 - Blood Invasion Battle (2021)(Nape Games).nes",          524304, 0xa9623021, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_uchusen2)
STD_ROM_FN(nes_uchusen2)

struct BurnDriver BurnDrvnes_uchusen2 = {
	"nes_uchusen2", NULL, NULL, NULL, "2021",
	"Uchusen 2 - Blood Invasion Battle (HB)\0", NULL, "NAPE Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_uchusen2RomInfo, nes_uchusen2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Upsad Down (HB, v0.6)
static struct BurnRomInfo nes_upsadownRomDesc[] = {
	{ "Upsad Down v0.6 (2021)(Fadest).nes",          40976, 0xf90302bc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_upsadown)
STD_ROM_FN(nes_upsadown)

struct BurnDriver BurnDrvnes_upsadown = {
	"nes_upsadown", NULL, NULL, NULL, "2020",
	"Upsad Down (HB, v0.6)\0", "NesDev Competition build", "Fadest", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_upsadownRomInfo, nes_upsadownRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// UXO - Unexploded Ordnance (HB)
static struct BurnRomInfo nes_uxoRomDesc[] = {
	{ "UXO - Unexploded Ordnance (2016)(FG Software).nes",          40976, 0x32ab3a14, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_uxo)
STD_ROM_FN(nes_uxo)

struct BurnDriver BurnDrvnes_uxo = {
	"nes_uxo", NULL, NULL, NULL, "2016",
	"UXO - Unexploded Ordnance (HB)\0", NULL, "FG Software", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_uxoRomInfo, nes_uxoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Valis++ (Hack, English v1.1)
// https://www.romhacking.net/hacks/248/
static struct BurnRomInfo nes_valisppRomDesc[] = {
	{ "Valis++ T-Eng v1.1 (2021)(Sliver X).nes",          131088, 0x77275641, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_valispp)
STD_ROM_FN(nes_valispp)

struct BurnDriver BurnDrvnes_valispp = {
	"nes_valispp", "nes_valis", NULL, NULL, "2021",
	"Valis++ (Hack, English v1.1)\0", NULL, "Sliver X", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_valisppRomInfo, nes_valisppRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Veggie Invaders (HB)
static struct BurnRomInfo nes_veggieinvadersRomDesc[] = {
	{ "Veggie Invaders (2019)(dustmop).nes",          65552, 0x6276c0a0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_veggieinvaders)
STD_ROM_FN(nes_veggieinvaders)

struct BurnDriver BurnDrvnes_veggieinvaders = {
	"nes_veggieinvaders", NULL, NULL, NULL, "2019",
	"Veggie Invaders (HB)\0", NULL, "dustmop", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_veggieinvadersRomInfo, nes_veggieinvadersRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Virus Cleaner (HB)
static struct BurnRomInfo nes_nesvircleRomDesc[] = {
	{ "NES Virus Cleaner (2016)(Second Dimension).nes",          40976, 0x5f17cb98, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_nesvircle)
STD_ROM_FN(nes_nesvircle)

struct BurnDriver BurnDrvnes_nesvircle = {
	"nes_nesvircle", NULL, NULL, NULL, "2011-2016",
	"Virus Cleaner (HB)\0", NULL, "Second Dimension - Sly Dog Studios", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_nesvircleRomInfo, nes_nesvircleRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wacko (HB)
static struct BurnRomInfo nes_wackoRomDesc[] = {
	{ "Wacko (2022).nes",          524304, 0xa806e746, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_wacko)
STD_ROM_FN(nes_wacko)

struct BurnDriver BurnDrvnes_wacko = {
	"nes_wacko", NULL, NULL, NULL, "2022",
	"Wacko (HB)\0", NULL, "<unknown>", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_wackoRomInfo, nes_wackoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Waddles the Duck (HB)
static struct BurnRomInfo nes_waddlesRomDesc[] = {
	{ "Waddles the Duck (2017)(CP Programs).nes",          65552, 0xe6b45c0e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_waddles)
STD_ROM_FN(nes_waddles)

struct BurnDriver BurnDrvnes_waddles = {
	"nes_waddles", NULL, NULL, NULL, "2017",
	"Waddles the Duck (HB)\0", NULL, "CP Programs", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_waddlesRomInfo, nes_waddlesRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Waldos Forever (HB)
static struct BurnRomInfo nes_waldos4everRomDesc[] = {
	{ "Waldos Forever (2021)(Dispensary 33).nes",          524304, 0x94c04ac4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_waldos4ever)
STD_ROM_FN(nes_waldos4ever)

struct BurnDriver BurnDrvnes_waldos4ever = {
	"nes_waldos4ever", NULL, NULL, NULL, "2021",
	"Waldos Forever (HB)\0", NULL, "Dispensary 33", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_waldos4everRomInfo, nes_waldos4everRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wampus (HB)
static struct BurnRomInfo nes_wampusRomDesc[] = {
	{ "Wampus (2019)(John Vanderhoef).nes",          524304, 0xf67d26a2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_wampus)
STD_ROM_FN(nes_wampus)

struct BurnDriver BurnDrvnes_wampus = {
	"nes_wampus", "nes_wampusdx", NULL, NULL, "2019",
	"Wampus (HB)\0", NULL, "John Vanderhoef", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_wampusRomInfo, nes_wampusRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wampus DX (HB)
static struct BurnRomInfo nes_wampusdxRomDesc[] = {
	{ "Wampus DX (2020)(John Vanderhoef).nes",          524304, 0x690f19e0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_wampusdx)
STD_ROM_FN(nes_wampusdx)

struct BurnDriver BurnDrvnes_wampusdx = {
	"nes_wampusdx", NULL, NULL, NULL, "2020",
	"Wampus DX (HB)\0", NULL, "John Vanderhoef", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_wampusdxRomInfo, nes_wampusdxRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wart Worm Wingding (HB)
static struct BurnRomInfo nes_wartwormRomDesc[] = {
	{ "Wart Worm Wingding (2020)(John Vanderhoef).nes",          524304, 0x8b9d8827, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_wartworm)
STD_ROM_FN(nes_wartworm)

struct BurnDriver BurnDrvnes_wartworm = {
	"nes_wartworm", NULL, NULL, NULL, "2020",
	"Wart Worm Wingding (HB)\0", NULL, "John Vanderhoef", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_ACTION | GBF_PLATFORM, 0,
	NESGetZipName, nes_wartwormRomInfo, nes_wartwormRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Weed N' Stiff 2 Bobsons Revenge (HB)
static struct BurnRomInfo nes_weedstiff2RomDesc[] = {
	{ "Weed N' Stiff 2 Bobsons Revenge (2021)(CalGames).nes",          524304, 0x8fd50f91, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_weedstiff2)
STD_ROM_FN(nes_weedstiff2)

struct BurnDriver BurnDrvnes_weedstiff2 = {
	"nes_weedstiff2", NULL, NULL, NULL, "2021",
	"Weed N' Stiff 2 Bobsons Revenge (HB)\0", NULL, "CalGames", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_ADV, 0,
	NESGetZipName, nes_weedstiff2RomInfo, nes_weedstiff2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// What Remains (HB, v1.0.2)
static struct BurnRomInfo nes_whatremainsRomDesc[] = {
	{ "What Remains (HB).nes",          524304, 0x2f2d03e5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_whatremains)
STD_ROM_FN(nes_whatremains)

struct BurnDriver BurnDrvnes_whatremains = {
	"nes_whatremains", NULL, NULL, NULL, "2019-20",
	"What Remains (HB, v1.0.2)\0", NULL, "Iodine Dynamics", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_whatremainsRomInfo, nes_whatremainsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Witch n' Wiz (HB)
static struct BurnRomInfo nes_witchnwizRomDesc[] = {
	{ "Witch n' Wiz (2021)(mhughson).nes",          262160, 0x4ac76d3f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_witchnwiz)
STD_ROM_FN(nes_witchnwiz)

struct BurnDriver BurnDrvnes_witchnwiz = {
	"nes_witchnwiz", NULL, NULL, NULL, "2021",
	"Witch n' Wiz (HB)\0", NULL, "Matt Hughson", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE | GBF_ADV, 0,
	NESGetZipName, nes_witchnwizRomInfo, nes_witchnwizRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Witch n' Wiz (HB, NESDev Ed.)
static struct BurnRomInfo nes_witchnwizndRomDesc[] = {
	{ "Witch n' Wiz (2020-21)(NESDev Ed.).nes",          65552, 0xbddd6cba, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_witchnwiznd)
STD_ROM_FN(nes_witchnwiznd)

struct BurnDriver BurnDrvnes_witchnwiznd = {
	"nes_witchnwiznd", "nes_witchnwiz", NULL, NULL, "2020-21",
	"Witch n' Wiz (HB, NESDev Ed.)\0", NULL, "Matt Hughson", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_witchnwizndRomInfo, nes_witchnwizndRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wolfling (HB, v1.4)
static struct BurnRomInfo nes_wolflingRomDesc[] = {
	{ "Wolfling (HB, v1.4).nes",          65552, 0xf22ae9b8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_wolfling)
STD_ROM_FN(nes_wolfling)

struct BurnDriver BurnDrvnes_wolfling = {
	"nes_wolfling", NULL, NULL, NULL, "2018",
	"Wolfling (HB, v1.4)\0", NULL, "Lazy Cow", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_wolflingRomInfo, nes_wolflingRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wolf Spirit (HB, Demo)
static struct BurnRomInfo nes_wolfspiritRomDesc[] = {
	{ "Wolf Spirit (HB)(2021)(Valdir Salgueiro).nes",          65552, 0x74574809, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_wolfspirit)
STD_ROM_FN(nes_wolfspirit)

struct BurnDriver BurnDrvnes_wolfspirit = {
	"nes_wolfspirit", NULL, NULL, NULL, "2021",
	"Wolf Spirit (HB, Demo)\0", NULL, "Valdir Salgueiro", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_wolfspiritRomInfo, nes_wolfspiritRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wordle (HB, v1.1)
static struct BurnRomInfo nes_wordleRomDesc[] = {
	{ "Wordle v1.1 (2022)(FG Software).nes",          65552, 0x604ff03b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_wordle)
STD_ROM_FN(nes_wordle)

struct BurnDriver BurnDrvnes_wordle = {
	"nes_wordle", NULL, NULL, NULL, "2022",
	"Wordle (HB, v1.1)\0", NULL, "FG Software", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_wordleRomInfo, nes_wordleRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wo Xiang Niao Niao (HB)
static struct BurnRomInfo nes_wxniaoRomDesc[] = {
	{ "Wo Xiang Niao Niao (2016)(Xin Xin).nes",          40976, 0x7063779c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_wxniao)
STD_ROM_FN(nes_wxniao)

struct BurnDriver BurnDrvnes_wxniao = {
	"nes_wxniao", NULL, NULL, NULL, "2016",
	"Wo Xiang Niao Niao (HB)\0", NULL, "Xin Xin", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_wxniaoRomInfo, nes_wxniaoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Yeah Yeah Beebiss II (HB)
// https://store.steampowered.com/app/1871700/Yeah_Yeah_Beebiss_II/
static struct BurnRomInfo nes_yybeebissiiRomDesc[] = {
	{ "Yeah Yeah Beebiss II (2022)(Rigg'd Games).nes",          65552, 0x4a8eed90, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_yybeebissii)
STD_ROM_FN(nes_yybeebissii)

struct BurnDriver BurnDrvnesnes_yybeebissii = {
	"nes_yybeebissii", NULL, NULL, NULL, "2022",
	"Yeah Yeah Beebiss II (HB)\0", NULL, "Rigg'd Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PLATFORM | GBF_ACTION, 0,
	NESGetZipName, nes_yybeebissiiRomInfo, nes_yybeebissiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Yun R5 (HB)
static struct BurnRomInfo nes_yunr5RomDesc[] = {
	{ "Yun R5 (2018)(The Mojon Twins).nes",          65552, 0x04940713, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_yunr5)
STD_ROM_FN(nes_yunr5)

struct BurnDriver BurnDrvnes_yunr5 = {
	"nes_yunr5", NULL, NULL, NULL, "2018",
	"Yun R5 (HB)\0", NULL, "The Mojon Twins", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_yunr5RomInfo, nes_yunr5RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Za! Yukigassen (HB, v1.02)
static struct BurnRomInfo nes_zayukiRomDesc[] = {
	{ "Za! Yukigassen v1.02 (2021)(Takenoko Games).nes",          40976, 0xfb8ca245, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_zayuki)
STD_ROM_FN(nes_zayuki)

struct BurnDriver BurnDrvnes_zayuki = {
	"nes_zayuki", NULL, NULL, NULL, "2021",
	"Za! Yukigassen (HB, v1.02)\0", NULL, "Takenoko Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_zayukiRomInfo, nes_zayukiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Zelda II Amida's Curse (GlobalHack, v1.9)
// https://www.romhacking.net/hacks/6292/
static struct BurnRomInfo nes_zeldaiiacRomDesc[] = {
	{ "Zelda II Amida's Curse GlobHack v1.9 (2021)(Ok Impala!).nes",          262160, 0xf01a5b55, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_zeldaiiac)
STD_ROM_FN(nes_zeldaiiac)

struct BurnDriver BurnDrvnes_zeldaiiac = {
	"nes_zeldaiiac", "nes_zeldaii", NULL, NULL, "2023",
	"Zelda II Amida's Curse (GlobalHack, v1.9)\0", NULL, "Ok Impala!", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW | BDF_CLONE | BDF_HOMEBREW | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_zeldaiiacRomInfo, nes_zeldaiiacRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Zelda Kong (GlobalHack)
// https://www.romhacking.net/hacks/6015/
static struct BurnRomInfo nes_zeldakongRomDesc[] = {
	{ "Zelda Kong (2021)(Zero Meaning).nes",          24592, 0x4c801a11, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_zeldakong)
STD_ROM_FN(nes_zeldakong)

struct BurnDriver BurnDrvnes_zeldakong = {
	"nes_zeldakong", "nes_donkeykong", NULL, NULL, "2021",
	"Zelda Kong (GlobalHack)\0", NULL, "Zero Meaning", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HOMEBREW | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_zeldakongRomInfo, nes_zeldakongRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Zdey the Game (HB)
static struct BurnRomInfo nes_zdeyRomDesc[] = {
	{ "Zdey the Game (2020)(Art'Cade).nes",          524304, 0xfd4036e1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_zdey)
STD_ROM_FN(nes_zdey)

struct BurnDriver BurnDrvnes_zdey = {
	"nes_zdey", NULL, NULL, NULL, "2020",
	"Zdey the Game (HB)\0", NULL, "Art'Cade", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_zdeyRomInfo, nes_zdeyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Zombie Calavera (HB)
static struct BurnRomInfo nes_zombiecalaveraRomDesc[] = {
	{ "Zombie Calavera (2016)(The Mojon Twins).nes",          40976, 0x23ec3047, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_zombiecalavera)
STD_ROM_FN(nes_zombiecalavera)

struct BurnDriver BurnDrvnes_zombiecalavera = {
	"nes_zombiecalavera", NULL, NULL, NULL, "2016",
	"Zombie Calavera (HB)\0", NULL, "The Mojon Twins", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_zombiecalaveraRomInfo, nes_zombiecalaveraRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Zombiehunter Bob (HB)
static struct BurnRomInfo nes_zombhuntbobRomDesc[] = {
	{ "Zombiehunter Bob (2022)(board-b).nes",          524304, 0x00927241, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_zombhuntbob)
STD_ROM_FN(nes_zombhuntbob)

struct BurnDriver BurnDrvnes_zombhuntbob = {
	"nes_zombhuntbob", NULL, NULL, NULL, "2022",
	"Zombiehunter Bob (HB)\0", NULL, "board-b", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_zombhuntbobRomInfo, nes_zombhuntbobRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Zooming Secretary (HB)
static struct BurnRomInfo nes_zoomisecRomDesc[] = {
	{ "Zooming Secretary (2021)(Pinwizz & Shiru).nes",          40976, 0x947972d0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_zoomisec)
STD_ROM_FN(nes_zoomisec)

struct BurnDriver BurnDrvnes_zoomisec = {
	"nes_zoomisec", NULL, NULL, NULL, "2011",
	"Zooming Secretary (HB)\0", NULL, "Pinwizz & Shiru", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_zoomisecRomInfo, nes_zoomisecRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_badappleRomDesc[] = {
	{ "bad_apple (2015 v2.5)(Little Limit).nes",          786448, 0xf96a5a8b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_badapple)
STD_ROM_FN(nes_badapple)

struct BurnDriver BurnDrvnes_badapple = {
	"nes_badapple", NULL, NULL, NULL, "2015",
	"Bad Apple (HB, Tech-Demo)\0", NULL, "Little Limit", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW | BDF_DEMO, 1, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_badappleRomInfo, nes_badappleRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_underadvRomDesc[] = {
	{ "Underground Adventure (2019)(Dale Coop).nes",          524304, 0xeaf67029, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_underadv)
STD_ROM_FN(nes_underadv)

struct BurnDriver BurnDrvnes_underadv = {
	"nes_underadv", NULL, NULL, NULL, "2019",
	"Underground Adventure (HB)\0", NULL, "Dale Coop", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_underadvRomInfo, nes_underadvRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_ultimfrochaRomDesc[] = {
	{ "Ultimate Frogger Champion (HB).nes",          49168, 0xab862073, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ultimfrocha)
STD_ROM_FN(nes_ultimfrocha)

struct BurnDriver BurnDrvnes_ultimfrocha = {
	"nes_ultimfrocha", NULL, NULL, NULL, "2019",
	"Ultimate Frogger Champion (HB)\0", NULL, "Khan Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_ultimfrochaRomInfo, nes_ultimfrochaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_jamgRomDesc[] = {
	{ "JAMG - The Lost Coins (HB).nes",          262160, 0x7a8877aa, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jamg)
STD_ROM_FN(nes_jamg)

struct BurnDriver BurnDrvnes_jamg = {
	"nes_jamg", NULL, NULL, NULL, "2018",
	"JAMG - The Lost Coins (HB)\0", NULL, "OCDreproductions", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_jamgRomInfo, nes_jamgRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_cmc80sdemoRomDesc[] = {
	{ "CMC 80's Demo (HB).nes",          49168, 0x0135b0e8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cmc80sdemo)
STD_ROM_FN(nes_cmc80sdemo)

struct BurnDriver BurnDrvnes_cmc80sdemo = {
	"nes_cmc80sdemo", NULL, NULL, NULL, "2000",
	"CMC 80's Demo (HB, Tech-Demo)\0", NULL, "Chris Covell", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW | BDF_DEMO, 1, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_cmc80sdemoRomInfo, nes_cmc80sdemoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_wallRomDesc[] = {
	{ "wall (Demo).nes",          24592, 0x5da28b4f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_wall)
STD_ROM_FN(nes_wall)

struct BurnDriver BurnDrvnes_wall = {
	"nes_wall", NULL, NULL, NULL, "1999",
	"Wall (HB, Tech-Demo)\0", NULL, "Chris Covell", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW | BDF_DEMO, 1, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_wallRomInfo, nes_wallRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x200,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};


static struct BurnRomInfo nes_actio53vol1stbuRomDesc[] = {
	{ "Action 53 vol 1 Streemerz Bundle (HB).nes",          524304, 0x54fc4fae, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_actio53vol1stbu)
STD_ROM_FN(nes_actio53vol1stbu)

struct BurnDriver BurnDrvnes_actio53vol1stbu = {
	"nes_actio53vol1stbu", NULL, NULL, NULL, "2013",
	"Action 53 vol 1 Streemerz Bundle (HB)\0", NULL, "Damian Yerrick & Contributors", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_actio53vol1stbuRomInfo, nes_actio53vol1stbuRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_actio53vol2doacRomDesc[] = {
	{ "Action 53 vol 2 Double Action (HB).nes",          524304, 0x4e9c9174, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_actio53vol2doac)
STD_ROM_FN(nes_actio53vol2doac)

struct BurnDriver BurnDrvnes_actio53vol2doac = {
	"nes_actio53vol2doac", NULL, NULL, NULL, "2015",
	"Action 53 vol 2 Double Action (HB)\0", NULL, "Damian Yerrick & Contributors", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_actio53vol2doacRomInfo, nes_actio53vol2doacRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_actio53vol3retwRomDesc[] = {
	{ "Action 53 vol 3 Revenge of the Twins (HB).nes",          1048592, 0x0dc9110b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_actio53vol3retw)
STD_ROM_FN(nes_actio53vol3retw)

struct BurnDriver BurnDrvnes_actio53vol3retw = {
	"nes_actio53vol3retw", NULL, NULL, NULL, "2018",
	"Action 53 vol 3 Revenge of the Twins (HB)\0", NULL, "Damian Yerrick & Contributors", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_actio53vol3retwRomInfo, nes_actio53vol3retwRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_expeditionRomDesc[] = {
	{ "Expedition (HB).nes",          393232, 0x1b83916d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_expedition)
STD_ROM_FN(nes_expedition)

struct BurnDriver BurnDrvnes_expedition = {
	"nes_expedition", NULL, NULL, NULL, "2017",
	"Expedition (HB)\0", NULL, "Mega Cat Studios", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_expeditionRomInfo, nes_expeditionRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_familypicrossRomDesc[] = {
	{ "Family Picross! (HB).nes",          40976, 0xbd459402, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_familypicross)
STD_ROM_FN(nes_familypicross)

struct BurnDriver BurnDrvnes_familypicross = {
	"nes_familypicross", NULL, NULL, NULL, "2018",
	"Family Picross! (HB)\0", NULL, "FG Software", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_familypicrossRomInfo, nes_familypicrossRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_kirakirstanigacRomDesc[] = {
	{ "Kira Kira Star Night AC (HB).nes",          524304, 0x9e650f69, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kirakirstanigac)
STD_ROM_FN(nes_kirakirstanigac)

struct BurnDriver BurnDrvnes_kirakirstanigac = {
	"nes_kirakirstanigac", NULL, NULL, NULL, "2017",
	"Kira Kira Star Night AC (HB)\0", NULL, "RiKi", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_kirakirstanigacRomInfo, nes_kirakirstanigacRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_kirakirstanigdxRomDesc[] = {
	{ "Kira Kira Star Night DX (HB).nes",          524304, 0x66a30110, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kirakirstanigdx)
STD_ROM_FN(nes_kirakirstanigdx)

struct BurnDriver BurnDrvnes_kirakirstanigdx = {
	"nes_kirakirstanigdx", NULL, NULL, NULL, "2016",
	"Kira Kira Star Night DX (HB)\0", NULL, "RiKi", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_kirakirstanigdxRomInfo, nes_kirakirstanigdxRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_kirakirstaniggoRomDesc[] = {
	{ "Kira Kira Star Night GOLD (HB).nes",          524304, 0xd2526d60, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kirakirstaniggo)
STD_ROM_FN(nes_kirakirstaniggo)

struct BurnDriver BurnDrvnes_kirakirstaniggo = {
	"nes_kirakirstaniggo", NULL, NULL, NULL, "2016",
	"Kira Kira Star Night GOLD (HB)\0", NULL, "RiKi", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_kirakirstaniggoRomInfo, nes_kirakirstaniggoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_nomolosRomDesc[] = {
	{ "Nomolos (HB).nes",          524304, 0x917154ac, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_nomolos)
STD_ROM_FN(nes_nomolos)

struct BurnDriver BurnDrvnes_nomolos = {
	"nes_nomolos", NULL, NULL, NULL, "2014",
	"Nomolos (HB)\0", NULL, "Gradual Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_nomolosRomInfo, nes_nomolosRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_panicdizzyRomDesc[] = {
	{ "Panic Dizzy (HB).nes",          65552, 0xc5b23abd, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_panicdizzy)
STD_ROM_FN(nes_panicdizzy)

struct BurnDriver BurnDrvnes_panicdizzy = {
	"nes_panicdizzy", NULL, NULL, NULL, "2019",
	"Panic Dizzy (HB)\0", NULL, "Oliver Twins", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_panicdizzyRomInfo, nes_panicdizzyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_wonderlanddizzyRomDesc[] = {
	{ "Wonderland Dizzy (HB).nes",          262160, 0x62c97c6c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_wonderlanddizzy)
STD_ROM_FN(nes_wonderlanddizzy)

struct BurnDriver BurnDrvnes_wonderlanddizzy = {
	"nes_wonderlanddizzy", NULL, NULL, NULL, "2015",
	"Wonderland Dizzy (HB)\0", NULL, "Oliver Twins", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_wonderlanddizzyRomInfo, nes_wonderlanddizzyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_mystewordizRomDesc[] = {
	{ "Mystery World Dizzy (HB).nes",          262160, 0x03124bf3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mystewordiz)
STD_ROM_FN(nes_mystewordiz)

struct BurnDriver BurnDrvnes_mystewordiz = {
	"nes_mystewordiz", NULL, NULL, NULL, "2017",
	"Mystery World Dizzy (HB)\0", NULL, "Oliver Twins", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_mystewordizRomInfo, nes_mystewordizRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_superbatpunRomDesc[] = {
	{ "Super Bat Puncher (Demo).nes",          131088, 0xd04302fa, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_superbatpun)
STD_ROM_FN(nes_superbatpun)

struct BurnDriver BurnDrvnes_superbatpun = {
	"nes_superbatpun", NULL, NULL, NULL, "2011",
	"Super Bat Puncher (HB, Demo)\0", NULL, "Morphcat Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_superbatpunRomInfo, nes_superbatpunRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_legendsofowliaRomDesc[] = {
	{ "Legends of Owlia (HB).nes",          524304, 0x26858010, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_legendsofowlia)
STD_ROM_FN(nes_legendsofowlia)

struct BurnDriver BurnDrvnes_legendsofowlia = {
	"nes_legendsofowlia", NULL, NULL, NULL, "2014",
	"Legends of Owlia (HB)\0", NULL, "Gradual Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_legendsofowliaRomInfo, nes_legendsofowliaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_mojontwimulRomDesc[] = {
	{ "Mojon Twins Multicart (HB).nes",          393232, 0xeec1e108, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mojontwimul)
STD_ROM_FN(nes_mojontwimul)

struct BurnDriver BurnDrvnes_mojontwimul = {
	"nes_mojontwimul", NULL, NULL, NULL, "2016",
	"Mojon Twins Multicart (HB)\0", NULL, "The Mojon Twins", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 2, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_mojontwimulRomInfo, nes_mojontwimulRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_jetpacoRomDesc[] = {
	{ "Jet-Paco (HB).nes",          40976, 0xb5f18574, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jetpaco)
STD_ROM_FN(nes_jetpaco)

struct BurnDriver BurnDrvnes_jetpaco = {
	"nes_jetpaco", NULL, NULL, NULL, "2015",
	"Jet-Paco (HB)\0", NULL, "The Mojon Twins", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HOMEBREW, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_jetpacoRomInfo, nes_jetpacoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// --------------------------------------------
// Aftermarket/Hack/Homebrew Games section end.
// --------------------------------------------

// ---------------------------------------------------------
// GAMES (licensed products + translation/improvement hacks)
// ---------------------------------------------------------

// 10-Yard Fight (USA)
static struct BurnRomInfo nes_10yardfightRomDesc[] = {
	{ "10-Yard Fight (USA).nes",          40976, 0xc38b62cb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_10yardfight)
STD_ROM_FN(nes_10yardfight)

struct BurnDriver BurnDrvnes_10yardfight = {
	"nes_10yardfight", NULL, NULL, NULL, "1985",
	"10-Yard Fight (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_10yardfightRomInfo, nes_10yardfightRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// 1942 (Japan, USA)
static struct BurnRomInfo nes_1942RomDesc[] = {
	{ "1942 (Japan, USA).nes",          40976, 0xe9cf747f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_1942)
STD_ROM_FN(nes_1942)

struct BurnDriver BurnDrvnes_1942 = {
	"nes_1942", NULL, NULL, NULL, "1985",
	"1942 (Japan, USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_1942RomInfo, nes_1942RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// 1943 - The Battle of Midway (USA)
static struct BurnRomInfo nes_1943RomDesc[] = {
	{ "1943 - The Battle of Midway (USA).nes",          131088, 0xd131bf15, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_1943)
STD_ROM_FN(nes_1943)

struct BurnDriver BurnDrvnes_1943 = {
	"nes_1943", NULL, NULL, NULL, "1988",
	"1943 - The Battle of Midway (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_1943RomInfo, nes_1943RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// 2010 - Street Fighter (Japan)
static struct BurnRomInfo nes_2010RomDesc[] = {
	{ "2010 - Street Fighter (Japan).nes",          262160, 0xc5a04eff, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_2010)
STD_ROM_FN(nes_2010)

struct BurnDriver BurnDrvnes_2010 = {
	"nes_2010", NULL, NULL, NULL, "1990",
	"2010 - Street Fighter (Japan)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_2010RomInfo, nes_2010RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// 3-D Battles of World Runner, The (USA)
static struct BurnRomInfo nes_3dbatworruRomDesc[] = {
	{ "3-D Battles of World Runner, The (USA).nes",          131088, 0xd5ada486, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_3dbatworru)
STD_ROM_FN(nes_3dbatworru)

struct BurnDriver BurnDrvnes_3dbatworru = {
	"nes_3dbatworru", NULL, NULL, NULL, "1987",
	"3-D Battles of World Runner, The (USA)\0", NULL, "Acclaim", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_3dbatworruRomInfo, nes_3dbatworruRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// 3D Block (Unl)
static struct BurnRomInfo nes_3dblockRomDesc[] = {
	{ "3D Block (Unl).nes",          32784, 0xa760eeeb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_3dblock)
STD_ROM_FN(nes_3dblock)

struct BurnDriver BurnDrvnes_3dblock = {
	"nes_3dblock", NULL, NULL, NULL, "1990",
	"3D Block (Unl)\0", NULL, "RCM Group", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_3dblockRomInfo, nes_3dblockRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// 720 Degrees (USA)
static struct BurnRomInfo nes_720degreesRomDesc[] = {
	{ "720 Degrees (USA).nes",          131088, 0x6bc968af, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_720degrees)
STD_ROM_FN(nes_720degrees)

struct BurnDriver BurnDrvnes_720degrees = {
	"nes_720degrees", NULL, NULL, NULL, "1989",
	"720 Degrees (USA)\0", NULL, "Mindscape", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_720degreesRomInfo, nes_720degreesRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// 8 Eyes (USA)
static struct BurnRomInfo nes_8eyesRomDesc[] = {
	{ "8 Eyes (USA).nes",          262160, 0x18f9bb24, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_8eyes)
STD_ROM_FN(nes_8eyes)

struct BurnDriver BurnDrvnes_8eyes = {
	"nes_8eyes", NULL, NULL, NULL, "1990",
	"8 Eyes (USA)\0", NULL, "Taxan", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_8eyesRomInfo, nes_8eyesRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Abadox - The Deadly Inner War (USA)
static struct BurnRomInfo nes_abadoxRomDesc[] = {
	{ "Abadox - The Deadly Inner War (USA).nes",          262160, 0xdc87f63d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_abadox)
STD_ROM_FN(nes_abadox)

struct BurnDriver BurnDrvnes_abadox = {
	"nes_abadox", NULL, NULL, NULL, "1990",
	"Abadox - The Deadly Inner War (USA)\0", NULL, "Milton Bradley", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_abadoxRomInfo, nes_abadoxRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Action 52 (USA)
static struct BurnRomInfo nes_action52RomDesc[] = {
	{ "Action 52 (USA).nes",          2097168, 0x7fa90614, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_action52)
STD_ROM_FN(nes_action52)

struct BurnDriver BurnDrvnes_action52 = {
	"nes_action52", NULL, NULL, NULL, "1991",
	"Action 52 (USA)\0", NULL, "Active Enterprises", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_action52RomInfo, nes_action52RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Action in New York (Euro)
static struct BurnRomInfo nes_actioinnewyorRomDesc[] = {
	{ "Action in New York (Europe).nes",          262160, 0x5773a224, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_actioinnewyor)
STD_ROM_FN(nes_actioinnewyor)

struct BurnDriver BurnDrvnes_actioinnewyor = {
	"nes_actioinnewyor", "nes_scat", NULL, NULL, "1992",
	"Action in New York (Euro)\0", NULL, "Infogrames", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_actioinnewyorRomInfo, nes_actioinnewyorRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL, SCREEN_WIDTH, SCREEN_HEIGHT_PAL
};

// Addams Family, The (USA)
static struct BurnRomInfo nes_addamfamRomDesc[] = {
	{ "Addams Family, The (USA).nes",          262160, 0x08e2af80, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_addamfam)
STD_ROM_FN(nes_addamfam)

struct BurnDriver BurnDrvnes_addamfam = {
	"nes_addamfam", NULL, NULL, NULL, "1992",
	"Addams Family, The (USA)\0", NULL, "Ocean", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_addamfamRomInfo, nes_addamfamRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Addams Family, The - Pugsley's Scavenger Hunt (USA)
static struct BurnRomInfo nes_addamfampugsschuRomDesc[] = {
	{ "Addams Family, The - Pugsley's Scavenger Hunt (USA).nes",          262160, 0x6b8d777d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_addamfampugsschu)
STD_ROM_FN(nes_addamfampugsschu)

struct BurnDriver BurnDrvnes_addamfampugsschu = {
	"nes_addamfampugsschu", NULL, NULL, NULL, "1993",
	"Addams Family, The - Pugsley's Scavenger Hunt (USA)\0", NULL, "Ocean", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_addamfampugsschuRomInfo, nes_addamfampugsschuRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Advanced Dungeons & Dragons - Dragons of Flame (Hack, English v1.03)
// https://www.romhacking.net/
static struct BurnRomInfo nes_advdddfRomDesc[] = {
	{ "advanced dungeons & dragons - dragons of flame (t-eng).nes",          262160, 0x8196b978, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_advdddf)
STD_ROM_FN(nes_advdddf)

struct BurnDriver BurnDrvnes_advdddf = {
	"nes_advdddf", NULL, NULL, NULL, "2003",
	"Advanced Dungeons & Dragons - Dragons of Flame (Hack, English v1.03)\0", NULL, "DvD Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_advdddfRomInfo, nes_advdddfRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Advanced Dungeons & Dragons - Dragons of Flame (Japan)
static struct BurnRomInfo nes_advdddfjRomDesc[] = {
	{ "advanced dungeons & dragons - dragons of flame (japan).nes",          262160, 0x8ba5de24, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_advdddfj)
STD_ROM_FN(nes_advdddfj)

struct BurnDriver BurnDrvnes_advdddfj = {
	"nes_advdddfj", "nes_advdddf", NULL, NULL, "1992",
	"Advanced Dungeons & Dragons - Dragons of Flame (Japan)\0", NULL, "Pony Canyon", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_advdddfjRomInfo, nes_advdddfjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Advanced Dungeons & Dragons - Dragon Strike (USA)
static struct BurnRomInfo nes_advdddsRomDesc[] = {
	{ "advanced dungeons & dragons - dragon strike (usa).nes",          524304, 0x4c87cdde, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_advddds)
STD_ROM_FN(nes_advddds)

struct BurnDriver BurnDrvnes_advddds = {
	"nes_advddds", NULL, NULL, NULL, "1990",
	"Advanced Dungeons & Dragons - Dragon Strike (USA)\0", NULL, "Natsume", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_advdddsRomInfo, nes_advdddsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Advanced Dungeons & Dragons - Heroes of the Lance (USA)
static struct BurnRomInfo nes_advddhlRomDesc[] = {
	{ "advanced dungeons & dragons - heroes of the lance (usa).nes",          262160, 0xe880d426, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_advddhl)
STD_ROM_FN(nes_advddhl)

struct BurnDriver BurnDrvnes_advddhl = {
	"nes_advddhl", NULL, NULL, NULL, "1990",
	"Advanced Dungeons & Dragons - Heroes of the Lance (USA)\0", NULL, "FCI Inc.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_advddhlRomInfo, nes_advddhlRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Advanced Dungeons & Dragons - Hillsfar (USA)
static struct BurnRomInfo nes_advddhllfrRomDesc[] = {
	{ "advanced dungeons & dragons - hillsfar (usa).nes",          262160, 0x3849d0ee, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_advddhllfr)
STD_ROM_FN(nes_advddhllfr)

struct BurnDriver BurnDrvnes_advddhllfr = {
	"nes_advddhllfr", NULL, NULL, NULL, "1992",
	"Advanced Dungeons & Dragons - Hillsfar (USA)\0", NULL, "FCI Inc.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_advddhllfrRomInfo, nes_advddhllfrRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Advanced Dungeons & Dragons - Pool of Radiance (USA)
static struct BurnRomInfo nes_advddporRomDesc[] = {
	{ "advanced dungeons & dragons - pool of radiance (usa).nes",          655376, 0xbbea8d23, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_advddpor)
STD_ROM_FN(nes_advddpor)

struct BurnDriver BurnDrvnes_advddpor = {
	"nes_advddpor", NULL, NULL, NULL, "1992",
	"Advanced Dungeons & Dragons - Pool of Radiance (USA)\0", NULL, "FCI Inc.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_advddporRomInfo, nes_advddporRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Adventure Island (USA)
static struct BurnRomInfo nes_adventureislandRomDesc[] = {
	{ "Adventure Island (USA)(1988)(Hudson Soft).nes",          65552, 0xb78c09a2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_adventureisland)
STD_ROM_FN(nes_adventureisland)

struct BurnDriver BurnDrvnes_adventureisland = {
	"nes_adventureisland", NULL, NULL, NULL, "1988",
	"Adventure Island (USA)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_adventureislandRomInfo, nes_adventureislandRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Adventure Island 3 (USA)
static struct BurnRomInfo nes_advenisl3RomDesc[] = {
	{ "Adventure Island 3 (USA)(1992)(Hudson Soft).nes",          262160, 0x952cdacf, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_advenisl3)
STD_ROM_FN(nes_advenisl3)

struct BurnDriver BurnDrvnes_advenisl3 = {
	"nes_advenisl3", NULL, NULL, NULL, "1992",
	"Adventure Island 3 (USA)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_advenisl3RomInfo, nes_advenisl3RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Adventure Island II (USA, Prototype)
static struct BurnRomInfo nes_advenisliiuRomDesc[] = {
	{ "Adventure Island II (USA, Proto)(1991)(Hudson Soft).nes",          262160, 0x51a401ca, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_advenisliiu)
STD_ROM_FN(nes_advenisliiu)

struct BurnDriver BurnDrvnes_advenisliiu = {
	"nes_advenisliiu", "nes_advenislii", NULL, NULL, "1991",
	"Adventure Island II (USA, Prototype)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_PROTOTYPE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_advenisliiuRomInfo, nes_advenisliiuRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Adventure Island II (USA)
static struct BurnRomInfo nes_advenisliiRomDesc[] = {
	{ "Adventure Island II (USA)(1991)(Hudson Soft).nes",          262160, 0x5d8f80c7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_advenislii)
STD_ROM_FN(nes_advenislii)

struct BurnDriver BurnDrvnes_advenislii = {
	"nes_advenislii", NULL, NULL, NULL, "1991",
	"Adventure Island II (USA)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_advenisliiRomInfo, nes_advenisliiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Adventure Island IV (Hack, English)
// https://www.romhacking.net/translations/3703/
static struct BurnRomInfo nes_advenislivRomDesc[] = {
	{ "Adventure Island IV T-Eng (2018)(Zynk Oxhyde).nes",          393232, 0x54c153c6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_advenisliv)
STD_ROM_FN(nes_advenisliv)

struct BurnDriver BurnDrvnes_advenisliv = {
	"nes_advenisliv", NULL, NULL, NULL, "2018",
	"Adventure Island IV (Hack, English)\0", NULL, "Zynk Oxhyde", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_advenislivRomInfo, nes_advenislivRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Adventures in the Magic Kingdom (USA)
static struct BurnRomInfo nes_adveninmagkinRomDesc[] = {
	{ "Adventures in the Magic Kingdom (USA).nes",          262160, 0x300e41b7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_adveninmagkin)
STD_ROM_FN(nes_adveninmagkin)

struct BurnDriver BurnDrvnes_adveninmagkin = {
	"nes_adveninmagkin", NULL, NULL, NULL, "1990",
	"Adventures in the Magic Kingdom (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_adveninmagkinRomInfo, nes_adveninmagkinRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Adventures of Bayou Billy, The (USA)
static struct BurnRomInfo nes_advenbaybilRomDesc[] = {
	{ "Adventures of Bayou Billy, The (USA).nes",          262160, 0x0ac631ba, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_advenbaybil)
STD_ROM_FN(nes_advenbaybil)

struct BurnDriver BurnDrvnes_advenbaybil = {
	"nes_advenbaybil", NULL, NULL, NULL, "1989",
	"Adventures of Bayou Billy, The (USA)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_SHOOT, 0,
	NESGetZipName, nes_advenbaybilRomInfo, nes_advenbaybilRomName, NULL, NULL, NULL, NULL, NESZapperInputInfo, NESZapperDIPInfo,
	NESZapperInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Adventures of Dino Riki (USA)
static struct BurnRomInfo nes_advendinrikRomDesc[] = {
	{ "Adventures of Dino Riki (USA).nes",          65552, 0xd4f5287b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_advendinrik)
STD_ROM_FN(nes_advendinrik)

struct BurnDriver BurnDrvnes_advendinrik = {
	"nes_advendinrik", NULL, NULL, NULL, "1989",
	"Adventures of Dino Riki (USA)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_advendinrikRomInfo, nes_advendinrikRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Adventures of Gilligan's Island, The (USA)
static struct BurnRomInfo nes_advengilsislRomDesc[] = {
	{ "Adventures of Gilligan's Island, The (USA).nes",          131088, 0x667eebb4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_advengilsisl)
STD_ROM_FN(nes_advengilsisl)

struct BurnDriver BurnDrvnes_advengilsisl = {
	"nes_advengilsisl", NULL, NULL, NULL, "1990",
	"Adventures of Gilligan's Island, The (USA)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_advengilsislRomInfo, nes_advengilsislRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Adventures of Lolo (USA)
static struct BurnRomInfo nes_advenlolRomDesc[] = {
	{ "Adventures of Lolo (USA).nes",          65552, 0xd9c4cbf7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_advenlol)
STD_ROM_FN(nes_advenlol)

struct BurnDriver BurnDrvnes_advenlol = {
	"nes_advenlol", NULL, NULL, NULL, "1989",
	"Adventures of Lolo (USA)\0", NULL, "HAL Laboratory", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_advenlolRomInfo, nes_advenlolRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Adventures of Lolo 2 (USA)
static struct BurnRomInfo nes_advenlol2RomDesc[] = {
	{ "Adventures of Lolo 2 (USA).nes",          65552, 0x862ab1e5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_advenlol2)
STD_ROM_FN(nes_advenlol2)

struct BurnDriver BurnDrvnes_advenlol2 = {
	"nes_advenlol2", NULL, NULL, NULL, "1990",
	"Adventures of Lolo 2 (USA)\0", NULL, "HAL Laboratory", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_advenlol2RomInfo, nes_advenlol2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Adventures of Lolo 3 (USA)
static struct BurnRomInfo nes_advenlol3RomDesc[] = {
	{ "Adventures of Lolo 3 (USA).nes",          262160, 0xb852cb26, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_advenlol3)
STD_ROM_FN(nes_advenlol3)

struct BurnDriver BurnDrvnes_advenlol3 = {
	"nes_advenlol3", NULL, NULL, NULL, "1991",
	"Adventures of Lolo 3 (USA)\0", NULL, "HAL Laboratory", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_advenlol3RomInfo, nes_advenlol3RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Adventures of Rad Gravity, The (USA)
static struct BurnRomInfo nes_advenradgraRomDesc[] = {
	{ "Adventures of Rad Gravity, The (USA).nes",          262160, 0xb55d5747, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_advenradgra)
STD_ROM_FN(nes_advenradgra)

struct BurnDriver BurnDrvnes_advenradgra = {
	"nes_advenradgra", NULL, NULL, NULL, "1990",
	"Adventures of Rad Gravity, The (USA)\0", NULL, "Activision", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_advenradgraRomInfo, nes_advenradgraRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Adventures of Rocky and Bullwinkle and Friends, The (USA)
static struct BurnRomInfo nes_advenrocandbulandfrRomDesc[] = {
	{ "Adventures of Rocky and Bullwinkle and Friends, The (USA).nes",          262160, 0x08effde5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_advenrocandbulandfr)
STD_ROM_FN(nes_advenrocandbulandfr)

struct BurnDriver BurnDrvnes_advenrocandbulandfr = {
	"nes_advenrocandbulandfr", NULL, NULL, NULL, "1992",
	"Adventures of Rocky and Bullwinkle and Friends, The (USA)\0", NULL, "THQ", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_advenrocandbulandfrRomInfo, nes_advenrocandbulandfrRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Adventures of Tom Sawyer (USA)
static struct BurnRomInfo nes_adventomsawRomDesc[] = {
	{ "Adventures of Tom Sawyer (USA).nes",          262160, 0x0336f9f3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_adventomsaw)
STD_ROM_FN(nes_adventomsaw)

struct BurnDriver BurnDrvnes_adventomsaw = {
	"nes_adventomsaw", NULL, NULL, NULL, "1989",
	"Adventures of Tom Sawyer (USA)\0", NULL, "Seta", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_adventomsawRomInfo, nes_adventomsawRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// After Burner (USA)
static struct BurnRomInfo nes_afterburnerRomDesc[] = {
	{ "After Burner (USA).nes",          393232, 0xa0c558a9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_afterburner)
STD_ROM_FN(nes_afterburner)

struct BurnDriver BurnDrvnes_afterburner = {
	"nes_afterburner", NULL, NULL, NULL, "1989",
	"After Burner (USA)\0", NULL, "Tengen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_afterburnerRomInfo, nes_afterburnerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// After Burner II (Japan)
static struct BurnRomInfo nes_afterburneriiRomDesc[] = {
	{ "After Burner II (Japan).nes",          393232, 0xa4928096, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_afterburnerii)
STD_ROM_FN(nes_afterburnerii)

struct BurnDriver BurnDrvnes_afterburnerii = {
	"nes_afterburnerii", NULL, NULL, NULL, "1989",
	"After Burner II (Japan)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_afterburneriiRomInfo, nes_afterburneriiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Airball (World)
static struct BurnRomInfo nes_airballRomDesc[] = {
	{ "Airball (2007)(Retrozone).nes",          131088, 0x9a535a93, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_airball)
STD_ROM_FN(nes_airball)

struct BurnDriver BurnDrvnes_airball = {
	"nes_airball", NULL, NULL, NULL, "2007",
	"Airball (World)\0", NULL, "Retrozone - Tengen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_MAZE | GBF_PUZZLE, 0,
	NESGetZipName, nes_airballRomInfo, nes_airballRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Airball (Prototype)
static struct BurnRomInfo nes_airballpRomDesc[] = {
	{ "Airball (Proto)(1990)(Tengen).nes",          131088, 0x8adb80e1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_airballp)
STD_ROM_FN(nes_airballp)

struct BurnDriver BurnDrvnes_airballp = {
	"nes_airballp", "nes_airball", NULL, NULL, "1990",
	"Airball (Prototype)\0", NULL, "Tengen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_PROTOTYPE, 1, HARDWARE_NES, GBF_MAZE | GBF_PUZZLE, 0,
	NESGetZipName, nes_airballpRomInfo, nes_airballpRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Air Fortress (USA)
static struct BurnRomInfo nes_airfortressRomDesc[] = {
	{ "Air Fortress (USA).nes",          163856, 0xb8fd02b7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_airfortress)
STD_ROM_FN(nes_airfortress)

struct BurnDriver BurnDrvnes_airfortress = {
	"nes_airfortress", NULL, NULL, NULL, "1989",
	"Air Fortress (USA)\0", NULL, "HAL Laboratory", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_airfortressRomInfo, nes_airfortressRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Airwolf (Japan)
static struct BurnRomInfo nes_airwolfjRomDesc[] = {
	{ "Airwolf (Japan).nes",          262160, 0x9639baae, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_airwolfj)
STD_ROM_FN(nes_airwolfj)

struct BurnDriver BurnDrvnes_airwolfj = {
	"nes_airwolfj", "nes_airwolf", NULL, NULL, "1988",
	"Airwolf (Japan)\0", NULL, "Kyugo Boueki", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_airwolfjRomInfo, nes_airwolfjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Airwolf (Hack, English)
static struct BurnRomInfo nes_airwolftRomDesc[] = {
	{ "Airwolf (T-eng).nes",          262160, 0xdeb8ef4a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_airwolft)
STD_ROM_FN(nes_airwolft)

struct BurnDriver BurnDrvnes_airwolft = {
	"nes_airwolft", "nes_airwolf", NULL, NULL, "2003",
	"Airwolf (Hack, English)\0", NULL, "Vice Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_airwolftRomInfo, nes_airwolftRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Airwolf (USA)
static struct BurnRomInfo nes_airwolfRomDesc[] = {
	{ "Airwolf (USA).nes",          163856, 0xf0a5eb24, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_airwolf)
STD_ROM_FN(nes_airwolf)

struct BurnDriver BurnDrvnes_airwolf = {
	"nes_airwolf", NULL, NULL, NULL, "1989",
	"Airwolf (USA)\0", NULL, "Acclaim", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_airwolfRomInfo, nes_airwolfRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Akira (Japan)
static struct BurnRomInfo nes_akirajRomDesc[] = {
	{ "Akira (Japan).nes",          393232, 0x9d83974c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_akiraj)
STD_ROM_FN(nes_akiraj)

struct BurnDriver BurnDrvnes_akiraj = {
	"nes_akiraj", "nes_akira", NULL, NULL, "1988",
	"Akira (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_akirajRomInfo, nes_akirajRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Akira (Hack, English)
static struct BurnRomInfo nes_akiraRomDesc[] = {
	{ "Akira (T-Eng).nes",          524304, 0xab6a9ee1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_akira)
STD_ROM_FN(nes_akira)

struct BurnDriver BurnDrvnes_akira = {
	"nes_akira", NULL, NULL, NULL, "2012",
	"Akira (Hack, English)\0", NULL, "Grimm Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_akiraRomInfo, nes_akiraRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Akumajou Densetsu (Japan)
static struct BurnRomInfo nes_akumadenjRomDesc[] = {
	{ "Akumajou Densetsu (Japan).nes",          393232, 0x2e93ce72, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_akumadenj)
STD_ROM_FN(nes_akumadenj)

struct BurnDriver BurnDrvnes_akumadenj = {
	"nes_akumadenj", "nes_castliii", NULL, NULL, "1989",
	"Akumajou Densetsu (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_akumadenjRomInfo, nes_akumadenjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Akumajou Densetsu (Hack, English)
static struct BurnRomInfo nes_akumadenRomDesc[] = {
	{ "Akumajou Densetsu (T-Eng).nes",          393232, 0x1965a3dc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_akumaden)
STD_ROM_FN(nes_akumaden)

struct BurnDriver BurnDrvnes_akumaden = {
	"nes_akumaden", "nes_castliii", NULL, NULL, "2003",
	"Akumajou Densetsu (Hack, English)\0", NULL, "Vice Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_akumadenRomInfo, nes_akumadenRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Akumajou Dracula (Japan)
static struct BurnRomInfo nes_akumajoudraculaRomDesc[] = {
	{ "Akumajou Dracula (Japan).nes",          131088, 0x93f0488c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_akumajoudracula)
STD_ROM_FN(nes_akumajoudracula)

struct BurnDriver BurnDrvnes_akumajoudracula = {
	"nes_akumajoudracula", "nes_castlevania", NULL, NULL, "1993",
	"Akumajou Dracula (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_akumajoudraculaRomInfo, nes_akumajoudraculaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Akumajou Special - Boku Dracula-kun (Japan)
static struct BurnRomInfo nes_akumaspeRomDesc[] = {
	{ "Akumajou Special - Boku Dracula-kun (Japan).nes",          262160, 0xf916d969, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_akumaspe)
STD_ROM_FN(nes_akumaspe)

struct BurnDriver BurnDrvnes_akumaspe = {
	"nes_akumaspe", "nes_kiddracula", NULL, NULL, "1990",
	"Akumajou Special - Boku Dracula-kun (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_akumaspeRomInfo, nes_akumaspeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Al Unser Jr. Turbo Racing (USA)
static struct BurnRomInfo nes_alunsjrturraRomDesc[] = {
	{ "Al Unser Jr. Turbo Racing (USA).nes",          262160, 0x023c7774, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_alunsjrturra)
STD_ROM_FN(nes_alunsjrturra)

struct BurnDriver BurnDrvnes_alunsjrturra = {
	"nes_alunsjrturra", NULL, NULL, NULL, "1990",
	"Al Unser Jr. Turbo Racing (USA)\0", NULL, "Data East", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_alunsjrturraRomInfo, nes_alunsjrturraRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Aladdin (Euro)
static struct BurnRomInfo nes_aladdinRomDesc[] = {
	{ "Aladdin (Europe).nes",          262160, 0xdcd55bec, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_aladdin)
STD_ROM_FN(nes_aladdin)

struct BurnDriver BurnDrvnes_aladdin = {
	"nes_aladdin", NULL, NULL, NULL, "1994",
	"Aladdin (Euro)\0", NULL, "Virgin Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_aladdinRomInfo, nes_aladdinRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL, SCREEN_WIDTH, SCREEN_HEIGHT_PAL
};

// Alfombra Magica, La (Euro) (Rev 1)
static struct BurnRomInfo nes_alfommaglaRomDesc[] = {
	{ "Alfombra Magica, La (Spain) (Rev 1) (Gluk Video) (Unl).nes",          65552, 0x7f165221, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_alfommagla)
STD_ROM_FN(nes_alfommagla)

struct BurnDriver BurnDrvnes_alfommagla = {
	"nes_alfommagla", NULL, NULL, NULL, "1991-92",
	"Alfombra Magica, La (Euro) (Rev 1)\0", NULL, "Mega Soft - Gluk Video", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_alfommaglaRomInfo, nes_alfommaglaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Alfred Chicken (USA)
static struct BurnRomInfo nes_alfredchickenRomDesc[] = {
	{ "Alfred Chicken (USA).nes",          131088, 0xa01ef87e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_alfredchicken)
STD_ROM_FN(nes_alfredchicken)

struct BurnDriver BurnDrvnes_alfredchicken = {
	"nes_alfredchicken", NULL, NULL, NULL, "1994",
	"Alfred Chicken (USA)\0", NULL, "Mindscape", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_alfredchickenRomInfo, nes_alfredchickenRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Alien 3 (USA)
static struct BurnRomInfo nes_alien3RomDesc[] = {
	{ "Alien 3 (USA).nes",          262160, 0xefb4ca05, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_alien3)
STD_ROM_FN(nes_alien3)

struct BurnDriver BurnDrvnes_alien3 = {
	"nes_alien3", NULL, NULL, NULL, "1993",
	"Alien 3 (USA)\0", NULL, "Ljn", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_alien3RomInfo, nes_alien3RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Alien Syndrome (USA)
static struct BurnRomInfo nes_aliensyndromeRomDesc[] = {
	{ "Alien Syndrome (USA).nes",          262160, 0x9e8351af, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_aliensyndrome)
STD_ROM_FN(nes_aliensyndrome)

struct BurnDriver BurnDrvnes_aliensyndrome = {
	"nes_aliensyndrome", NULL, NULL, NULL, "1989",
	"Alien Syndrome (USA)\0", NULL, "Tengen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_aliensyndromeRomInfo, nes_aliensyndromeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Alpha Mission (USA)
static struct BurnRomInfo nes_alphamissionRomDesc[] = {
	{ "Alpha Mission (USA).nes",          65552, 0x02e67223, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_alphamission)
STD_ROM_FN(nes_alphamission)

struct BurnDriver BurnDrvnes_alphamission = {
	"nes_alphamission", NULL, NULL, NULL, "1987",
	"Alpha Mission (USA)\0", NULL, "SNK", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_alphamissionRomInfo, nes_alphamissionRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Amagon (USA)
static struct BurnRomInfo nes_amagonRomDesc[] = {
	{ "Amagon (USA).nes",          131088, 0xd1bde95c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_amagon)
STD_ROM_FN(nes_amagon)

struct BurnDriver BurnDrvnes_amagon = {
	"nes_amagon", NULL, NULL, NULL, "1989",
	"Amagon (USA)\0", NULL, "Sammy", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_amagonRomInfo, nes_amagonRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// American Dream (Japan)
static struct BurnRomInfo nes_americandreamjRomDesc[] = {
	{ "American Dream (Japan).nes",          262160, 0x5249764c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_americandreamj)
STD_ROM_FN(nes_americandreamj)

struct BurnDriver BurnDrvnes_americandreamj = {
	"nes_americandreamj", "nes_americandream", NULL, NULL, "1989",
	"American Dream (Japan)\0", NULL, "Coconuts", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG | GBF_STRATEGY, 0,
	NESGetZipName, nes_americandreamjRomInfo, nes_americandreamjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// American Dream (Hack, English)
static struct BurnRomInfo nes_americandreamRomDesc[] = {
	{ "American Dream (T-Eng).nes",          262160, 0xd2275854, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_americandream)
STD_ROM_FN(nes_americandream)

struct BurnDriver BurnDrvnes_americandream = {
	"nes_americandream", NULL, NULL, NULL, "2007",
	"American Dream (Hack, English)\0", NULL, "Pale Dim", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG | GBF_STRATEGY, 0,
	NESGetZipName, nes_americandreamRomInfo, nes_americandreamRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// American Gladiators (USA)
static struct BurnRomInfo nes_ameriglaRomDesc[] = {
	{ "American Gladiators (USA).nes",          262160, 0x74c08f86, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_amerigla)
STD_ROM_FN(nes_amerigla)

struct BurnDriver BurnDrvnes_amerigla = {
	"nes_amerigla", NULL, NULL, NULL, "1991",
	"American Gladiators (USA)\0", NULL, "GameTek", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_ameriglaRomInfo, nes_ameriglaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Antarctic Adventure (Japan)
static struct BurnRomInfo nes_antaradvRomDesc[] = {
	{ "Antarctic Adventure (Japan).nes",          24592, 0x9da252b4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_antaradv)
STD_ROM_FN(nes_antaradv)

struct BurnDriver BurnDrvnes_antaradv = {
	"nes_antaradv", NULL, NULL, NULL, "1985",
	"Antarctic Adventure (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_antaradvRomInfo, nes_antaradvRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Anticipation (USA)
static struct BurnRomInfo nes_anticipationRomDesc[] = {
	{ "Anticipation (USA).nes",          65552, 0x31d239d6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_anticipation)
STD_ROM_FN(nes_anticipation)

struct BurnDriver BurnDrvnes_anticipation = {
	"nes_anticipation", NULL, NULL, NULL, "1988",
	"Anticipation (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_BOARD, 0,
	NESGetZipName, nes_anticipationRomInfo, nes_anticipationRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Arch Rivals - A Basketbrawl! (USA)
static struct BurnRomInfo nes_archrivRomDesc[] = {
	{ "Arch Rivals - A Basketbrawl! (USA).nes",          131088, 0x37ef8319, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_archriv)
STD_ROM_FN(nes_archriv)

struct BurnDriver BurnDrvnes_archriv = {
	"nes_archriv", NULL, NULL, NULL, "1990",
	"Arch Rivals - A Basketbrawl! (USA)\0", NULL, "Acclaim", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_archrivRomInfo, nes_archrivRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Archon (USA)
static struct BurnRomInfo nes_archonRomDesc[] = {
	{ "Archon (USA).nes",          131088, 0xc00d228d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_archon)
STD_ROM_FN(nes_archon)

struct BurnDriver BurnDrvnes_archon = {
	"nes_archon", NULL, NULL, NULL, "1989",
	"Archon (USA)\0", NULL, "Activision", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_STRATEGY | GBF_BOARD, 0,
	NESGetZipName, nes_archonRomInfo, nes_archonRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// A Ressha de Ikou (Hack, English)
// https://www.romhacking.net/
static struct BurnRomInfo nes_atrainRomDesc[] = {
	{ "a ressha de ikou (t-eng).nes",          147472, 0xfd7bc532, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_atrain)
STD_ROM_FN(nes_atrain)

struct BurnDriver BurnDrvnes_atrain = {
	"nes_atrain", NULL, NULL, NULL, "2021",
	"A Ressha de Ikou (Hack, English)\0", NULL, "AgentOrange & Jink640", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_atrainRomInfo, nes_atrainRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// A Ressha de Ikou (Japan)
static struct BurnRomInfo nes_atrainjRomDesc[] = {
	{ "a ressha de ikou (japan).nes",          147472, 0x58fe5467, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_atrainj)
STD_ROM_FN(nes_atrainj)

	struct BurnDriver BurnDrvnes_atrainj = {
	"nes_atrainj", "nes_atrain", NULL, NULL, "1991",
	"A Ressha de Ikou (Japan)\0", NULL, "Pony Canyon", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_atrainjRomInfo, nes_atrainjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Argus (Japan)
static struct BurnRomInfo nes_argusRomDesc[] = {
	{ "Argus (Japan).nes",          49168, 0xd6396aa7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_argus)
STD_ROM_FN(nes_argus)

struct BurnDriver BurnDrvnes_argus = {
	"nes_argus", NULL, NULL, NULL, "1986",
	"Argus (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_argusRomInfo, nes_argusRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Arkanoid (USA)
static struct BurnRomInfo nes_arkanoidRomDesc[] = {
	{ "Arkanoid (USA).nes",          49168, 0xee93a28c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_arkanoid)
STD_ROM_FN(nes_arkanoid)

struct BurnDriver BurnDrvnes_arkanoid = {
	"nes_arkanoid", NULL, NULL, NULL, "1987",
	"Arkanoid (USA)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_BREAKOUT, 0,
	NESGetZipName, nes_arkanoidRomInfo, nes_arkanoidRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Arkanoid After Dark (Hack)
// https://www.romhacking.net/hacks/2060/
static struct BurnRomInfo nes_arkanoidadRomDesc[] = {
	{ "Arkanoid After Dark Hack (2014)(Super Justin Bros).nes",          40976, 0x79ceb4d5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_arkanoidad)
STD_ROM_FN(nes_arkanoidad)

struct BurnDriver BurnDrvnes_arkanoidad = {
	"nes_arkanoidad", "nes_arkanoid", NULL, NULL, "2014",
	"Arkanoid After Dark (Hack)\0", NULL, "Super Justin Bros", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_BREAKOUT, 0,
	NESGetZipName, nes_arkanoidadRomInfo, nes_arkanoidadRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Arkanoid II (Japan)
static struct BurnRomInfo nes_arkanoidiiRomDesc[] = {
	{ "Arkanoid II (Japan).nes",          262160, 0xc7db2710, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_arkanoidii)
STD_ROM_FN(nes_arkanoidii)

struct BurnDriver BurnDrvnes_arkanoidii = {
	"nes_arkanoidii", NULL, NULL, NULL, "1988",
	"Arkanoid II (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_BREAKOUT, 0,
	NESGetZipName, nes_arkanoidiiRomInfo, nes_arkanoidiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Arkista's Ring (USA)
static struct BurnRomInfo nes_arkistasringRomDesc[] = {
	{ "Arkista's Ring (USA).nes",          65552, 0xcd3aa2a5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_arkistasring)
STD_ROM_FN(nes_arkistasring)

struct BurnDriver BurnDrvnes_arkistasring = {
	"nes_arkistasring", NULL, NULL, NULL, "1990",
	"Arkista's Ring (USA)\0", NULL, "Sammy", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_arkistasringRomInfo, nes_arkistasringRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Armadillo (Japan)
static struct BurnRomInfo nes_armadillojRomDesc[] = {
	{ "Armadillo (Japan).nes",          393232, 0xae73e0c2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_armadilloj)
STD_ROM_FN(nes_armadilloj)

struct BurnDriver BurnDrvnes_armadilloj = {
	"nes_armadilloj", "nes_armadillo", NULL, NULL, "1991",
	"Armadillo (Japan)\0", NULL, "IGS", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_armadillojRomInfo, nes_armadillojRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Armadillo (Hack, English)
static struct BurnRomInfo nes_armadilloRomDesc[] = {
	{ "Armadillo (T-eng).nes",          393232, 0x651c9916, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_armadillo)
STD_ROM_FN(nes_armadillo)

struct BurnDriver BurnDrvnes_armadillo = {
	"nes_armadillo", NULL, NULL, NULL, "2007",
	"Armadillo (Hack, English)\0", NULL, "Vice Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_armadilloRomInfo, nes_armadilloRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Armed Dragon Fantasy Villgust (Japan)
static struct BurnRomInfo nes_armeddrafanviljRomDesc[] = {
	{ "Armed Dragon Fantasy Villgust (Japan).nes",          393232, 0x5a8bfdf5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_armeddrafanvilj)
STD_ROM_FN(nes_armeddrafanvilj)

struct BurnDriver BurnDrvnes_armeddrafanvilj = {
	"nes_armeddrafanvilj", "nes_armeddrafanvil", NULL, NULL, "1993",
	"Armed Dragon Fantasy Villgust (Japan)\0", NULL, "Angel Studios", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_armeddrafanviljRomInfo, nes_armeddrafanviljRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Armed Dragon Fantasy Villgust (Hack, English)
static struct BurnRomInfo nes_armeddrafanvilRomDesc[] = {
	{ "Armed Dragon Fantasy Villgust (T-Eng).nes",          524304, 0xde77f40a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_armeddrafanvil)
STD_ROM_FN(nes_armeddrafanvil)

struct BurnDriver BurnDrvnes_armeddrafanvil = {
	"nes_armeddrafanvil", NULL, NULL, NULL, "2018",
	"Armed Dragon Fantasy Villgust (Hack, English)\0", NULL, "LIPEMCO! Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_armeddrafanvilRomInfo, nes_armeddrafanvilRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Asmik-kun Land (Hack, English)
static struct BurnRomInfo nes_asmikkunlandRomDesc[] = {
	{ "Asmik-kun Land T-Eng (2022)(Rani Baker).nes",          262160, 0xc2da9631, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_asmikkunland)
STD_ROM_FN(nes_asmikkunland)

struct BurnDriver BurnDrvnes_asmikkunland = {
	"nes_asmikkunland", NULL, NULL, NULL, "2022",
	"Asmik-kun Land (Hack, English)\0", NULL, "Rani Baker", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_asmikkunlandRomInfo, nes_asmikkunlandRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Asmik-kun Land (Japan)
static struct BurnRomInfo nes_asmikkunlandjRomDesc[] = {
	{ "Asmik-kun Land (Japan)(1991)(Asmik).nes",          262160, 0xc81cdf4e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_asmikkunlandj)
STD_ROM_FN(nes_asmikkunlandj)

struct BurnDriver BurnDrvnes_asmikkunlandj = {
	"nes_asmikkunlandj", "nes_asmikkunland", NULL, NULL, "1991",
	"Asmik-kun Land (Japan)\0", NULL, "Asmik", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_asmikkunlandjRomInfo, nes_asmikkunlandjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Asterix (Euro)
static struct BurnRomInfo nes_asterixRomDesc[] = {
	{ "Asterix (Europe).nes",          131088, 0xde7e6767, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_asterix)
STD_ROM_FN(nes_asterix)

struct BurnDriver BurnDrvnes_asterix = {
	"nes_asterix", NULL, NULL, NULL, "1993",
	"Asterix (Euro)\0", NULL, "Infogrames", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_asterixRomInfo, nes_asterixRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL, SCREEN_WIDTH, SCREEN_HEIGHT_PAL
};

// Astro Boy (Hack, English)
static struct BurnRomInfo nes_astroboyRomDesc[] = {
	{ "Astro Boy T-Eng (2022)(Pacnsacdave).nes",          262160, 0xd5e10c90, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_astroboy)
STD_ROM_FN(nes_astroboy)

struct BurnDriver BurnDrvnes_astroboy = {
	"nes_astroboy", NULL, NULL, NULL, "2022",
	"Astro Boy (Hack, English)\0", NULL, "pacnsacdave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_astroboyRomInfo, nes_astroboyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Astro Fang - Super Machine (Japan)
static struct BurnRomInfo nes_astrofanjRomDesc[] = {
	{ "Astro Fang - Super Machine (Japan).nes",          262160, 0xc3dae718, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_astrofanj)
STD_ROM_FN(nes_astrofanj)

struct BurnDriver BurnDrvnes_astrofanj = {
	"nes_astrofanj", "nes_astrofan", NULL, NULL, "1990",
	"Astro Fang - Super Machine (Japan)\0", NULL, "A Wave Inc.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RACING | GBF_SHOOT, 0,
	NESGetZipName, nes_astrofanjRomInfo, nes_astrofanjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Astro Fang - Super Machine (Hack, English)
static struct BurnRomInfo nes_astrofanRomDesc[] = {
	{ "Astro Fang - Super Machine (T-eng).nes",          262160, 0xcfdb30c9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_astrofan)
STD_ROM_FN(nes_astrofan)

struct BurnDriver BurnDrvnes_astrofan = {
	"nes_astrofan", NULL, NULL, NULL, "2001",
	"Astro Fang - Super Machine (Hack, English)\0", NULL, "Caution", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RACING | GBF_SHOOT, 0,
	NESGetZipName, nes_astrofanRomInfo, nes_astrofanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Astro Robo Sasa (Japan)
static struct BurnRomInfo nes_astrorobosasaRomDesc[] = {
	{ "Astro Robo Sasa (Japan).nes",          40976, 0xcab240b1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_astrorobosasa)
STD_ROM_FN(nes_astrorobosasa)

struct BurnDriver BurnDrvnes_astrorobosasa = {
	"nes_astrorobosasa", NULL, NULL, NULL, "1985",
	"Astro Robo Sasa (Japan)\0", NULL, "ASCII Corp.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_astrorobosasaRomInfo, nes_astrorobosasaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Astyanax (USA)
static struct BurnRomInfo nes_astyanaxRomDesc[] = {
	{ "Astyanax (USA).nes",          262160, 0x2fdfbc79, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_astyanax)
STD_ROM_FN(nes_astyanax)

struct BurnDriver BurnDrvnes_astyanax = {
	"nes_astyanax", NULL, NULL, NULL, "1990",
	"Astyanax (USA)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_astyanaxRomInfo, nes_astyanaxRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Athena (USA)
static struct BurnRomInfo nes_athenaRomDesc[] = {
	{ "Athena (USA).nes",          131088, 0x14d42113, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_athena)
STD_ROM_FN(nes_athena)

struct BurnDriver BurnDrvnes_athena = {
	"nes_athena", NULL, NULL, NULL, "1987",
	"Athena (USA)\0", NULL, "SNK", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_athenaRomInfo, nes_athenaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Atlantis no Nazo (Japan)
static struct BurnRomInfo nes_atlantisnonazojRomDesc[] = {
	{ "Atlantis no Nazo (Japan).nes",          49168, 0xdccbe3ae, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_atlantisnonazoj)
STD_ROM_FN(nes_atlantisnonazoj)

struct BurnDriver BurnDrvnes_atlantisnonazoj = {
	"nes_atlantisnonazoj", "nes_atlantisnonazo", NULL, NULL, "1986",
	"Atlantis no Nazo (Japan)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_atlantisnonazojRomInfo, nes_atlantisnonazojRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Atlantis no Nazo (Hack, English)
static struct BurnRomInfo nes_atlantisnonazoRomDesc[] = {
	{ "Atlantis no Nazo (T-Eng).nes",          49168, 0x6a5ee2fc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_atlantisnonazo)
STD_ROM_FN(nes_atlantisnonazo)

struct BurnDriver BurnDrvnes_atlantisnonazo = {
	"nes_atlantisnonazo", NULL, NULL, NULL, "2015",
	"Atlantis no Nazo (Hack, English)\0", NULL, "pacnsacdave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_atlantisnonazoRomInfo, nes_atlantisnonazoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Attack Animal Gakuen (Japan)
static struct BurnRomInfo nes_attacanigakjRomDesc[] = {
	{ "Attack Animal Gakuen (Japan).nes",          131088, 0x4e5c1c1d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_attacanigakj)
STD_ROM_FN(nes_attacanigakj)

struct BurnDriver BurnDrvnes_attacanigakj = {
	"nes_attacanigakj", "nes_attacanigak", NULL, NULL, "1987",
	"Attack Animal Gakuen (Japan)\0", NULL, "Pony Canyon", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_attacanigakjRomInfo, nes_attacanigakjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Attack Animal Gakuen (Hack, English)
static struct BurnRomInfo nes_attacanigakRomDesc[] = {
	{ "Attack Animal Gakuen (T-eng).nes",          131088, 0xefbf63ee, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_attacanigak)
STD_ROM_FN(nes_attacanigak)

struct BurnDriver BurnDrvnes_attacanigak = {
	"nes_attacanigak", NULL, NULL, NULL, "2003",
	"Attack Animal Gakuen (Hack, English)\0", NULL, "PentarouZero", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_attacanigakRomInfo, nes_attacanigakRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Attack of the Killer Tomatoes (USA)
static struct BurnRomInfo nes_attackiltomRomDesc[] = {
	{ "Attack of the Killer Tomatoes (USA).nes",          262160, 0x11dc4071, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_attackiltom)
STD_ROM_FN(nes_attackiltom)

struct BurnDriver BurnDrvnes_attackiltom = {
	"nes_attackiltom", NULL, NULL, NULL, "1992",
	"Attack of the Killer Tomatoes (USA)\0", NULL, "THQ", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_attackiltomRomInfo, nes_attackiltomRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// B-Wings (Japan)
static struct BurnRomInfo nes_bwingsRomDesc[] = {
	{ "B-Wings (Japan).nes",          40976, 0x15a4facb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bwings)
STD_ROM_FN(nes_bwings)

struct BurnDriver BurnDrvnes_bwings = {
	"nes_bwings", NULL, NULL, NULL, "1986",
	"B-Wings (Japan)\0", NULL, "Data East", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_bwingsRomInfo, nes_bwingsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Babel no Tou (Japan)
static struct BurnRomInfo nes_babelnotouRomDesc[] = {
	{ "Babel no Tou (Japan).nes",          65552, 0x154a31b6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_babelnotou)
STD_ROM_FN(nes_babelnotou)

struct BurnDriver BurnDrvnes_babelnotou = {
	"nes_babelnotou", NULL, NULL, NULL, "1986",
	"Babel no Tou (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM | GBF_PUZZLE, 0,
	NESGetZipName, nes_babelnotouRomInfo, nes_babelnotouRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Baby Boomer (USA)
static struct BurnRomInfo nes_babyboomerRomDesc[] = {
	{ "Baby Boomer (USA).nes",          81936, 0xed58dddd, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_babyboomer)
STD_ROM_FN(nes_babyboomer)

struct BurnDriver BurnDrvnes_babyboomer = {
	"nes_babyboomer", NULL, NULL, NULL, "1989",
	"Baby Boomer (USA)\0", NULL, "Color Dreams", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_babyboomerRomInfo, nes_babyboomerRomName, NULL, NULL, NULL, NULL, NESZapperInputInfo, NESZapperDIPInfo,
	NESZapperInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Back to the Future (USA)
static struct BurnRomInfo nes_backfutRomDesc[] = {
	{ "Back to the Future (USA).nes",          65552, 0x7c40d6c6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_backfut)
STD_ROM_FN(nes_backfut)

struct BurnDriver BurnDrvnes_backfut = {
	"nes_backfut", NULL, NULL, NULL, "1989",
	"Back to the Future (USA)\0", NULL, "Ljn", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_backfutRomInfo, nes_backfutRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Back to the Future Enhanced (Hack, v1.1)
static struct BurnRomInfo nes_backfutenhRomDesc[] = {
	{ "Back to the Future Enhanced v1.1 (2020)(pacnsacdave).nes",          65552, 0xa1382ff9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_backfutenh)
STD_ROM_FN(nes_backfutenh)

struct BurnDriver BurnDrvnes_backfutenh = {
	"nes_backfutenh", "nes_backfut", NULL, NULL, "2020",
	"Back to the Future Enhanced (Hack, v1.1)\0", NULL, "pacnsacdave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_backfutenhRomInfo, nes_backfutenhRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Back to the Future Part II & III (USA)
static struct BurnRomInfo nes_backfutpariiiiiRomDesc[] = {
	{ "Back to the Future Part II & III (USA).nes",          262160, 0x5a09134f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_backfutpariiiii)
STD_ROM_FN(nes_backfutpariiiii)

struct BurnDriver BurnDrvnes_backfutpariiiii = {
	"nes_backfutpariiiii", NULL, NULL, NULL, "1990",
	"Back to the Future Part II & III (USA)\0", NULL, "Ljn", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_backfutpariiiiiRomInfo, nes_backfutpariiiiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bad Dudes (USA)
static struct BurnRomInfo nes_baddudesRomDesc[] = {
	{ "Bad Dudes (USA).nes",          262160, 0x3c8e79e9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_baddudes)
STD_ROM_FN(nes_baddudes)

struct BurnDriver BurnDrvnes_baddudes = {
	"nes_baddudes", NULL, NULL, NULL, "1990",
	"Bad Dudes (USA)\0", NULL, "Data East", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_baddudesRomInfo, nes_baddudesRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bad News Baseball (USA)
static struct BurnRomInfo nes_badnewbasRomDesc[] = {
	{ "Bad News Baseball (USA).nes",          262160, 0x2d69dd94, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_badnewbas)
STD_ROM_FN(nes_badnewbas)

struct BurnDriver BurnDrvnes_badnewbas = {
	"nes_badnewbas", NULL, NULL, NULL, "1990",
	"Bad News Baseball (USA)\0", NULL, "Tecmo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_badnewbasRomInfo, nes_badnewbasRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bad Street Brawler (USA)
static struct BurnRomInfo nes_badstrbraRomDesc[] = {
	{ "Bad Street Brawler (USA).nes",          131088, 0xc8272d9a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_badstrbra)
STD_ROM_FN(nes_badstrbra)

struct BurnDriver BurnDrvnes_badstrbra = {
	"nes_badstrbra", NULL, NULL, NULL, "1989",
	"Bad Street Brawler (USA)\0", NULL, "Mattel", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_badstrbraRomInfo, nes_badstrbraRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_ballstoRomDesc[] = {
	{ "Ball Story - Jong Yuk Chuen Suet Fa Jong II (China).nes",          131088, 0x1090a2e5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ballsto)
STD_ROM_FN(nes_ballsto)

struct BurnDriver BurnDrvnes_ballsto = {
	"nes_ballsto", NULL, NULL, NULL, "1993",
	"Ball Story - Jong Yuk Chuen Suet Fa Jong II (China)\0", NULL, "Sun Team Corp.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION | GBF_PUZZLE, 0,
	NESGetZipName, nes_ballstoRomInfo, nes_ballstoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_ballblazerRomDesc[] = {
	{ "Ballblazer (Japan).nes",          131088, 0x7b43b3ef, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ballblazer)
STD_ROM_FN(nes_ballblazer)

struct BurnDriver BurnDrvnes_ballblazer = {
	"nes_ballblazer", NULL, NULL, NULL, "1988",
	"Ballblazer (Japan)\0", NULL, "Pony Canyon", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_ballblazerRomInfo, nes_ballblazerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_balloonfightRomDesc[] = {
	{ "Balloon Fight (USA).nes",          24592, 0xcb8fd7b2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_balloonfight)
STD_ROM_FN(nes_balloonfight)

struct BurnDriver BurnDrvnes_balloonfight = {
	"nes_balloonfight", NULL, NULL, NULL, "1986",
	"Balloon Fight (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_balloonfightRomInfo, nes_balloonfightRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_balloonmonsterRomDesc[] = {
	{ "Balloon Monster (Unl).nes",          40976, 0xb5ae9f8b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_balloonmonster)
STD_ROM_FN(nes_balloonmonster)

struct BurnDriver BurnDrvnes_balloonmonster = {
	"nes_balloonmonster", NULL, NULL, NULL, "1992",
	"Balloon Monster (Unl)\0", NULL, "Gluk Video", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_balloonmonsterRomInfo, nes_balloonmonsterRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_baltronRomDesc[] = {
	{ "Baltron (Japan).nes",          40976, 0xf85f8769, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_baltron)
STD_ROM_FN(nes_baltron)

struct BurnDriver BurnDrvnes_baltron = {
	"nes_baltron", NULL, NULL, NULL, "1986",
	"Baltron (Japan)\0", NULL, "Toei Animation", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_baltronRomInfo, nes_baltronRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Banana (Japan)
static struct BurnRomInfo nes_bananaRomDesc[] = {
	{ "Banana (Japan).nes",          49168, 0x5ac41464, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_banana)
STD_ROM_FN(nes_banana)

struct BurnDriver BurnDrvnes_banana = {
	"nes_banana", NULL, NULL, NULL, "1986",
	"Banana (Japan)\0", NULL, "Victor", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_bananaRomInfo, nes_bananaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Banana Prince (Germany)
static struct BurnRomInfo nes_bananaprincegRomDesc[] = {
	{ "Banana Prince (Germany).nes",          262160, 0xa0f6edee, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bananaprinceg)
STD_ROM_FN(nes_bananaprinceg)

struct BurnDriver BurnDrvnes_bananaprinceg = {
	"nes_bananaprinceg", "nes_bananaprince", NULL, NULL, "1992",
	"Banana Prince (Germany)\0", NULL, "Takara", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_bananaprincegRomInfo, nes_bananaprincegRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Banana Prince (Japan)
static struct BurnRomInfo nes_bananaprincejRomDesc[] = {
	{ "Banana Prince (Japan).nes",          262160, 0x4c7e9492, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bananaprincej)
STD_ROM_FN(nes_bananaprincej)

struct BurnDriver BurnDrvnes_bananaprincej = {
	"nes_bananaprincej", "nes_bananaprince", NULL, NULL, "1992",
	"Banana Prince (Japan)\0", NULL, "Takara", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_bananaprincejRomInfo, nes_bananaprincejRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Banana Prince (Hack, English)
static struct BurnRomInfo nes_bananaprinceRomDesc[] = {
	{ "Banana Prince (T-Eng).nes",          262160, 0x3a2e77a7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bananaprince)
STD_ROM_FN(nes_bananaprince)

struct BurnDriver BurnDrvnes_bananaprince = {
	"nes_bananaprince", NULL, NULL, NULL, "2003",
	"Banana Prince (Hack, English)\0", NULL, "KingMike", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_bananaprinceRomInfo, nes_bananaprinceRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_bandikinancchiRomDesc[] = {
	{ "Bandit Kings of Ancient China (USA).nes",          393232, 0xa9e2bf31, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bandikinancchi)
STD_ROM_FN(nes_bandikinancchi)

struct BurnDriver BurnDrvnes_bandikinancchi = {
	"nes_bandikinancchi", NULL, NULL, NULL, "1990",
	"Bandit Kings of Ancient China (USA)\0", NULL, "Koei", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_bandikinancchiRomInfo, nes_bandikinancchiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_barkebilstrishRomDesc[] = {
	{ "Barker Bill's Trick Shooting (USA).nes",          196624, 0xc898e6c1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_barkebilstrish)
STD_ROM_FN(nes_barkebilstrish)

struct BurnDriver BurnDrvnes_barkebilstrish = {
	"nes_barkebilstrish", NULL, NULL, NULL, "1990",
	"Barker Bill's Trick Shooting (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_barkebilstrishRomInfo, nes_barkebilstrishRomName, NULL, NULL, NULL, NULL, NESZapperInputInfo, NESZapperDIPInfo,
	NESZapperInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_basewarsRomDesc[] = {
	{ "Base Wars (USA).nes",          262160, 0xeed00ddf, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_basewars)
STD_ROM_FN(nes_basewars)

struct BurnDriver BurnDrvnes_basewars = {
	"nes_basewars", NULL, NULL, NULL, "1991",
	"Base Wars (USA)\0", NULL, "Ultra Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_basewarsRomInfo, nes_basewarsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_basebsim1000RomDesc[] = {
	{ "Baseball Simulator 1.000 (USA).nes",          262160, 0x469b04f6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_basebsim1000)
STD_ROM_FN(nes_basebsim1000)

struct BurnDriver BurnDrvnes_basebsim1000 = {
	"nes_basebsim1000", NULL, NULL, NULL, "1990",
	"Baseball Simulator 1.000 (USA)\0", NULL, "Culture Brain", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_basebsim1000RomInfo, nes_basebsim1000RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_baseballstarsRomDesc[] = {
	{ "Baseball Stars (USA).nes",          262160, 0x1924f963, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_baseballstars)
STD_ROM_FN(nes_baseballstars)

struct BurnDriver BurnDrvnes_baseballstars = {
	"nes_baseballstars", NULL, NULL, NULL, "1989",
	"Baseball Stars (USA)\0", NULL, "SNK", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_baseballstarsRomInfo, nes_baseballstarsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_basebstaiiRomDesc[] = {
	{ "Baseball Stars II (USA).nes",          393232, 0x104fabee, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_basebstaii)
STD_ROM_FN(nes_basebstaii)

struct BurnDriver BurnDrvnes_basebstaii = {
	"nes_basebstaii", NULL, NULL, NULL, "1992",
	"Baseball Stars II (USA)\0", NULL, "Romstar", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_basebstaiiRomInfo, nes_basebstaiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_basesloadedRomDesc[] = {
	{ "Bases Loaded (USA).nes",          327696, 0x5f1b9397, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_basesloaded)
STD_ROM_FN(nes_basesloaded)

struct BurnDriver BurnDrvnes_basesloaded = {
	"nes_basesloaded", NULL, NULL, NULL, "1988",
	"Bases Loaded (USA)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_basesloadedRomInfo, nes_basesloadedRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_basesloaded3RomDesc[] = {
	{ "Bases Loaded 3 (USA).nes",          393232, 0x1bdd1704, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_basesloaded3)
STD_ROM_FN(nes_basesloaded3)

struct BurnDriver BurnDrvnes_basesloaded3 = {
	"nes_basesloaded3", NULL, NULL, NULL, "1991",
	"Bases Loaded 3 (USA)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_basesloaded3RomInfo, nes_basesloaded3RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_basesloaded4RomDesc[] = {
	{ "Bases Loaded 4 (USA).nes",          393232, 0x0dee9ec1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_basesloaded4)
STD_ROM_FN(nes_basesloaded4)

struct BurnDriver BurnDrvnes_basesloaded4 = {
	"nes_basesloaded4", NULL, NULL, NULL, "1993",
	"Bases Loaded 4 (USA)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_basesloaded4RomInfo, nes_basesloaded4RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_basesloaiiRomDesc[] = {
	{ "Bases Loaded II - Second Season (USA).nes",          393232, 0x965b9a2f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_basesloaii)
STD_ROM_FN(nes_basesloaii)

struct BurnDriver BurnDrvnes_basesloaii = {
	"nes_basesloaii", NULL, NULL, NULL, "1990",
	"Bases Loaded II - Second Season (USA)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_basesloaiiRomInfo, nes_basesloaiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_bashibazRomDesc[] = {
	{ "Bashi Bazook - Morphoid Masher (USA) (Proto).nes",          262160, 0x11c92b5d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bashibaz)
STD_ROM_FN(nes_bashibaz)

struct BurnDriver BurnDrvnes_bashibaz = {
	"nes_bashibaz", NULL, NULL, NULL, "1989",
	"Bashi Bazook - Morphoid Masher (USA) (Prototype)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_PROTOTYPE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_bashibazRomInfo, nes_bashibazRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_batmaretjokRomDesc[] = {
	{ "Batman - Return of the Joker (USA).nes",          393232, 0xe14a7971, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_batmaretjok)
STD_ROM_FN(nes_batmaretjok)

struct BurnDriver BurnDrvnes_batmaretjok = {
	"nes_batmaretjok", NULL, NULL, NULL, "1991",
	"Batman - Return of the Joker (USA)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_batmaretjokRomInfo, nes_batmaretjokRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_batmavidgamjRomDesc[] = {
	{ "Batman - The Video Game (Japan).nes",          262160, 0x15f9a645, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_batmavidgamj)
STD_ROM_FN(nes_batmavidgamj)

struct BurnDriver BurnDrvnes_batmavidgamj = {
	"nes_batmavidgamj", "nes_batmavidgam", NULL, NULL, "1989",
	"Batman - The Video Game (Japan)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_batmavidgamjRomInfo, nes_batmavidgamjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_batmavidgamRomDesc[] = {
	{ "Batman - The Video Game (USA).nes",          262160, 0x395569ec, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_batmavidgam)
STD_ROM_FN(nes_batmavidgam)

struct BurnDriver BurnDrvnes_batmavidgam = {
	"nes_batmavidgam", NULL, NULL, NULL, "1990",
	"Batman - The Video Game (USA)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_batmavidgamRomInfo, nes_batmavidgamRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_batmanreturnsRomDesc[] = {
	{ "Batman Returns (USA).nes",          393232, 0xe625e398, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_batmanreturns)
STD_ROM_FN(nes_batmanreturns)

struct BurnDriver BurnDrvnes_batmanreturns = {
	"nes_batmanreturns", NULL, NULL, NULL, "1993",
	"Batman Returns (USA)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_batmanreturnsRomInfo, nes_batmanreturnsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Batsu & Terii (Japan)
static struct BurnRomInfo nes_batsuteriiRomDesc[] = {
	{ "Batsu & Terii (Japan).nes",          131088, 0xca80fa58, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_batsuterii)
STD_ROM_FN(nes_batsuterii)

struct BurnDriver BurnDrvnes_batsuterii = {
	"nes_batsuterii", NULL, NULL, NULL, "1987",
	"Batsu & Terii (Japan)\0", NULL, "Use", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_batsuteriiRomInfo, nes_batsuteriiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Battle Baseball (Japan)
static struct BurnRomInfo nes_battlebaseballRomDesc[] = {
	{ "Battle Baseball (Japan).nes",          524304, 0x8b65f724, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_battlebaseball)
STD_ROM_FN(nes_battlebaseball)

struct BurnDriver BurnDrvnes_battlebaseball = {
	"nes_battlebaseball", NULL, NULL, NULL, "1989?",
	"Battle Baseball (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_battlebaseballRomInfo, nes_battlebaseballRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Battle Chess (USA)
static struct BurnRomInfo nes_battlechessRomDesc[] = {
	{ "Battle Chess (USA).nes",          262160, 0x7dc49898, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_battlechess)
STD_ROM_FN(nes_battlechess)

struct BurnDriver BurnDrvnes_battlechess = {
	"nes_battlechess", NULL, NULL, NULL, "1990",
	"Battle Chess (USA)\0", NULL, "Data East", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_STRATEGY | GBF_BOARD, 0,
	NESGetZipName, nes_battlechessRomInfo, nes_battlechessRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Battle Formula (Japan)
static struct BurnRomInfo nes_battleformulaRomDesc[] = {
	{ "Battle Formula (Japan).nes",          262160, 0xf6454be1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_battleformula)
STD_ROM_FN(nes_battleformula)

struct BurnDriver BurnDrvnes_battleformula = {
	"nes_battleformula", NULL, NULL, NULL, "1991",
	"Battle Formula (Japan)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_battleformulaRomInfo, nes_battleformulaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Battle of Olympus, The (USA)
static struct BurnRomInfo nes_battlolyRomDesc[] = {
	{ "Battle of Olympus, The (USA).nes",          131088, 0xb99394c3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_battloly)
STD_ROM_FN(nes_battloly)

struct BurnDriver BurnDrvnes_battloly = {
	"nes_battloly", NULL, NULL, NULL, "1989",
	"Battle of Olympus, The (USA)\0", NULL, "Broderbund", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_battlolyRomInfo, nes_battlolyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Battle Tank (USA)
static struct BurnRomInfo nes_battletankRomDesc[] = {
	{ "Battle Tank (USA).nes",          65552, 0x49c9ff12, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_battletank)
STD_ROM_FN(nes_battletank)

struct BurnDriver BurnDrvnes_battletank = {
	"nes_battletank", NULL, NULL, NULL, "1990",
	"Battle Tank (USA)\0", "Garry Kitchen's Battletank", "Absolute", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SIM, 0,
	NESGetZipName, nes_battletankRomInfo, nes_battletankRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Battle City (Japan)
static struct BurnRomInfo nes_battlecityRomDesc[] = {
	{ "BattleCity (Japan).nes",          24592, 0xf599a07e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_battlecity)
STD_ROM_FN(nes_battlecity)

struct BurnDriver BurnDrvnes_battlecity = {
	"nes_battlecity", NULL, NULL, NULL, "1985",
	"Battle City (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_MAZE | GBF_SHOOT, 0,
	NESGetZipName, nes_battlecityRomInfo, nes_battlecityRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tank H 1990 (YS Hack)
static struct BurnRomInfo nes_tankh1990RomDesc[] = {
	{ "Tank H 1990 (YS).nes",          40976, 0x86d9aa5d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tankh1990)
STD_ROM_FN(nes_tankh1990)

struct BurnDriver BurnDrvnes_tankh1990 = {
	"nes_tankh1990", "nes_battlecity", NULL, NULL, "1990",
	"Tank H 1990 (YS Hack)\0", NULL, "YS", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_MAZE | GBF_SHOOT, 0,
	NESGetZipName, nes_tankh1990RomInfo, nes_tankh1990RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tank H 1990 (bedmoon Hack)
static struct BurnRomInfo nes_tankh1990bmRomDesc[] = {
	{ "Tank H 1990bm (bedmoon).nes",          40976, 0x3e7577ce, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tankh1990bm)
STD_ROM_FN(nes_tankh1990bm)

struct BurnDriver BurnDrvnes_tankh1990bm = {
	"nes_tankh1990bm", "nes_battlecity", NULL, NULL, "2023",
	"Tank H 1990 (bedmoon Hack)\0", NULL, "bedmoon", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_MAZE | GBF_SHOOT, 0,
	NESGetZipName, nes_tankh1990bmRomInfo, nes_tankh1990bmRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Binary City (GlobalHack)
// http://www.romhacking.net/hacks/569/
static struct BurnRomInfo nes_binarycityRomDesc[] = {
	{ "Binary City GlobalHack (2009)(AnS).nes",          40976, 0x84f56a94, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_binarycity)
STD_ROM_FN(nes_binarycity)

struct BurnDriver BurnDrvnes_binarycity = {
	"nes_binarycity", "nes_battlecity", NULL, NULL, "2009",
	"Binary City (GlobalHack)\0", NULL, "AnS", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PUZZLE | GBF_SHOOT, 0,
	NESGetZipName, nes_binarycityRomInfo, nes_binarycityRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Battleship (USA)
static struct BurnRomInfo nes_battleshipRomDesc[] = {
	{ "Battleship (USA).nes",          65552, 0x89d3bdbc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_battleship)
STD_ROM_FN(nes_battleship)

struct BurnDriver BurnDrvnes_battleship = {
	"nes_battleship", NULL, NULL, NULL, "1993",
	"Battleship (USA)\0", NULL, "Mindscape", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_STRATEGY | GBF_BOARD, 0,
	NESGetZipName, nes_battleshipRomInfo, nes_battleshipRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Battletoads (USA)
static struct BurnRomInfo nes_battletoadsRomDesc[] = {
	{ "Battletoads (USA).nes",          262160, 0xba9164e7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_battletoads)
STD_ROM_FN(nes_battletoads)

struct BurnDriver BurnDrvnes_battletoads = {
	"nes_battletoads", NULL, NULL, NULL, "1991",
	"Battletoads (USA)\0", NULL, "Tradewest", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_battletoadsRomInfo, nes_battletoadsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Battletoads-Double Dragon (USA)
static struct BurnRomInfo nes_battldoudraRomDesc[] = {
	{ "Battletoads-Double Dragon (USA).nes",          262160, 0x53b02f3d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_battldoudra)
STD_ROM_FN(nes_battldoudra)

struct BurnDriver BurnDrvnes_battldoudra = {
	"nes_battldoudra", NULL, NULL, NULL, "1993",
	"Battletoads-Double Dragon (USA)\0", NULL, "Tradewest", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_battldoudraRomInfo, nes_battldoudraRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Beauty and the Beast (Euro)
static struct BurnRomInfo nes_beautandbeaRomDesc[] = {
	{ "Beauty and the Beast (Europe).nes",          393232, 0xe08a5881, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_beautandbea)
STD_ROM_FN(nes_beautandbea)

struct BurnDriver BurnDrvnes_beautandbea = {
	"nes_beautandbea", NULL, NULL, NULL, "1989?",
	"Beauty and the Beast (Euro)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_beautandbeaRomInfo, nes_beautandbeaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL, SCREEN_WIDTH, SCREEN_HEIGHT_PAL
};

// Bee 52 (USA) (Unl)
static struct BurnRomInfo nes_bee52RomDesc[] = {
	{ "Bee 52 (USA) (Unl).nes",          65552, 0x77a8486f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bee52)
STD_ROM_FN(nes_bee52)

struct BurnDriver BurnDrvnes_bee52 = {
	"nes_bee52", NULL, NULL, NULL, "1992",
	"Bee 52 (USA) (Unl)\0", NULL, "Camerica", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_bee52RomInfo, nes_bee52RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Beetlejuice (USA)
static struct BurnRomInfo nes_beetlejuiceRomDesc[] = {
	{ "Beetlejuice (USA).nes",          131088, 0x1b2bad13, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_beetlejuice)
STD_ROM_FN(nes_beetlejuice)

struct BurnDriver BurnDrvnes_beetlejuice = {
	"nes_beetlejuice", NULL, NULL, NULL, "1991",
	"Beetlejuice (USA)\0", NULL, "Ljn", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_beetlejuiceRomInfo, nes_beetlejuiceRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bible Adventures (Unl)
static struct BurnRomInfo nes_bibleadventuresRomDesc[] = {
	{ "Bible Adventures (Unl).nes",          131088, 0x5eb290af, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bibleadventures)
STD_ROM_FN(nes_bibleadventures)

struct BurnDriver BurnDrvnes_bibleadventures = {
	"nes_bibleadventures", NULL, NULL, NULL, "1991",
	"Bible Adventures (Unl)\0", NULL, "Wisdom Tree", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_bibleadventuresRomInfo, nes_bibleadventuresRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bible Buffet (Unl)
static struct BurnRomInfo nes_biblebuffetRomDesc[] = {
	{ "Bible Buffet (Unl).nes",          262160, 0xdbbd1de9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_biblebuffet)
STD_ROM_FN(nes_biblebuffet)

struct BurnDriver BurnDrvnes_biblebuffet = {
	"nes_biblebuffet", NULL, NULL, NULL, "1993",
	"Bible Buffet (Unl)\0", NULL, "Wisdom Tree", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_ACTION | GBF_PUZZLE, 0,
	NESGetZipName, nes_biblebuffetRomInfo, nes_biblebuffetRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Big Nose Freaks Out (USA)
static struct BurnRomInfo nes_bignosfreoutRomDesc[] = {
	{ "Big Nose Freaks Out (USA).nes",          262160, 0xad16f6c7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bignosfreout)
STD_ROM_FN(nes_bignosfreout)

struct BurnDriver BurnDrvnes_bignosfreout = {
	"nes_bignosfreout", NULL, NULL, NULL, "1992",
	"Big Nose Freaks Out (USA)\0", NULL, "Camerica", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_bignosfreoutRomInfo, nes_bignosfreoutRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Big Nose the Caveman (USA)
static struct BurnRomInfo nes_bignoscavRomDesc[] = {
	{ "Big Nose the Caveman (USA).nes",          262160, 0xdcdf053f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bignoscav)
STD_ROM_FN(nes_bignoscav)

struct BurnDriver BurnDrvnes_bignoscav = {
	"nes_bignoscav", NULL, NULL, NULL, "1991",
	"Big Nose the Caveman (USA)\0", NULL, "Camerica", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_bignoscavRomInfo, nes_bignoscavRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bigfoot (USA)
static struct BurnRomInfo nes_bigfootRomDesc[] = {
	{ "Bigfoot (USA).nes",          262160, 0xa99d45a4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bigfoot)
STD_ROM_FN(nes_bigfoot)

struct BurnDriver BurnDrvnes_bigfoot = {
	"nes_bigfoot", NULL, NULL, NULL, "1990",
	"Bigfoot (USA)\0", NULL, "Acclaim", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_bigfootRomInfo, nes_bigfootRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bill & Ted's Excellent Video Game Adventure (USA)
static struct BurnRomInfo nes_billtedsexcvigaadRomDesc[] = {
	{ "Bill & Ted's Excellent Video Game Adventure (USA).nes",          262160, 0xa905cc12, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_billtedsexcvigaad)
STD_ROM_FN(nes_billtedsexcvigaad)

struct BurnDriver BurnDrvnes_billtedsexcvigaad = {
	"nes_billtedsexcvigaad", NULL, NULL, NULL, "1991",
	"Bill & Ted's Excellent Video Game Adventure (USA)\0", NULL, "Ljn", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_billtedsexcvigaadRomInfo, nes_billtedsexcvigaadRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Binary Land (Japan)
static struct BurnRomInfo nes_binarylandRomDesc[] = {
	{ "Binary Land (Japan).nes",          24592, 0x7e68abab, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_binaryland)
STD_ROM_FN(nes_binaryland)

struct BurnDriver BurnDrvnes_binaryland = {
	"nes_binaryland", NULL, NULL, NULL, "1985",
	"Binary Land (Japan)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION | GBF_PUZZLE, 0,
	NESGetZipName, nes_binarylandRomInfo, nes_binarylandRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bio Force Ape (Japan) (English) (Prototype)
static struct BurnRomInfo nes_bioforceapeRomDesc[] = {
	{ "Bio Force Ape (Japan) (En) (Proto).nes",          262160, 0x339d5a6d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bioforceape)
STD_ROM_FN(nes_bioforceape)

struct BurnDriver BurnDrvnes_bioforceape = {
	"nes_bioforceape", NULL, NULL, NULL, "1991",
	"Bio Force Ape (Japan) (English) (Prototype)\0", NULL, "Seta", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_PROTOTYPE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_bioforceapeRomInfo, nes_bioforceapeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bio Miracle Bokutte Upa (Japan)
static struct BurnRomInfo nes_biomirbokupajRomDesc[] = {
	{ "Bio Miracle Bokutte Upa (Japan).nes",          262160, 0xe50ad737, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_biomirbokupaj)
STD_ROM_FN(nes_biomirbokupaj)

struct BurnDriver BurnDrvnes_biomirbokupaj = {
	"nes_biomirbokupaj", "nes_biomirbokupa", NULL, NULL, "1993",
	"Bio Miracle Bokutte Upa (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_biomirbokupajRomInfo, nes_biomirbokupajRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bio Miracle Baby Upa!! (Hack, English)
static struct BurnRomInfo nes_biomirbokupaRomDesc[] = {
	{ "Bio Miracle Bokutte Upa T-Eng (2013)(Vice Translations).nes",          262160, 0x31a8ed51, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_biomirbokupa)
STD_ROM_FN(nes_biomirbokupa)

struct BurnDriver BurnDrvnes_biomirbokupa = {
	"nes_biomirbokupa", NULL, NULL, NULL, "2013",
	"Bio Miracle Baby Upa!! (Hack, English)\0", NULL, "Vice Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_biomirbokupaRomInfo, nes_biomirbokupaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bio Senshi Dan - Increaser Tono Tatakai (Japan)
static struct BurnRomInfo nes_biosendanRomDesc[] = {
	{ "Bio Senshi Dan - Increaser Tono Tatakai (Japan).nes",          262160, 0x5b2d91d0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_biosendan)
STD_ROM_FN(nes_biosendan)

struct BurnDriver BurnDrvnes_biosendan = {
	"nes_biosendan", NULL, NULL, NULL, "1987",
	"Bio Senshi Dan - Increaser Tono Tatakai (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_biosendanRomInfo, nes_biosendanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bionic Commando (USA)
static struct BurnRomInfo nes_bioniccommandoRomDesc[] = {
	{ "Bionic Commando (USA).nes",          262160, 0x83be000c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bioniccommando)
STD_ROM_FN(nes_bioniccommando)

struct BurnDriver BurnDrvnes_bioniccommando = {
	"nes_bioniccommando", NULL, NULL, NULL, "1988",
	"Bionic Commando (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_bioniccommandoRomInfo, nes_bioniccommandoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bionic Commando - Return of Hitler (Hack)
static struct BurnRomInfo nes_bionicomRomDesc[] = {
	{ "Bionic Commando - Return of Hitler (Hack).nes",          262160, 0x519a3005, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bionicom)
STD_ROM_FN(nes_bionicom)

struct BurnDriver BurnDrvnes_bionicom = {
	"nes_bionicom", "nes_bioniccommando", NULL, NULL, "2006",
	"Bionic Commando - Return of Hitler (Hack)\0", NULL, "Chris M. Covell", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_bionicomRomInfo, nes_bionicomRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bird Week (Japan)
static struct BurnRomInfo nes_birdweekRomDesc[] = {
	{ "Bird Week (Japan).nes",          24592, 0xd9b9b3ab, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_birdweek)
STD_ROM_FN(nes_birdweek)

struct BurnDriver BurnDrvnes_birdweek = {
	"nes_birdweek", NULL, NULL, NULL, "1986",
	"Bird Week (Japan)\0", NULL, "Toemiland", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_birdweekRomInfo, nes_birdweekRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Black Bass 2, The (Japan)
static struct BurnRomInfo nes_blackbas2jRomDesc[] = {
	{ "Black Bass 2, The (Japan).nes",          131088, 0x5a514495, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_blackbas2j)
STD_ROM_FN(nes_blackbas2j)

struct BurnDriver BurnDrvnes_blackbas2j = {
	"nes_blackbas2j", "nes_blackbas2", NULL, NULL, "1988",
	"Black Bass 2, The (Japan)\0", NULL, "HOT-B", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_blackbas2jRomInfo, nes_blackbas2jRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Black Bass 2, The (USA)
static struct BurnRomInfo nes_blackbas2RomDesc[] = {
	{ "Black Bass 2, The (USA).nes",          131088, 0x2e069e5f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_blackbas2)
STD_ROM_FN(nes_blackbas2)

struct BurnDriver BurnDrvnes_blackbas2 = {
	"nes_blackbas2", NULL, NULL, NULL, "1989",
	"Black Bass 2, The (USA)\0", NULL, "HOT-B", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_blackbas2RomInfo, nes_blackbas2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Black Bass, The (Japan)
static struct BurnRomInfo nes_blackbasstheRomDesc[] = {
	{ "Black Bass, The (Japan).nes",          131088, 0x73bccc8b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_blackbassthe)
STD_ROM_FN(nes_blackbassthe)

struct BurnDriver BurnDrvnes_blackbassthe = {
	"nes_blackbassthe", NULL, NULL, NULL, "1987",
	"Black Bass, The (Japan)\0", NULL, "HOT-B", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_blackbasstheRomInfo, nes_blackbasstheRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Blackjack (USA)
static struct BurnRomInfo nes_blackjackRomDesc[] = {
	{ "Blackjack (U)(1992)(AVE).nes",          65552, 0x00ac0fac, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_blackjack)
STD_ROM_FN(nes_blackjack)

struct BurnDriver BurnDrvnes_blackjack = {
	"nes_blackjack", NULL, NULL, NULL, "1992",
	"Blackjack (USA)\0", NULL, "American Video Entertainment", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_CARD, 0,
	NESGetZipName, nes_blackjackRomInfo, nes_blackjackRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Blades of Steel (USA)
static struct BurnRomInfo nes_bladesofsteelRomDesc[] = {
	{ "Blades of Steel (USA).nes",          131088, 0xb9bcf910, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bladesofsteel)
STD_ROM_FN(nes_bladesofsteel)

struct BurnDriver BurnDrvnes_bladesofsteel = {
	"nes_bladesofsteel", NULL, NULL, NULL, "1988",
	"Blades of Steel (USA)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_bladesofsteelRomInfo, nes_bladesofsteelRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Blaster Master (USA)
static struct BurnRomInfo nes_blastermasterRomDesc[] = {
	{ "Blaster Master (U)(1988)(Sunsoft).nes",          262160, 0x52bcf64a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_blastermaster)
STD_ROM_FN(nes_blastermaster)

struct BurnDriver BurnDrvnes_blastermaster = {
	"nes_blastermaster", NULL, NULL, NULL, "1988",
	"Blaster Master (USA)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_blastermasterRomInfo, nes_blastermasterRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Block Out (USA)
static struct BurnRomInfo nes_blockoutRomDesc[] = {
	{ "Block Out (USA).nes",          131088, 0xdeff01f6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_blockout)
STD_ROM_FN(nes_blockout)

struct BurnDriver BurnDrvnes_blockout = {
	"nes_blockout", NULL, NULL, NULL, "1990",
	"Block Out (USA)\0", NULL, "California Dreams / Technos", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_blockoutRomInfo, nes_blockoutRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Blodia Land - Puzzle Quest (Japan)
static struct BurnRomInfo nes_blodilanRomDesc[] = {
	{ "Blodia Land - Puzzle Quest (Japan).nes",          262160, 0x6d3d0c1e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_blodilan)
STD_ROM_FN(nes_blodilan)

struct BurnDriver BurnDrvnes_blodilan = {
	"nes_blodilan", NULL, NULL, NULL, "1990",
	"Blodia Land - Puzzle Quest (Japan)\0", NULL, "Tonkin House", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_blodilanRomInfo, nes_blodilanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bloody Warriors - Shan-Go no Gyakushuu (Japan)
static struct BurnRomInfo nes_bloodwarjRomDesc[] = {
	{ "Bloody Warriors - Shan-Go no Gyakushuu (Japan).nes",          262160, 0x5cb5676f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bloodwarj)
STD_ROM_FN(nes_bloodwarj)

struct BurnDriver BurnDrvnes_bloodwarj = {
	"nes_bloodwarj", "nes_bloodwar", NULL, NULL, "1990",
	"Bloody Warriors - Shan-Go no Gyakushuu (Japan)\0", NULL, "Toei Animation", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_bloodwarjRomInfo, nes_bloodwarjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bloody Warriors - Shan-Go no Gyakushuu (Hack, English)
static struct BurnRomInfo nes_bloodwarRomDesc[] = {
	{ "Bloody Warriors - Shan-Go no Gyakushuu (T-Eng).nes",          262160, 0xc06584e5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bloodwar)
STD_ROM_FN(nes_bloodwar)

struct BurnDriver BurnDrvnes_bloodwar = {
	"nes_bloodwar", NULL, NULL, NULL, "2021",
	"Bloody Warriors - Shan-Go no Gyakushuu (Hack, English)\0", NULL, "BlackPaladin", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_bloodwarRomInfo, nes_bloodwarRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Blue Marlin, The (USA)
static struct BurnRomInfo nes_bluemarlintheRomDesc[] = {
	{ "Blue Marlin, The (USA).nes",          262160, 0xd9e8e747, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bluemarlinthe)
STD_ROM_FN(nes_bluemarlinthe)

struct BurnDriver BurnDrvnes_bluemarlinthe = {
	"nes_bluemarlinthe", NULL, NULL, NULL, "1992",
	"Blue Marlin, The (USA)\0", NULL, "HOT-B", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_bluemarlintheRomInfo, nes_bluemarlintheRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Blue Shadow (Euro)
static struct BurnRomInfo nes_blueshadowRomDesc[] = {
	{ "Blue Shadow (Europe).nes",          262160, 0xe3b889d9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_blueshadow)
STD_ROM_FN(nes_blueshadow)

struct BurnDriver BurnDrvnes_blueshadow = {
	"nes_blueshadow", "nes_shadonin", NULL, NULL, "1991",
	"Blue Shadow (Euro)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, nes_blueshadowRomInfo, nes_blueshadowRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL, SCREEN_WIDTH, SCREEN_HEIGHT_PAL
};

// Blues Brothers, The (USA)
static struct BurnRomInfo nes_bluesbroRomDesc[] = {
	{ "Blues Brothers, The (USA).nes",          131088, 0xac273c14, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bluesbro)
STD_ROM_FN(nes_bluesbro)

struct BurnDriver BurnDrvnes_bluesbro = {
	"nes_bluesbro", NULL, NULL, NULL, "1992",
	"Blues Brothers, The (USA)\0", NULL, "Titus", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_bluesbroRomInfo, nes_bluesbroRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bokosuka Wars (Japan)
static struct BurnRomInfo nes_bokosukawarsRomDesc[] = {
	{ "Bokosuka Wars (Japan).nes",          40976, 0x196afc68, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bokosukawars)
STD_ROM_FN(nes_bokosukawars)

struct BurnDriver BurnDrvnes_bokosukawars = {
	"nes_bokosukawars", NULL, NULL, NULL, "1985",
	"Bokosuka Wars (Japan)\0", NULL, "ASCII Corp.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_bokosukawarsRomInfo, nes_bokosukawarsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bomberman (USA)
static struct BurnRomInfo nes_bombermanRomDesc[] = {
	{ "Bomberman (USA).nes",          24592, 0xb9804046, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bomberman)
STD_ROM_FN(nes_bomberman)

struct BurnDriver BurnDrvnes_bomberman = {
	"nes_bomberman", NULL, NULL, NULL, "1989",
	"Bomberman (USA)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_MAZE | GBF_ACTION, 0,
	NESGetZipName, nes_bombermanRomInfo, nes_bombermanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bomberman II (USA)
static struct BurnRomInfo nes_bombermaniiRomDesc[] = {
	{ "Bomberman II (USA).nes",          131088, 0xcc7bcfeb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bombermanii)
STD_ROM_FN(nes_bombermanii)

struct BurnDriver BurnDrvnes_bombermanii = {
	"nes_bombermanii", NULL, NULL, NULL, "1993",
	"Bomberman II (USA)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_MAZE | GBF_ACTION, 0,
	NESGetZipName, nes_bombermaniiRomInfo, nes_bombermaniiRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bonk's Adventure (USA)
static struct BurnRomInfo nes_bonksadventureRomDesc[] = {
	{ "Bonk's Adventure (USA).nes",          393232, 0x6b53d59a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bonksadventure)
STD_ROM_FN(nes_bonksadventure)

struct BurnDriver BurnDrvnes_bonksadventure = {
	"nes_bonksadventure", NULL, NULL, NULL, "1994",
	"Bonk's Adventure (USA)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_bonksadventureRomInfo, nes_bonksadventureRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Booby Kids (Japan)
static struct BurnRomInfo nes_boobykidsRomDesc[] = {
	{ "Booby Kids (Japan).nes",          131088, 0x828f23a8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_boobykids)
STD_ROM_FN(nes_boobykids)

struct BurnDriver BurnDrvnes_boobykids = {
	"nes_boobykids", NULL, NULL, NULL, "1987",
	"Booby Kids (Japan)\0", NULL, "Nichibutsu", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_boobykidsRomInfo, nes_boobykidsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Boulder Dash (USA)
static struct BurnRomInfo nes_boulderdashRomDesc[] = {
	{ "Boulder Dash (USA).nes",          65552, 0x008f1536, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_boulderdash)
STD_ROM_FN(nes_boulderdash)

struct BurnDriver BurnDrvnes_boulderdash = {
	"nes_boulderdash", NULL, NULL, NULL, "1990",
	"Boulder Dash (USA)\0", NULL, "JVC", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_MAZE, 0,
	NESGetZipName, nes_boulderdashRomInfo, nes_boulderdashRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bram Stoker's Dracula (USA)
static struct BurnRomInfo nes_bramstosdraRomDesc[] = {
	{ "Bram Stoker's Dracula (USA).nes",          262160, 0xf5321963, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bramstosdra)
STD_ROM_FN(nes_bramstosdra)

struct BurnDriver BurnDrvnes_bramstosdra = {
	"nes_bramstosdra", NULL, NULL, NULL, "1993",
	"Bram Stoker's Dracula (USA)\0", NULL, "Sony Imagesoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_bramstosdraRomInfo, nes_bramstosdraRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// BreakThru (USA)
static struct BurnRomInfo nes_breakthruRomDesc[] = {
	{ "BreakThru (USA).nes",          262160, 0xc85bf3e3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_breakthru)
STD_ROM_FN(nes_breakthru)

struct BurnDriver BurnDrvnes_breakthru = {
	"nes_breakthru", NULL, NULL, NULL, "1987",
	"BreakThru (USA)\0", NULL, "Data East", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_breakthruRomInfo, nes_breakthruRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bubble Bobble (USA)
static struct BurnRomInfo nes_bubblebobbleRomDesc[] = {
	{ "Bubble Bobble (USA).nes",          163856, 0xd3a91b41, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bubblebobble)
STD_ROM_FN(nes_bubblebobble)

struct BurnDriver BurnDrvnes_bubblebobble = {
	"nes_bubblebobble", NULL, NULL, NULL, "1988",
	"Bubble Bobble (USA)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_bubblebobbleRomInfo, nes_bubblebobbleRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bubble Bobble Part 2 (USA)
static struct BurnRomInfo nes_bubblbobpar2RomDesc[] = {
	{ "Bubble Bobble Part 2 (USA).nes",          262160, 0xca06cb60, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bubblbobpar2)
STD_ROM_FN(nes_bubblbobpar2)

struct BurnDriver BurnDrvnes_bubblbobpar2 = {
	"nes_bubblbobpar2", NULL, NULL, NULL, "1993",
	"Bubble Bobble Part 2 (USA)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_bubblbobpar2RomInfo, nes_bubblbobpar2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bucky O'Hare (USA)
static struct BurnRomInfo nes_buckyohareRomDesc[] = {
	{ "Bucky O'Hare (USA).nes",          262160, 0x3c9622d3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_buckyohare)
STD_ROM_FN(nes_buckyohare)

struct BurnDriver BurnDrvnes_buckyohare = {
	"nes_buckyohare", NULL, NULL, NULL, "1992",
	"Bucky O'Hare (USA)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_buckyohareRomInfo, nes_buckyohareRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Buggy Popper (Japan)
static struct BurnRomInfo nes_buggypopperRomDesc[] = {
	{ "Buggy Popper (Japan).nes",          65552, 0x46cc2d53, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_buggypopper)
STD_ROM_FN(nes_buggypopper)

struct BurnDriver BurnDrvnes_buggypopper = {
	"nes_buggypopper", "nes_bumpnjump", NULL, NULL, "1986",
	"Buggy Popper (Japan)\0", NULL, "Data East", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_buggypopperRomInfo, nes_buggypopperRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bugs Bunny Birthday Blowout, The (USA)
static struct BurnRomInfo nes_bugsbunbirbloRomDesc[] = {
	{ "Bugs Bunny Birthday Blowout, The (USA).nes",          262160, 0x38fdb7f4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bugsbunbirblo)
STD_ROM_FN(nes_bugsbunbirblo)

struct BurnDriver BurnDrvnes_bugsbunbirblo = {
	"nes_bugsbunbirblo", NULL, NULL, NULL, "1990",
	"Bugs Bunny Birthday Blowout, The (USA)\0", NULL, "Kemco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_bugsbunbirbloRomInfo, nes_bugsbunbirbloRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bugs Bunny Crazy Castle, The (USA)
static struct BurnRomInfo nes_bugsbuncracasRomDesc[] = {
	{ "Bugs Bunny Crazy Castle, The (USA).nes",          98320, 0xdb0c3656, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bugsbuncracas)
STD_ROM_FN(nes_bugsbuncracas)

struct BurnDriver BurnDrvnes_bugsbuncracas = {
	"nes_bugsbuncracas", NULL, NULL, NULL, "1989",
	"Bugs Bunny Crazy Castle, The (USA)\0", NULL, "Kemco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_bugsbuncracasRomInfo, nes_bugsbuncracasRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Bump'n'Jump (USA)
static struct BurnRomInfo nes_bumpnjumpRomDesc[] = {
	{ "Bump'n'Jump (USA).nes",          65552, 0x79bfe095, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_bumpnjump)
STD_ROM_FN(nes_bumpnjump)

struct BurnDriver BurnDrvnes_bumpnjump = {
	"nes_bumpnjump", NULL, NULL, NULL, "1988",
	"Bump'n'Jump (USA)\0", NULL, "Vic Tokai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_bumpnjumpRomInfo, nes_bumpnjumpRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Burai Fighter (Japan)
static struct BurnRomInfo nes_buraifighterjRomDesc[] = {
	{ "Burai Fighter (Japan).nes",          65552, 0x76af01af, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_buraifighterj)
STD_ROM_FN(nes_buraifighterj)

struct BurnDriver BurnDrvnes_buraifighterj = {
	"nes_buraifighterj", "nes_buraifighter", NULL, NULL, "1990",
	"Burai Fighter (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_buraifighterjRomInfo, nes_buraifighterjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Burai Fighter (USA)
static struct BurnRomInfo nes_buraifighterRomDesc[] = {
	{ "Burai Fighter (USA).nes",          65552, 0x519ae8f2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_buraifighter)
STD_ROM_FN(nes_buraifighter)

struct BurnDriver BurnDrvnes_buraifighter = {
	"nes_buraifighter", NULL, NULL, NULL, "1990",
	"Burai Fighter (USA)\0", NULL, "Taxan", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_buraifighterRomInfo, nes_buraifighterRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// BurgerTime (USA)
static struct BurnRomInfo nes_burgertimeRomDesc[] = {
	{ "BurgerTime (USA).nes",          24592, 0x516549f9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_burgertime)
STD_ROM_FN(nes_burgertime)

struct BurnDriver BurnDrvnes_burgertime = {
	"nes_burgertime", NULL, NULL, NULL, "1987",
	"BurgerTime (USA)\0", NULL, "Data East", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_burgertimeRomInfo, nes_burgertimeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Buzz & Waldog (USA) (Prototype)
static struct BurnRomInfo nes_buzzwaldogRomDesc[] = {
	{ "Buzz & Waldog (USA) (Proto) (Unl).nes",          262160, 0x1587bc5f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_buzzwaldog)
STD_ROM_FN(nes_buzzwaldog)

struct BurnDriver BurnDrvnes_buzzwaldog = {
	"nes_buzzwaldog", NULL, NULL, NULL, "1993",
	"Buzz & Waldog (USA) (Prototype)\0", NULL, "Inovation Tech.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_PROTOTYPE, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_buzzwaldogRomInfo, nes_buzzwaldogRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cabal (USA)
static struct BurnRomInfo nes_cabalRomDesc[] = {
	{ "Cabal (USA).nes",          131088, 0x4d5f2eb0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cabal)
STD_ROM_FN(nes_cabal)

struct BurnDriver BurnDrvnes_cabal = {
	"nes_cabal", NULL, NULL, NULL, "1990",
	"Cabal (USA)\0", NULL, "Milton Bradley", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_cabalRomInfo, nes_cabalRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Caesars Palace (USA)
static struct BurnRomInfo nes_cspalaceRomDesc[] = {
	{ "Caesars Palace (U)(1990)(Virgin Games).nes",          131088, 0xe814d0d1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cspalace)
STD_ROM_FN(nes_cspalace)

struct BurnDriver BurnDrvnes_cspalace = {
	"nes_cspalace", NULL, NULL, NULL, "1990",
	"Caesars Palace (USA)\0", NULL, "Virgin Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_CASINO, 0,
	NESGetZipName, nes_cspalaceRomInfo, nes_cspalaceRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// California Games (USA)
static struct BurnRomInfo nes_californiagamesRomDesc[] = {
	{ "California Games (USA).nes",          131088, 0x1c6f3036, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_californiagames)
STD_ROM_FN(nes_californiagames)

struct BurnDriver BurnDrvnes_californiagames = {
	"nes_californiagames", NULL, NULL, NULL, "1989",
	"California Games (USA)\0", NULL, "Milton Bradley", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_californiagamesRomInfo, nes_californiagamesRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_caltron6in1RomDesc[] = {
	{ "Caltron 6-in-1 (USA).nes",          393232, 0xf78e68db, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_caltron6in1)
STD_ROM_FN(nes_caltron6in1)

struct BurnDriver BurnDrvnes_caltron6in1 = {
	"nes_caltron6in1", NULL, NULL, NULL, "1992",
	"Caltron 6-in-1 (USA) (Unl)\0", NULL, "Caltron", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_caltron6in1RomInfo, nes_caltron6in1RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_caltron9in1RomDesc[] = {
	{ "Caltron 9-in-1 (USA).nes",          786448, 0x9c529e3b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_caltron9in1)
STD_ROM_FN(nes_caltron9in1)

struct BurnDriver BurnDrvnes_caltron9in1 = {
	"nes_caltron9in1", NULL, NULL, NULL, "1992",
	"Caltron 9-in-1 (USA) (Unl)\0", NULL, "Caltron", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_caltron9in1RomInfo, nes_caltron9in1RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_capcosgolmedch92RomDesc[] = {
	{ "Capcom's Gold Medal Challenge '92 (USA).nes",          262160, 0xa0f08ae1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_capcosgolmedch92)
STD_ROM_FN(nes_capcosgolmedch92)

struct BurnDriver BurnDrvnes_capcosgolmedch92 = {
	"nes_capcosgolmedch92", NULL, NULL, NULL, "1992",
	"Capcom's Gold Medal Challenge '92 (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 8, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_capcosgolmedch92RomInfo, nes_capcosgolmedch92RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_captaameandaveRomDesc[] = {
	{ "Captain America and the Avengers (USA).nes",          262160, 0x7254d53d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_captaameandave)
STD_ROM_FN(nes_captaameandave)

struct BurnDriver BurnDrvnes_captaameandave = {
	"nes_captaameandave", NULL, NULL, NULL, "1991",
	"Captain America and the Avengers (USA)\0", NULL, "Data East", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_captaameandaveRomInfo, nes_captaameandaveRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_captacomRomDesc[] = {
	{ "Captain Comic - The Adventure (USA).nes",          131088, 0x9357a157, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_captacom)
STD_ROM_FN(nes_captacom)

struct BurnDriver BurnDrvnes_captacom = {
	"nes_captacom", NULL, NULL, NULL, "1989",
	"Captain Comic - The Adventure (USA)\0", NULL, "Color Dreams", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_captacomRomInfo, nes_captacomRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_captainedRomDesc[] = {
	{ "Captain ED (Japan).nes",          262160, 0x6ebfe4be, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_captained)
STD_ROM_FN(nes_captained)

struct BurnDriver BurnDrvnes_captained = {
	"nes_captained", NULL, NULL, NULL, "1989",
	"Captain ED (Japan)\0", NULL, "CBS / Sony Group", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_captainedRomInfo, nes_captainedRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_captaplaandplaRomDesc[] = {
	{ "Captain Planet and the Planeteers (USA).nes",          262160, 0x21d34187, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_captaplaandpla)
STD_ROM_FN(nes_captaplaandpla)

struct BurnDriver BurnDrvnes_captaplaandpla = {
	"nes_captaplaandpla", NULL, NULL, NULL, "1991",
	"Captain Planet and the Planeteers (USA)\0", NULL, "Mindscape", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_HORSHOOT | GBF_PLATFORM, 0,
	NESGetZipName, nes_captaplaandplaRomInfo, nes_captaplaandplaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_captainsaverRomDesc[] = {
	{ "Captain Saver (Japan).nes",          262160, 0xfc97fc14, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_captainsaver)
STD_ROM_FN(nes_captainsaver)

struct BurnDriver BurnDrvnes_captainsaver = {
	"nes_captainsaver", "nes_powerblade2", NULL, NULL, "1992",
	"Captain Saver (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_captainsaverRomInfo, nes_captainsaverRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_captainsilverRomDesc[] = {
	{ "Captain Silver (Japan).nes",          262160, 0xa6b91bda, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_captainsilver)
STD_ROM_FN(nes_captainsilver)

struct BurnDriver BurnDrvnes_captainsilver = {
	"nes_captainsilver", NULL, NULL, NULL, "1988",
	"Captain Silver (Japan)\0", NULL, "Tokuma Shoten", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_captainsilverRomInfo, nes_captainsilverRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_captainskyhawkRomDesc[] = {
	{ "Captain Skyhawk (USA) (Rev A).nes",          131088, 0x1f7d0668, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_captainskyhawk)
STD_ROM_FN(nes_captainskyhawk)

struct BurnDriver BurnDrvnes_captainskyhawk = {
	"nes_captainskyhawk", NULL, NULL, NULL, "1990",
	"Captain Skyhawk (USA) (Rev A)\0", NULL, "Milton Bradley", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_captainskyhawkRomInfo, nes_captainskyhawkRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Captain Tsubasa (Japan)
static struct BurnRomInfo nes_captaintsubasaRomDesc[] = {
	{ "Captain Tsubasa (Japan).nes",          262160, 0x9e4207b3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_captaintsubasa)
STD_ROM_FN(nes_captaintsubasa)

struct BurnDriver BurnDrvnes_captaintsubasa = {
	"nes_captaintsubasa", "nes_tecmocup", NULL, NULL, "1988",
	"Captain Tsubasa (Japan)\0", NULL, "Tecmo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_SPORTSFOOTBALL | GBF_RPG, 0,
	NESGetZipName, nes_captaintsubasaRomInfo, nes_captaintsubasaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Captain Tsubasa Vol. II - Super Striker (Japan)
static struct BurnRomInfo nes_captatsuvoliijRomDesc[] = {
	{ "Captain Tsubasa Vol. II - Super Striker (Japan).nes",          393232, 0x14a366bb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_captatsuvoliij)
STD_ROM_FN(nes_captatsuvoliij)

struct BurnDriver BurnDrvnes_captatsuvoliij = {
	"nes_captatsuvoliij", "nes_captatsuvolii", NULL, NULL, "1990",
	"Captain Tsubasa Vol. II - Super Striker (Japan)\0", NULL, "Tecmo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_SPORTSFOOTBALL | GBF_RPG, 0,
	NESGetZipName, nes_captatsuvoliijRomInfo, nes_captatsuvoliijRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Captain Tsubasa Vol. II - Super Striker (Hack, English)
// https://www.romhacking.net/translations/1182/
static struct BurnRomInfo nes_captatsuvoliiRomDesc[] = {
	{ "Captain Tsubasa Vol. II - Super Striker (T-eng).nes",          393232, 0x465917f7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_captatsuvolii)
STD_ROM_FN(nes_captatsuvolii)

struct BurnDriver BurnDrvnes_captatsuvolii = {
	"nes_captatsuvolii", NULL, NULL, NULL, "2007",
	"Captain Tsubasa Vol. II - Super Striker (Hack, English)\0", NULL, "hayabusakun", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_SPORTSFOOTBALL | GBF_RPG, 0,
	NESGetZipName, nes_captatsuvoliiRomInfo, nes_captatsuvoliiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Casino Kid (USA)
static struct BurnRomInfo nes_casinokidRomDesc[] = {
	{ "Casino Kid (USA).nes",          131088, 0xc651e21a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_casinokid)
STD_ROM_FN(nes_casinokid)

struct BurnDriver BurnDrvnes_casinokid = {
	"nes_casinokid", NULL, NULL, NULL, "1989",
	"Casino Kid (USA)\0", NULL, "Sofel", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_CASINO, 0,
	NESGetZipName, nes_casinokidRomInfo, nes_casinokidRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Casino Kid 2 (USA)
static struct BurnRomInfo nes_casinokid2RomDesc[] = {
	{ "Casino Kid 2 (USA).nes",          131088, 0xb0de7b5f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_casinokid2)
STD_ROM_FN(nes_casinokid2)

struct BurnDriver BurnDrvnes_casinokid2 = {
	"nes_casinokid2", NULL, NULL, NULL, "1993",
	"Casino Kid 2 (USA)\0", NULL, "Sofel", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_CASINO, 0,
	NESGetZipName, nes_casinokid2RomInfo, nes_casinokid2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Castelian (USA)
static struct BurnRomInfo nes_castelianRomDesc[] = {
	{ "Castelian (USA).nes",          131088, 0x39ef1ad6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_castelian)
STD_ROM_FN(nes_castelian)

struct BurnDriver BurnDrvnes_castelian = {
	"nes_castelian", NULL, NULL, NULL, "1991",
	"Castelian (USA)\0", NULL, "Triffix", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_castelianRomInfo, nes_castelianRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Castle Excellent (Japan)
static struct BurnRomInfo nes_castleexcellentRomDesc[] = {
	{ "Castle Excellent (Japan).nes",          65552, 0x3089d649, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_castleexcellent)
STD_ROM_FN(nes_castleexcellent)

struct BurnDriver BurnDrvnes_castleexcellent = {
	"nes_castleexcellent", "nes_castlequest", NULL, NULL, "1986",
	"Castle Excellent (Japan)\0", NULL, "ASCII Corp.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_castleexcellentRomInfo, nes_castleexcellentRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Castle of Deceit (USA)
static struct BurnRomInfo nes_castleofdeceitRomDesc[] = {
	{ "Castle of Deceit (USA).nes",          131088, 0x02e20d38, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_castleofdeceit)
STD_ROM_FN(nes_castleofdeceit)

struct BurnDriver BurnDrvnes_castleofdeceit = {
	"nes_castleofdeceit", NULL, NULL, NULL, "1990",
	"Castle of Deceit (USA)\0", NULL, "Bunch Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_castleofdeceitRomInfo, nes_castleofdeceitRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Castle of Dragon (USA)
static struct BurnRomInfo nes_castleofdragonRomDesc[] = {
	{ "Castle of Dragon (USA).nes",          131088, 0x1c24cc9d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_castleofdragon)
STD_ROM_FN(nes_castleofdragon)

struct BurnDriver BurnDrvnes_castleofdragon = {
	"nes_castleofdragon", NULL, NULL, NULL, "1990",
	"Castle of Dragon (USA)\0", NULL, "Seta", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_castleofdragonRomInfo, nes_castleofdragonRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Castlequest (USA)
static struct BurnRomInfo nes_castlequestRomDesc[] = {
	{ "Castlequest (U)(1989)(Nexoft).nes",          65552, 0x5dbb7c78, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_castlequest)
STD_ROM_FN(nes_castlequest)

struct BurnDriver BurnDrvnes_castlequest = {
	"nes_castlequest", NULL, NULL, NULL, "1989",
	"Castlequest (USA)\0", NULL, "Nexoft - ASCII Corp.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_castlequestRomInfo, nes_castlequestRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Castle Quest (Hack, English v2.01)
// https://www.romhacking.net/translations/1500/
static struct BurnRomInfo nes_cstlquestRomDesc[] = {
	{ "Castle Quest T-Eng (2012)(Stardust Crusaders).nes",          262160, 0xfaabff04, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cstlquest)
STD_ROM_FN(nes_cstlquest)

struct BurnDriver BurnDrvnes_cstlquest = {
	"nes_cstlquest", NULL, NULL, NULL, "2012",
	"Castle Quest (Hack, English v2.01)\0", NULL, "Stardust Crusaders, Hubz", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_NES, GBF_STRATEGY | GBF_BOARD, 0,
	NESGetZipName, nes_cstlquestRomInfo, nes_cstlquestRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Castle Quest (Japan)
static struct BurnRomInfo nes_cstlquestjRomDesc[] = {
	{ "Castle Quest (J)(1990)(Hudson Soft).nes",          262160, 0x95dc4334, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cstlquestj)
STD_ROM_FN(nes_cstlquestj)

struct BurnDriver BurnDrvnes_cstlquestj = {
	"nes_cstlquestj", "nes_cstlquest", NULL, NULL, "1990",
	"Castle Quest (Japan)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_STRATEGY | GBF_BOARD, 0,
	NESGetZipName, nes_cstlquestjRomInfo, nes_cstlquestjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Castlevania (USA)
static struct BurnRomInfo nes_castlevaniaRomDesc[] = {
	{ "Castlevania (USA).nes",          131088, 0x856114c8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_castlevania)
STD_ROM_FN(nes_castlevania)

struct BurnDriver BurnDrvnes_castlevania = {
	"nes_castlevania", NULL, NULL, NULL, "1987",
	"Castlevania (USA)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_castlevaniaRomInfo, nes_castlevaniaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Castlevania Simplified (Hack)
// https://www.romhacking.net/hacks/1726/
static struct BurnRomInfo nes_castlsimRomDesc[] = {
	{ "Castlevania Simplified (2014)(Megafield64).nes",          131088, 0x451a0c75, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_castlsim)
STD_ROM_FN(nes_castlsim)

struct BurnDriver BurnDrvnes_castlsim = {
	"nes_castlsim", "nes_castlevania", NULL, NULL, "2014",
	"Castlevania Simplified (Hack)\0", NULL, "Megafield64", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_castlsimRomInfo, nes_castlsimRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Castlevania II - Simon's Quest (Hack, Re-translation + Map)
// https://www.romhacking.net/hacks/1032/
static struct BurnRomInfo nes_castliihRomDesc[] = {
	{ "Castlevania II - Simon's Quest (English Re-translation + Map)(2020)(Bisqwit).nes",          262160, 0x153143e9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_castliih)
STD_ROM_FN(nes_castliih)

struct BurnDriver BurnDrvnes_castliih = {
	"nes_castliih", "nes_castlii", NULL, NULL, "2020",
	"Castlevania II - Simon's Quest (Hack, Re-translation + Map)\0", NULL, "Bisqwit", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_RPG, 0,
	NESGetZipName, nes_castliihRomInfo, nes_castliihRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Castlevania II - Simon's Quest (USA)
static struct BurnRomInfo nes_castliiRomDesc[] = {
	{ "Castlevania II - Simon's Quest (USA).nes",          262160, 0xa9c2c503, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_castlii)
STD_ROM_FN(nes_castlii)

struct BurnDriver BurnDrvnes_castlii = {
	"nes_castlii", NULL, NULL, NULL, "1988",
	"Castlevania II - Simon's Quest (USA)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM | GBF_RPG, 0,
	NESGetZipName, nes_castliiRomInfo, nes_castliiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Castlevania III - Dracula's Curse (USA).nes
static struct BurnRomInfo nes_castliiiRomDesc[] = {
	{ "Castlevania III - Dracula's Curse (USA).nes",          393232, 0x7cc9c669, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_castliii)
STD_ROM_FN(nes_castliii)

struct BurnDriver BurnDrvnes_castliii = {
	"nes_castliii", NULL, NULL, NULL, "1990",
	"Castlevania III - Dracula's Curse (USA)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_castliiiRomInfo, nes_castliiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cat Ninden Teyandee (Japan)
static struct BurnRomInfo nes_catninteyjRomDesc[] = {
	{ "Cat Ninden Teyandee (Japan).nes",          262160, 0x6f1485ed, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_catninteyj)
STD_ROM_FN(nes_catninteyj)

struct BurnDriver BurnDrvnes_catninteyj = {
	"nes_catninteyj", "nes_catnintey", NULL, NULL, "1991",
	"Cat Ninden Teyandee (Japan)\0", NULL, "Tecmo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_catninteyjRomInfo, nes_catninteyjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cat Ninden Teyandee (Hack, English)
// https://www.romhacking.net/translations/1706/
static struct BurnRomInfo nes_catninteyRomDesc[] = {
	{ "Cat Ninden Teyandee (T-eng).nes",          393232, 0x60f29773, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_catnintey)
STD_ROM_FN(nes_catnintey)

struct BurnDriver BurnDrvnes_catnintey = {
	"nes_catnintey", NULL, NULL, NULL, "2012",
	"Cat Ninden Teyandee (Hack, English)\0", NULL, "Dark Mark", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_catninteyRomInfo, nes_catninteyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Chack'n Pop (Japan)
static struct BurnRomInfo nes_chacknpopRomDesc[] = {
	{ "Chack'n Pop (Japan).nes",          24592, 0xe9b39b87, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_chacknpop)
STD_ROM_FN(nes_chacknpop)

struct BurnDriver BurnDrvnes_chacknpop = {
	"nes_chacknpop", NULL, NULL, NULL, "1985",
	"Chack'n Pop (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_chacknpopRomInfo, nes_chacknpopRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Challenge of the Dragon (USA)
static struct BurnRomInfo nes_challdraRomDesc[] = {
	{ "Challenge of the Dragon (USA).nes",          131088, 0xe737a11f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_challdra)
STD_ROM_FN(nes_challdra)

struct BurnDriver BurnDrvnes_challdra = {
	"nes_challdra", NULL, NULL, NULL, "1990",
	"Challenge of the Dragon (USA)\0", NULL, "Color Dreams", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, nes_challdraRomInfo, nes_challdraRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Challenger (Japan)
static struct BurnRomInfo nes_challengerRomDesc[] = {
	{ "Challenger (Japan).nes",          40976, 0x94339dff, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_challenger)
STD_ROM_FN(nes_challenger)

struct BurnDriver BurnDrvnes_challenger = {
	"nes_challenger", NULL, NULL, NULL, "1985",
	"Challenger (Japan)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_challengerRomInfo, nes_challengerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Championship Bowling (USA)
static struct BurnRomInfo nes_champbowRomDesc[] = {
	{ "Championship Bowling (USA).nes",          65552, 0xa5e89b19, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_champbow)
STD_ROM_FN(nes_champbow)

struct BurnDriver BurnDrvnes_champbow = {
	"nes_champbow", NULL, NULL, NULL, "1989",
	"Championship Bowling (USA)\0", NULL, "Romstar", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_champbowRomInfo, nes_champbowRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Championship Lode Runner (Japan)
static struct BurnRomInfo nes_champlodrunRomDesc[] = {
	{ "Championship Lode Runner (Japan).nes",          24592, 0xcfa85f7c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_champlodrun)
STD_ROM_FN(nes_champlodrun)

struct BurnDriver BurnDrvnes_champlodrun = {
	"nes_champlodrun", NULL, NULL, NULL, "1985",
	"Championship Lode Runner (Japan)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_champlodrunRomInfo, nes_champlodrunRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Chaos World (Japan)
static struct BurnRomInfo nes_chaosworldjRomDesc[] = {
	{ "Chaos World (Japan).nes",          393232, 0xe2ae3e63, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_chaosworldj)
STD_ROM_FN(nes_chaosworldj)

struct BurnDriver BurnDrvnes_chaosworldj = {
	"nes_chaosworldj", "nes_chaosworld", NULL, NULL, "1991",
	"Chaos World (Japan)\0", NULL, "Natsume", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_chaosworldjRomInfo, nes_chaosworldjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Chaos World (Hack, English)
static struct BurnRomInfo nes_chaosworldRomDesc[] = {
	{ "Chaos World (T-eng).nes",          393232, 0xfbd2a0e0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_chaosworld)
STD_ROM_FN(nes_chaosworld)

struct BurnDriver BurnDrvnes_chaosworld = {
	"nes_chaosworld", NULL, NULL, NULL, "2001",
	"Chaos World (Hack, English)\0", NULL, "Aeon Genesis", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_chaosworldRomInfo, nes_chaosworldRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Chessmaster, The (USA)
static struct BurnRomInfo nes_chessmasterRomDesc[] = {
	{ "Chessmaster, The (U)(1989)(Software Toolworks).nes",          163856, 0x5acf2c6f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_chessmaster)
STD_ROM_FN(nes_chessmaster)

struct BurnDriver BurnDrvnes_chessmaster = {
	"nes_chessmaster", NULL, NULL, NULL, "1989",
	"Chessmaster, The (USA)\0", NULL, "Software Toolworks", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_STRATEGY | GBF_BOARD, 0,
	NESGetZipName, nes_chessmasterRomInfo, nes_chessmasterRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Chester Field - Ankoku Shin e no Chousen (Japan)
static struct BurnRomInfo nes_chestfieRomDesc[] = {
	{ "Chester Field - Ankoku Shin e no Chousen (Japan).nes",          131088, 0xa6f40bd1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_chestfie)
STD_ROM_FN(nes_chestfie)

struct BurnDriver BurnDrvnes_chestfie = {
	"nes_chestfie", NULL, NULL, NULL, "1987",
	"Chester Field - Ankoku Shin e no Chousen (Japan)\0", NULL, "Vic Tokai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_chestfieRomInfo, nes_chestfieRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Chiisana Obake - Acchi Socchi Kocchi (Japan)
static struct BurnRomInfo nes_chiisobajRomDesc[] = {
	{ "Chiisana Obake - Acchi Socchi Kocchi (Japan).nes",          262160, 0x305fa5d6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_chiisobaj)
STD_ROM_FN(nes_chiisobaj)

struct BurnDriver BurnDrvnes_chiisobaj = {
	"nes_chiisobaj", "nes_chiisoba", NULL, NULL, "1992",
	"Chiisana Obake - Acchi Socchi Kocchi (Japan)\0", NULL, "Vap", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ACTION | GBF_PUZZLE, 0,
	NESGetZipName, nes_chiisobajRomInfo, nes_chiisobajRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Chiisana Obake - Acchi Socchi Kocchi (Hack, English)
// https://www.romhacking.net/translations/888/
static struct BurnRomInfo nes_chiisobaRomDesc[] = {
	{ "Chiisana Obake - Acchi Socchi Kocchi (T-Eng).nes",          262160, 0x46dd3c86, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_chiisoba)
STD_ROM_FN(nes_chiisoba)

struct BurnDriver BurnDrvnes_chiisoba = {
	"nes_chiisoba", NULL, NULL, NULL, "2005",
	"Chiisana Obake - Acchi Socchi Kocchi (Hack, English)\0", NULL, "KingMike", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_ACTION | GBF_PUZZLE, 0,
	NESGetZipName, nes_chiisobaRomInfo, nes_chiisobaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Chiki Chiki Machine Mou Race (Japan)
static struct BurnRomInfo nes_chikichimacmouraRomDesc[] = {
	{ "Chiki Chiki Machine Mou Race (Japan).nes",          262160, 0xfda7b555, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_chikichimacmoura)
STD_ROM_FN(nes_chikichimacmoura)

struct BurnDriver BurnDrvnes_chikichimacmoura = {
	"nes_chikichimacmoura", "nes_wackyraces", NULL, NULL, "1991",
	"Chiki Chiki Machine Mou Race (Japan)\0", NULL, "Atlus", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_chikichimacmouraRomInfo, nes_chikichimacmouraRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Chiller (USA)
static struct BurnRomInfo nes_chillerRomDesc[] = {
	{ "Chiller (USA).nes",          65552, 0xe4e7539a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_chiller)
STD_ROM_FN(nes_chiller)

struct BurnDriver BurnDrvnes_chiller = {
	"nes_chiller", NULL, NULL, NULL, "1990",
	"Chiller (USA)\0", NULL, "AGCI", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_chillerRomInfo, nes_chillerRomName, NULL, NULL, NULL, NULL, NESZapperInputInfo, NESZapperDIPInfo,
	NESZapperInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Chip 'n Dale - Rescue Rangers (USA)
static struct BurnRomInfo nes_chipndalresraRomDesc[] = {
	{ "Chip 'n Dale - Rescue Rangers (USA).nes",          262160, 0x11da7e45, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_chipndalresra)
STD_ROM_FN(nes_chipndalresra)

struct BurnDriver BurnDrvnes_chipndalresra = {
	"nes_chipndalresra", NULL, NULL, NULL, "1990",
	"Chip 'n Dale - Rescue Rangers (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_chipndalresraRomInfo, nes_chipndalresraRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Chip 'n Dale - Rescue Rangers 2 (USA)
static struct BurnRomInfo nes_chipndalresra2RomDesc[] = {
	{ "Chip 'n Dale - Rescue Rangers 2 (USA).nes",          262160, 0x91e4a289, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_chipndalresra2)
STD_ROM_FN(nes_chipndalresra2)

struct BurnDriver BurnDrvnes_chipndalresra2 = {
	"nes_chipndalresra2", NULL, NULL, NULL, "1994",
	"Chip 'n Dale - Rescue Rangers 2 (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_chipndalresra2RomInfo, nes_chipndalresra2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Chitei Senkuu Vazolder (Japan)
static struct BurnRomInfo nes_chitesenvazRomDesc[] = {
	{ "Chitei Senkuu Vazolder (Japan).nes",          262160, 0xa5487ac2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_chitesenvaz)
STD_ROM_FN(nes_chitesenvaz)

struct BurnDriver BurnDrvnes_chitesenvaz = {
	"nes_chitesenvaz", NULL, NULL, NULL, "1989?",
	"Chitei Senkuu Vazolder (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_chitesenvazRomInfo, nes_chitesenvazRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Chiyonofuji no Ooichou (Japan)
static struct BurnRomInfo nes_chiyonoooiRomDesc[] = {
	{ "Chiyonofuji no Ooichou (Japan).nes",          262160, 0x2e2f83ee, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_chiyonoooi)
STD_ROM_FN(nes_chiyonoooi)

struct BurnDriver BurnDrvnes_chiyonoooi = {
	"nes_chiyonoooi", NULL, NULL, NULL, "1990",
	"Chiyonofuji no Ooichou (Japan)\0", NULL, "Face", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_chiyonoooiRomInfo, nes_chiyonoooiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Choplifter (Japan)
static struct BurnRomInfo nes_choplifterRomDesc[] = {
	{ "Choplifter (Japan).nes",          49168, 0x8bb9afa7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_choplifter)
STD_ROM_FN(nes_choplifter)

struct BurnDriver BurnDrvnes_choplifter = {
	"nes_choplifter", NULL, NULL, NULL, "1986",
	"Choplifter (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_choplifterRomInfo, nes_choplifterRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Choujikuu Yousai - Macross (Japan)
static struct BurnRomInfo nes_choujyouRomDesc[] = {
	{ "Choujikuu Yousai - Macross (Japan).nes",          24592, 0xa3ca24d2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_choujyou)
STD_ROM_FN(nes_choujyou)

struct BurnDriver BurnDrvnes_choujyou = {
	"nes_choujyou", NULL, NULL, NULL, "1985",
	"Choujikuu Yousai - Macross (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_choujyouRomInfo, nes_choujyouRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Choujin Sentai Jetman (Japan)
static struct BurnRomInfo nes_choujsenjetjRomDesc[] = {
	{ "Choujin Sentai Jetman (Japan).nes",          262160, 0xf899bf59, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_choujsenjetj)
STD_ROM_FN(nes_choujsenjetj)

struct BurnDriver BurnDrvnes_choujsenjetj = {
	"nes_choujsenjetj", "nes_choujsenjet", NULL, NULL, "1991",
	"Choujin Sentai Jetman (Japan)\0", NULL, "Angel Studio", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM | GBF_VSFIGHT, 0,
	NESGetZipName, nes_choujsenjetjRomInfo, nes_choujsenjetjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Choujin Sentai Jetman (Hack, English)
// https://www.romhacking.net/translations/4499/
static struct BurnRomInfo nes_choujsenjetRomDesc[] = {
	{ "Choujin Sentai Jetman T-Eng (2019)(chronix).nes",          262160, 0x7649c688, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_choujsenjet)
STD_ROM_FN(nes_choujsenjet)

struct BurnDriver BurnDrvnes_choujsenjet = {
	"nes_choujsenjet", NULL, NULL, NULL, "2019",
	"Choujin Sentai Jetman (Hack, English)\0", NULL, "chronix", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_VSFIGHT, 0,
	NESGetZipName, nes_choujsenjetRomInfo, nes_choujsenjetRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Choujinrou Senki Warwolf (Japan)
static struct BurnRomInfo nes_choujsenwarRomDesc[] = {
	{ "Choujinrou Senki Warwolf (Japan).nes",          262160, 0x58e8c244, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_choujsenwar)
STD_ROM_FN(nes_choujsenwar)

struct BurnDriver BurnDrvnes_choujsenwar = {
	"nes_choujsenwar", "nes_werew", NULL, NULL, "1991",
	"Choujinrou Senki Warwolf (Japan)\0", NULL, "Takara", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, nes_choujsenwarRomInfo, nes_choujsenwarRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Chubby Cherub (USA)
static struct BurnRomInfo nes_chubbycherubRomDesc[] = {
	{ "Chubby Cherub (USA).nes",          40976, 0x90f12ac8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_chubbycherub)
STD_ROM_FN(nes_chubbycherub)

struct BurnDriver BurnDrvnes_chubbycherub = {
	"nes_chubbycherub", NULL, NULL, NULL, "1986",
	"Chubby Cherub (USA)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_chubbycherubRomInfo, nes_chubbycherubRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Chuuka Taisen (Japan)
static struct BurnRomInfo nes_chuukataisenjRomDesc[] = {
	{ "Chuuka Taisen (Japan).nes",          262160, 0xe3beb057, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_chuukataisenj)
STD_ROM_FN(nes_chuukataisenj)

struct BurnDriver BurnDrvnes_chuukataisenj = {
	"nes_chuukataisenj", "nes_chuukataisen", NULL, NULL, "1989",
	"Chuuka Taisen (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_chuukataisenjRomInfo, nes_chuukataisenjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Chuuka Taisen - Cloud Master (Hack, English)
// https://www.romhacking.net/translations/1697/
static struct BurnRomInfo nes_chuukataisenRomDesc[] = {
	{ "Chuuka Taisen (T-Eng)(2012)(Stardust Crusaders).nes",          262160, 0x8cdbc48f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_chuukataisen)
STD_ROM_FN(nes_chuukataisen)

struct BurnDriver BurnDrvnes_chuukataisen = {
	"nes_chuukataisen", NULL, NULL, NULL, "2012",
	"Chuuka Taisen - Cloud Master (Hack, English)\0", NULL, "Stardust Crusaders", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_chuukataisenRomInfo, nes_chuukataisenRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Circus Caper (USA)
static struct BurnRomInfo nes_circuscaperRomDesc[] = {
	{ "Circus Caper (USA).nes",          262160, 0xbce1da2c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_circuscaper)
STD_ROM_FN(nes_circuscaper)

struct BurnDriver BurnDrvnes_circuscaper = {
	"nes_circuscaper", NULL, NULL, NULL, "1990",
	"Circus Caper (USA)\0", NULL, "Toho", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_circuscaperRomInfo, nes_circuscaperRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Circus Charlie (Japan)
static struct BurnRomInfo nes_circuscharlieRomDesc[] = {
	{ "Circus Charlie (Japan).nes",          24592, 0xda673c95, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_circuscharlie)
STD_ROM_FN(nes_circuscharlie)

struct BurnDriver BurnDrvnes_circuscharlie = {
	"nes_circuscharlie", NULL, NULL, NULL, "1986",
	"Circus Charlie (Japan)\0", NULL, "Soft Pro", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_circuscharlieRomInfo, nes_circuscharlieRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// City Connection (USA)
static struct BurnRomInfo nes_cityconnectionRomDesc[] = {
	{ "City Connection (USA).nes",          65552, 0xe1ad7ca8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cityconnection)
STD_ROM_FN(nes_cityconnection)

struct BurnDriver BurnDrvnes_cityconnection = {
	"nes_cityconnection", NULL, NULL, NULL, "1988",
	"City Connection (USA)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_cityconnectionRomInfo, nes_cityconnectionRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// CJ's Elephant Antics (USA) (Unl)
static struct BurnRomInfo nes_cjeleantRomDesc[] = {
	{ "CJ's Elephant Antics (1992)(Codemasters).nes",          65552, 0x875855f1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cjeleant)
STD_ROM_FN(nes_cjeleant)

struct BurnDriver BurnDrvnes_cjeleant = {
	"nes_cjeleant", NULL, NULL, NULL, "1992",
	"CJ's Elephant Antics (USA) (Unl)\0", NULL, "Camerica", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_cjeleantRomInfo, nes_cjeleantRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Clash at Demonhead (USA)
static struct BurnRomInfo nes_clashatdemRomDesc[] = {
	{ "Clash at Demonhead (USA).nes",          262160, 0xef1c8906, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_clashatdem)
STD_ROM_FN(nes_clashatdem)

struct BurnDriver BurnDrvnes_clashatdem = {
	"nes_clashatdem", NULL, NULL, NULL, "1990",
	"Clash at Demonhead (USA)\0", NULL, "Vic Tokai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_clashatdemRomInfo, nes_clashatdemRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cliffhanger (USA)
static struct BurnRomInfo nes_cliffhangerRomDesc[] = {
	{ "Cliffhanger (USA).nes",          262160, 0x7d51a6dc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cliffhanger)
STD_ROM_FN(nes_cliffhanger)

struct BurnDriver BurnDrvnes_cliffhanger = {
	"nes_cliffhanger", NULL, NULL, NULL, "1993",
	"Cliffhanger (USA)\0", NULL, "Sony Imagesoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_cliffhangerRomInfo, nes_cliffhangerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Clu Clu Land (World)
static struct BurnRomInfo nes_cluclulandRomDesc[] = {
	{ "Clu Clu Land (World).nes",          24592, 0xc36a135a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_clucluland)
STD_ROM_FN(nes_clucluland)

struct BurnDriver BurnDrvnes_clucluland = {
	"nes_clucluland", NULL, NULL, NULL, "1984",
	"Clu Clu Land (World)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_MAZE | GBF_ACTION, 0,
	NESGetZipName, nes_cluclulandRomInfo, nes_cluclulandRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cobra Command (USA)
static struct BurnRomInfo nes_cobracommandRomDesc[] = {
	{ "Cobra Command (USA).nes",          262160, 0x40c6e687, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cobracommand)
STD_ROM_FN(nes_cobracommand)

struct BurnDriver BurnDrvnes_cobracommand = {
	"nes_cobracommand", NULL, NULL, NULL, "1988",
	"Cobra Command (USA)\0", NULL, "Data East", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_cobracommandRomInfo, nes_cobracommandRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cobra Mission (Asia)
static struct BurnRomInfo nes_cobramissionRomDesc[] = {
	{ "Cobra Mission (Asia).nes",          131088, 0x0f6bc06c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cobramission)
STD_ROM_FN(nes_cobramission)

struct BurnDriver BurnDrvnes_cobramission = {
	"nes_cobramission", NULL, NULL, NULL, "1994",
	"Cobra Mission (Asia)\0", NULL, "Asder", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_cobramissionRomInfo, nes_cobramissionRomName, NULL, NULL, NULL, NULL, NESZapperInputInfo, NESZapperDIPInfo,
	NESZapperInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cobra Triangle (USA)
static struct BurnRomInfo nes_cobratriangleRomDesc[] = {
	{ "Cobra Triangle (USA).nes",          131088, 0x3802276d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cobratriangle)
STD_ROM_FN(nes_cobratriangle)

struct BurnDriver BurnDrvnes_cobratriangle = {
	"nes_cobratriangle", NULL, NULL, NULL, "1989",
	"Cobra Triangle (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RACING | GBF_SHOOT, 0,
	NESGetZipName, nes_cobratriangleRomInfo, nes_cobratriangleRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cocoron (Japan)
static struct BurnRomInfo nes_cocoronjRomDesc[] = {
	{ "Cocoron (Japan).nes",          262160, 0x1d6b80da, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cocoronj)
STD_ROM_FN(nes_cocoronj)

struct BurnDriver BurnDrvnes_cocoronj = {
	"nes_cocoronj", "nes_cocoron", NULL, NULL, "1991",
	"Cocoron (Japan)\0", NULL, "Takeru", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_cocoronjRomInfo, nes_cocoronjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cocoron (Hack, English)
static struct BurnRomInfo nes_cocoronRomDesc[] = {
	{ "Cocoron (T-eng).nes",          262160, 0xe486f7d3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cocoron)
STD_ROM_FN(nes_cocoron)

struct BurnDriver BurnDrvnes_cocoron = {
	"nes_cocoron", NULL, NULL, NULL, "1999",
	"Cocoron (Hack, English)\0", NULL, "Akujin, Dynamic-Designs", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_cocoronRomInfo, nes_cocoronRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Code Name - Viper (USA)
static struct BurnRomInfo nes_codenamRomDesc[] = {
	{ "Code Name - Viper (USA).nes",          262160, 0xc8a23081, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_codenam)
STD_ROM_FN(nes_codenam)

struct BurnDriver BurnDrvnes_codenam = {
	"nes_codenam", NULL, NULL, NULL, "1989",
	"Code Name - Viper (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_codenamRomInfo, nes_codenamRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Color A Dinosaur (USA)
static struct BurnRomInfo nes_coloradinosaurRomDesc[] = {
	{ "Color A Dinosaur (USA).nes",          131088, 0x322a6cca, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_coloradinosaur)
STD_ROM_FN(nes_coloradinosaur)

struct BurnDriver BurnDrvnes_coloradinosaur = {
	"nes_coloradinosaur", NULL, NULL, NULL, "1993",
	"Color A Dinosaur (USA)\0", NULL, "Virgin Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_coloradinosaurRomInfo, nes_coloradinosaurRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Commando (USA)
static struct BurnRomInfo nes_commandoRomDesc[] = {
	{ "Commando (USA).nes",          131088, 0x41492df6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_commando)
STD_ROM_FN(nes_commando)

struct BurnDriver BurnDrvnes_commando = {
	"nes_commando", NULL, NULL, NULL, "1986",
	"Commando (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_commandoRomInfo, nes_commandoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Conan (USA)
static struct BurnRomInfo nes_conanRomDesc[] = {
	{ "Conan (USA).nes",          131088, 0x05f76a57, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_conan)
STD_ROM_FN(nes_conan)

struct BurnDriver BurnDrvnes_conan = {
	"nes_conan", NULL, NULL, NULL, "1991",
	"Conan (USA)\0", NULL, "Mindscape", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_conanRomInfo, nes_conanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Conflict (USA)
static struct BurnRomInfo nes_conflictRomDesc[] = {
	{ "Conflict (USA).nes",          262160, 0x5f7c6229, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_conflict)
STD_ROM_FN(nes_conflict)

struct BurnDriver BurnDrvnes_conflict = {
	"nes_conflict", NULL, NULL, NULL, "1990",
	"Conflict (USA)\0", NULL, "Vic Tokai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_conflictRomInfo, nes_conflictRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Conquest of the Crystal Palace (USA)
static struct BurnRomInfo nes_conqucrypalRomDesc[] = {
	{ "Conquest of the Crystal Palace (USA).nes",          262160, 0x0a362909, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_conqucrypal)
STD_ROM_FN(nes_conqucrypal)

struct BurnDriver BurnDrvnes_conqucrypal = {
	"nes_conqucrypal", NULL, NULL, NULL, "1990",
	"Conquest of the Crystal Palace (USA)\0", NULL, "Asmik", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_conqucrypalRomInfo, nes_conqucrypalRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Contra (Japan)
static struct BurnRomInfo nes_contrajRomDesc[] = {
	{ "Contra (Japan).nes",          262160, 0x8a96a3c4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_contraj)
STD_ROM_FN(nes_contraj)

struct BurnDriver BurnDrvnes_contraj = {
	"nes_contraj", "nes_contra", NULL, NULL, "1988",
	"Contra (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_contrajRomInfo, nes_contrajRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Contra (Hack, English)
static struct BurnRomInfo nes_contratRomDesc[] = {
	{ "Contra (T-Eng).nes",          262160, 0xd93f2c45, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_contrat)
STD_ROM_FN(nes_contrat)

struct BurnDriver BurnDrvnes_contrat = {
	"nes_contrat", "nes_contra", NULL, NULL, "1998",
	"Contra (Hack, English)\0", NULL, "MadHacker", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_contratRomInfo, nes_contratRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Contra (USA)
static struct BurnRomInfo nes_contraRomDesc[] = {
	{ "Contra (USA).nes",          131088, 0xc50a8304, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_contra)
STD_ROM_FN(nes_contra)

struct BurnDriver BurnDrvnes_contra = {
	"nes_contra", NULL, NULL, NULL, "1988",
	"Contra (USA)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_contraRomInfo, nes_contraRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Contra - Red Falcon War (Hack)
static struct BurnRomInfo nes_contrredfalwarRomDesc[] = {
	{ "Contra - Red Falcon War (USA).nes",          262160, 0x59ef411a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_contrredfalwar)
STD_ROM_FN(nes_contrredfalwar)

struct BurnDriver BurnDrvnes_contrredfalwar = {
	"nes_contrredfalwar", "nes_contra", NULL, NULL, "2019",
	"Contra - Red Falcon War (Hack)\0", NULL, "Azstar", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_contrredfalwarRomInfo, nes_contrredfalwarRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Contra - Revenge of the Red Falcon (Hack)
static struct BurnRomInfo nes_contrrevredfalRomDesc[] = {
	{ "Contra - Revenge of the Red Falcon (USA).nes",          262160, 0xfa28193b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_contrrevredfal)
STD_ROM_FN(nes_contrrevredfal)

struct BurnDriver BurnDrvnes_contrrevredfal = {
	"nes_contrrevredfal", "nes_contra", NULL, NULL, "2016",
	"Contra - Revenge of the Red Falcon (Hack)\0", NULL, "Trax", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_contrrevredfalRomInfo, nes_contrrevredfalRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Contra - The Last Rebirth (China)
// Modified by Jing Jing Bu Xiang Wo / ¾²¾²²»ÏëÎÒ
// GOTVG 20221226
static struct BurnRomInfo nes_contracsRomDesc[] = {
	{ "contracs.nes",          541200, 0xe7e2ffa3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_contracs)
STD_ROM_FN(nes_contracs)

struct BurnDriver BurnDrvnes_contracs = {
	"nes_contracs", "nes_contra", NULL, NULL, "2022",
	"Contra - The Last Rebirth (China)\0", NULL, "Jing Jing Bu Xiang Wo", "Miscellaneous",
	L"Contra - The Last Rebirth\0\u9b42\u6597\u7f85 - \u6700\u540e\u7684\u91cd\u751f\0", NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_contracsRomInfo, nes_contracsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Contra - Demon Contra (China)
// Modified by Huan Tian / »ÃÌì
// GOTVG 20200406
static struct BurnRomInfo nes_contramdlRomDesc[] = {
	{ "contramdl.nes",          541200, 0x78e3d5a4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_contramdl)
STD_ROM_FN(nes_contramdl)

struct BurnDriver BurnDrvnes_contramdl = {
	"nes_contramdl", "nes_contra", NULL, NULL, "2020",
	"Contra - Demon Contra (China)\0", NULL, "Huan Tian", "Miscellaneous",
	L"Contra - Demon Contra\0\u9b42\u6597\u7f85 - \u9b54\u6597\u7f85\0", NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_contramdlRomInfo, nes_contramdlRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Contra Force (USA)
static struct BurnRomInfo nes_contraforceRomDesc[] = {
	{ "Contra Force (USA).nes",          262160, 0x83d69922, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_contraforce)
STD_ROM_FN(nes_contraforce)

struct BurnDriver BurnDrvnes_contraforce = {
	"nes_contraforce", NULL, NULL, NULL, "1992",
	"Contra Force (USA)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_contraforceRomInfo, nes_contraforceRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Contra Spirits (Unl)
static struct BurnRomInfo nes_contraspiritsRomDesc[] = {
	{ "Contra Spirits (Unl).nes",          524304, 0xcea432be, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_contraspirits)
STD_ROM_FN(nes_contraspirits)

struct BurnDriver BurnDrvnes_contraspirits = {
	"nes_contraspirits", NULL, NULL, NULL, "1996",
	"Contra Spirits (Unl)\0", NULL, "J.Y. Company", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_contraspiritsRomInfo, nes_contraspiritsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Contra Spirits (Hack, ending fixed)
// https://www.romhacking.net/hacks/7877/
static struct BurnRomInfo nes_contraspiritfixRomDesc[] = {
	{ "Contra Spirits (Hack, ending fixed)(2023)(the jabu).nes",          524304, 0xed96cb51, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_contraspiritfix)
STD_ROM_FN(nes_contraspiritfix)

struct BurnDriver BurnDrvnes_contraspiritfix = {
	"nes_contraspiritfix", "nes_contraspirits", NULL, NULL, "2023",
	"Contra Spirits (Hack, ending fixed)\0", NULL, "the jabu", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_contraspiritfixRomInfo, nes_contraspiritfixRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cool World (USA)
static struct BurnRomInfo nes_coolworldRomDesc[] = {
	{ "Cool World (USA).nes",          262160, 0xba898162, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_coolworld)
STD_ROM_FN(nes_coolworld)

struct BurnDriver BurnDrvnes_coolworld = {
	"nes_coolworld", NULL, NULL, NULL, "1993",
	"Cool World (USA)\0", NULL, "Ocean", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_coolworldRomInfo, nes_coolworldRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Corre Benny (Euro, Spain)
static struct BurnRomInfo nes_correbennyRomDesc[] = {
	{ "Corre Benny (Spain).nes",          65552, 0xc92325a0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_correbenny)
STD_ROM_FN(nes_correbenny)

struct BurnDriver BurnDrvnes_correbenny = {
	"nes_correbenny", NULL, NULL, NULL, "1992",
	"Corre Benny (Euro, Spain)\0", NULL, "Gluk Video", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_correbennyRomInfo, nes_correbennyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cosmic Epsilon (Japan)
static struct BurnRomInfo nes_cosmicepsilonRomDesc[] = {
	{ "Cosmic Epsilon (Japan).nes",          393232, 0x0357095e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cosmicepsilon)
STD_ROM_FN(nes_cosmicepsilon)

struct BurnDriver BurnDrvnes_cosmicepsilon = {
	"nes_cosmicepsilon", NULL, NULL, NULL, "1989",
	"Cosmic Epsilon (Japan)\0", NULL, "Asmik", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_cosmicepsilonRomInfo, nes_cosmicepsilonRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cosmic Wars (Hack, English v0.999)
// https://www.romhacking.net/translations/7287/
static struct BurnRomInfo nes_cosmwarsRomDesc[] = {
	{ "Cosmic Wars T-Eng v0.999 (2024)(popeyeotaku).nes",          262160, 0xb0247268, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cosmwars)
STD_ROM_FN(nes_cosmwars)

struct BurnDriver BurnDrvnes_cosmwars = {
	"nes_cosmwars", NULL, NULL, NULL, "2024",
	"Cosmic Wars (Hack, English v0.999)\0", NULL, "popeyeotaku", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_cosmwarsRomInfo, nes_cosmwarsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cosmic Wars (Japan)
static struct BurnRomInfo nes_cosmwarsjRomDesc[] = {
	{ "Cosmic Wars (Japan)(1989)(Konami).nes",          262160, 0xa309055c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cosmwarsj)
STD_ROM_FN(nes_cosmwarsj)

struct BurnDriver BurnDrvnes_cosmwarsj = {
	"nes_cosmwarsj", "nes_cosmwars", NULL, NULL, "1989",
	"Cosmic Wars (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_cosmwarsjRomInfo, nes_cosmwarsjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cosmo Genesis (Japan)
static struct BurnRomInfo nes_cosmogenesisRomDesc[] = {
	{ "Cosmo Genesis (Japan).nes",          65552, 0xd5c8ee20, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cosmogenesis)
STD_ROM_FN(nes_cosmogenesis)

struct BurnDriver BurnDrvnes_cosmogenesis = {
	"nes_cosmogenesis", "nes_starvoyager", NULL, NULL, "1986",
	"Cosmo Genesis (Japan)\0", NULL, "ASCII Corp.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_SIM | GBF_SHOOT, 0,
	NESGetZipName, nes_cosmogenesisRomInfo, nes_cosmogenesisRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cosmo Police Galivan (Japan)
static struct BurnRomInfo nes_cosmopolgaljRomDesc[] = {
	{ "Cosmo Police Galivan (Japan).nes",          262160, 0xbccada80, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cosmopolgalj)
STD_ROM_FN(nes_cosmopolgalj)

struct BurnDriver BurnDrvnes_cosmopolgalj = {
	"nes_cosmopolgalj", "nes_cosmopolgal", NULL, NULL, "1988",
	"Cosmo Police Galivan (Japan)\0", NULL, "Nihon Bussan", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_cosmopolgaljRomInfo, nes_cosmopolgaljRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cosmo Police Galivan (Hack, English)
static struct BurnRomInfo nes_cosmopolgalRomDesc[] = {
	{ "Cosmo Police Galivan (T-eng).nes",          262160, 0x4f031cb0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cosmopolgal)
STD_ROM_FN(nes_cosmopolgal)

struct BurnDriver BurnDrvnes_cosmopolgal = {
	"nes_cosmopolgal", NULL, NULL, NULL, "2000",
	"Cosmo Police Galivan (Hack, English)\0", NULL, "Jair", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_cosmopolgalRomInfo, nes_cosmopolgalRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cowboy Kid (USA)
static struct BurnRomInfo nes_cowboykidRomDesc[] = {
	{ "Cowboy Kid (USA).nes",          524304, 0xb150ae9a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cowboykid)
STD_ROM_FN(nes_cowboykid)

struct BurnDriver BurnDrvnes_cowboykid = {
	"nes_cowboykid", NULL, NULL, NULL, "1992",
	"Cowboy Kid (USA)\0", NULL, "Romstar", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_cowboykidRomInfo, nes_cowboykidRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Crash 'n' the Boys - Street Challenge (USA)
static struct BurnRomInfo nes_crashnboyRomDesc[] = {
	{ "Crash 'n' the Boys - Street Challenge (USA).nes",          262160, 0xed63ccc5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_crashnboy)
STD_ROM_FN(nes_crashnboy)

struct BurnDriver BurnDrvnes_crashnboy = {
	"nes_crashnboy", NULL, NULL, NULL, "1992",
	"Crash 'n' the Boys - Street Challenge (USA)\0", NULL, "Technos", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_crashnboyRomInfo, nes_crashnboyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Crayon Shin-chan - Ora to Poi Poi (Japan)
static struct BurnRomInfo nes_crayoshichaRomDesc[] = {
	{ "Crayon Shin-chan - Ora to Poi Poi (Japan).nes",          262160, 0x564205d0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_crayoshicha)
STD_ROM_FN(nes_crayoshicha)

struct BurnDriver BurnDrvnes_crayoshicha = {
	"nes_crayoshicha", NULL, NULL, NULL, "1993",
	"Crayon Shin-chan - Ora to Poi Poi (Japan)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_crayoshichaRomInfo, nes_crayoshichaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Crazy Climber (Japan)
static struct BurnRomInfo nes_crazyclimberRomDesc[] = {
	{ "Crazy Climber (Japan).nes",          131088, 0x83763841, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_crazyclimber)
STD_ROM_FN(nes_crazyclimber)

struct BurnDriver BurnDrvnes_crazyclimber = {
	"nes_crazyclimber", NULL, NULL, NULL, "1986",
	"Crazy Climber (Japan)\0", NULL, "Nichibutsu", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_crazyclimberRomInfo, nes_crazyclimberRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Crime Busters (USA)
static struct BurnRomInfo nes_crimebustersRomDesc[] = {
	{ "Crime Busters (USA).nes",          163856, 0x86c7d81e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_crimebusters)
STD_ROM_FN(nes_crimebusters)

struct BurnDriver BurnDrvnes_crimebusters = {
	"nes_crimebusters", NULL, NULL, NULL, "1989",
	"Crime Busters (USA)\0", NULL, "Gradiente", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_crimebustersRomInfo, nes_crimebustersRomName, NULL, NULL, NULL, NULL, NESZapperInputInfo, NESZapperDIPInfo,
	NESZapperInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Crisis Force (Japan)
static struct BurnRomInfo nes_crisisforcejRomDesc[] = {
	{ "Crisis Force (Japan).nes",          262160, 0xc4520781, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_crisisforcej)
STD_ROM_FN(nes_crisisforcej)

struct BurnDriver BurnDrvnes_crisisforcej = {
	"nes_crisisforcej", "nes_crisisforce", NULL, NULL, "1991",
	"Crisis Force (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_crisisforcejRomInfo, nes_crisisforcejRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Crisis Force (Hack, English)
static struct BurnRomInfo nes_crisisforceRomDesc[] = {
	{ "Crisis Force (T-Eng).nes",          262160, 0x8a053054, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_crisisforce)
STD_ROM_FN(nes_crisisforce)

struct BurnDriver BurnDrvnes_crisisforce = {
	"nes_crisisforce", NULL, NULL, NULL, "2008",
	"Crisis Force (Hack, English)\0", NULL, "Stardust Crusaders", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_crisisforceRomInfo, nes_crisisforceRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cross Fire (Japan)
static struct BurnRomInfo nes_crossfireRomDesc[] = {
	{ "Cross Fire (Japan).nes",          262160, 0xc3c75c6e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_crossfire)
STD_ROM_FN(nes_crossfire)

struct BurnDriver BurnDrvnes_crossfire = {
	"nes_crossfire", NULL, NULL, NULL, "1989?",
	"Cross Fire (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, nes_crossfireRomInfo, nes_crossfireRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Crystalis (USA)
static struct BurnRomInfo nes_crystalisRomDesc[] = {
	{ "Crystalis (USA).nes",          393232, 0x1bd39032, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_crystalis)
STD_ROM_FN(nes_crystalis)

struct BurnDriver BurnDrvnes_crystalis = {
	"nes_crystalis", NULL, NULL, NULL, "1990",
	"Crystalis (USA)\0", NULL, "SNK", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_crystalisRomInfo, nes_crystalisRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cyber Stadium Series - Base Wars (USA)
static struct BurnRomInfo nes_cyberstaserRomDesc[] = {
	{ "Cyber Stadium Series - Base Wars (USA).nes",          262160, 0xda968c24, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cyberstaser)
STD_ROM_FN(nes_cyberstaser)

struct BurnDriver BurnDrvnes_cyberstaser = {
	"nes_cyberstaser", NULL, NULL, NULL, "1991",
	"Cyber Stadium Series - Base Wars (USA)\0", NULL, "Ultra Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_cyberstaserRomInfo, nes_cyberstaserRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cybernoid - The Fighting Machine (USA)
static struct BurnRomInfo nes_cyberRomDesc[] = {
	{ "Cybernoid - The Fighting Machine (USA).nes",          65552, 0xe3a6d7f6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cyber)
STD_ROM_FN(nes_cyber)

struct BurnDriver BurnDrvnes_cyber = {
	"nes_cyber", NULL, NULL, NULL, "1989",
	"Cybernoid - The Fighting Machine (USA)\0", NULL, "Acclaim", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_cyberRomInfo, nes_cyberRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Cycle Race - Road Man (Japan)
static struct BurnRomInfo nes_cycleracRomDesc[] = {
	{ "Cycle Race - Road Man (Japan).nes",          262160, 0x899ad1fd, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_cyclerac)
STD_ROM_FN(nes_cyclerac)

struct BurnDriver BurnDrvnes_cyclerac = {
	"nes_cyclerac", NULL, NULL, NULL, "1988",
	"Cycle Race - Road Man (Japan)\0", NULL, "Tokyo Shoseki", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_cycleracRomInfo, nes_cycleracRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dai-2-ji Super Robot Taisen (Japan)
static struct BurnRomInfo nes_dai2jisuprotajRomDesc[] = {
	{ "Dai-2-ji Super Robot Taisen (Japan).nes",          524304, 0x62c5d10c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dai2jisuprotaj)
STD_ROM_FN(nes_dai2jisuprotaj)

struct BurnDriver BurnDrvnes_dai2jisuprotaj = {
	"nes_dai2jisuprotaj", "nes_dai2jisuprota", NULL, NULL, "1991",
	"Dai-2-ji Super Robot Taisen (Japan)\0", NULL, "Banpresto", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_dai2jisuprotajRomInfo, nes_dai2jisuprotajRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dai-2-ji Super Robot Taisen (Hack, English)
// https://www.romhacking.net/translations/221/
static struct BurnRomInfo nes_dai2jisuprotaRomDesc[] = {
	{ "Dai-2-ji Super Robot Taisen (T-eng).nes",          524304, 0x648c69fe, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dai2jisuprota)
STD_ROM_FN(nes_dai2jisuprota)

struct BurnDriver BurnDrvnes_dai2jisuprota = {
	"nes_dai2jisuprota", NULL, NULL, NULL, "2013",
	"Dai-2-ji Super Robot Taisen (Hack, English)\0", NULL, "Aeon Genesis", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_dai2jisuprotaRomInfo, nes_dai2jisuprotaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Daiku no Gen-san (Japan)
static struct BurnRomInfo nes_daikunogensanRomDesc[] = {
	{ "Daiku no Gen-san (Japan).nes",          262160, 0xa529d5f0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_daikunogensan)
STD_ROM_FN(nes_daikunogensan)

struct BurnDriver BurnDrvnes_daikunogensan = {
	"nes_daikunogensan", NULL, NULL, NULL, "1991",
	"Daiku no Gen-san (Japan)\0", NULL, "Irem", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_daikunogensanRomInfo, nes_daikunogensanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Daiku no Gen-san 2 - Akage no Dan no Gyakushuu (Japan)
static struct BurnRomInfo nes_daikunogensan2RomDesc[] = {
	{ "Daiku no Gen-san 2 - Akage no Dan no Gyakushuu (Japan).nes",          524304, 0x3774121e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_daikunogensan2)
STD_ROM_FN(nes_daikunogensan2)

struct BurnDriver BurnDrvnes_daikunogensan2 = {
	"nes_daikunogensan2", NULL, NULL, NULL, "1993",
	"Daiku no Gen-san 2 - Akage no Dan no Gyakushuu (Japan)\0", NULL, "Irem", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_daikunogensan2RomInfo, nes_daikunogensan2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Danny Sullivan's Indy Heat (USA)
static struct BurnRomInfo nes_dannysulsindheRomDesc[] = {
	{ "Danny Sullivan's Indy Heat (USA).nes",          131088, 0x311b5a58, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dannysulsindhe)
STD_ROM_FN(nes_dannysulsindhe)

struct BurnDriver BurnDrvnes_dannysulsindhe = {
	"nes_dannysulsindhe", NULL, NULL, NULL, "1992",
	"Danny Sullivan's Indy Heat (USA)\0", NULL, "Tradewest", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_dannysulsindheRomInfo, nes_dannysulsindheRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dark Lord (Japan)
static struct BurnRomInfo nes_darklordRomDesc[] = {
	{ "Dark Lord (Japan).nes",          393232, 0x1be8483a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_darklord)
STD_ROM_FN(nes_darklord)

struct BurnDriver BurnDrvnes_darklord = {
	"nes_darklord", NULL, NULL, NULL, "1991",
	"Dark Lord (Japan)\0", NULL, "Data East", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_darklordRomInfo, nes_darklordRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Darkman (USA)
static struct BurnRomInfo nes_darkmanRomDesc[] = {
	{ "Darkman (USA).nes",          262160, 0x5438a0ac, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_darkman)
STD_ROM_FN(nes_darkman)

struct BurnDriver BurnDrvnes_darkman = {
	"nes_darkman", NULL, NULL, NULL, "1991",
	"Darkman (USA)\0", NULL, "Ocean", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_darkmanRomInfo, nes_darkmanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Darkwing Duck (USA)
static struct BurnRomInfo nes_darkwingduckRomDesc[] = {
	{ "Darkwing Duck (USA).nes",          262160, 0xc7e6cc19, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_darkwingduck)
STD_ROM_FN(nes_darkwingduck)

struct BurnDriver BurnDrvnes_darkwingduck = {
	"nes_darkwingduck", NULL, NULL, NULL, "1992",
	"Darkwing Duck (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_darkwingduckRomInfo, nes_darkwingduckRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dash Galaxy in the Alien Asylum (USA)
static struct BurnRomInfo nes_dashgalinaliasRomDesc[] = {
	{ "Dash Galaxy in the Alien Asylum (USA).nes",          65552, 0x28aa07ba, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dashgalinalias)
STD_ROM_FN(nes_dashgalinalias)

struct BurnDriver BurnDrvnes_dashgalinalias = {
	"nes_dashgalinalias", NULL, NULL, NULL, "1990",
	"Dash Galaxy in the Alien Asylum (USA)\0", NULL, "Data East", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_dashgalinaliasRomInfo, nes_dashgalinaliasRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dash Yarou (Japan)
static struct BurnRomInfo nes_dashyarouRomDesc[] = {
	{ "Dash Yarou (Japan).nes",          131088, 0x2ddd5f68, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dashyarou)
STD_ROM_FN(nes_dashyarou)

struct BurnDriver BurnDrvnes_dashyarou = {
	"nes_dashyarou", NULL, NULL, NULL, "1990",
	"Dash Yarou (Japan)\0", NULL, "Visco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_dashyarouRomInfo, nes_dashyarouRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Datsugoku (Japan)
static struct BurnRomInfo nes_datsugokuRomDesc[] = {
	{ "Datsugoku (Japan)(1989)(KAC).nes",          262160, 0x5bb9899a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_datsugoku)
STD_ROM_FN(nes_datsugoku)

struct BurnDriver BurnDrvnes_datsugoku = {
	"nes_datsugoku", "nes_pow", NULL, NULL, "1989",
	"Datsugoku (Japan)\0", NULL, "KAC", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_datsugokuRomInfo, nes_datsugokuRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// David Crane's A Boy and His Blob - Trouble on Blobolonia (USA)
static struct BurnRomInfo nes_davidcrasaboyandhisRomDesc[] = {
	{ "David Crane's A Boy and His Blob - Trouble on Blobolonia (USA)(1990)(Absolute).nes",          262160, 0x20a9e4a2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_davidcrasaboyandhis)
STD_ROM_FN(nes_davidcrasaboyandhis)

struct BurnDriver BurnDrvnes_davidcrasaboyandhis = {
	"nes_davidcrasaboyandhis", NULL, NULL, NULL, "1990",
	"David Crane's A Boy and His Blob - Trouble on Blobolonia (USA)\0", NULL, "Absolute Entertainment", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_davidcrasaboyandhisRomInfo, nes_davidcrasaboyandhisRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Fushigi na Blobby - Blobania no Kiki (Japan)
static struct BurnRomInfo nes_fushiblobbyRomDesc[] = {
	{ "Fushigi na Blobby - Blobania no Kiki (Japan)(1990)(Jaleco).nes",          262160, 0x76c8f957, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_fushiblobby)
STD_ROM_FN(nes_fushiblobby)

struct BurnDriver BurnDrvnes_fushiblobby = {
	"nes_fushiblobby", "nes_davidcrasaboyandhis", NULL, NULL, "1990",
	"Fushigi na Blobby - Blobania no Kiki (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_fushiblobbyRomInfo, nes_fushiblobbyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Day Dreamin' Davey (USA)
static struct BurnRomInfo nes_daydredavRomDesc[] = {
	{ "Day Dreamin' Davey (USA)(1992)(HAL Lab.).nes",          393232, 0xced13971, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_daydredav)
STD_ROM_FN(nes_daydredav)

struct BurnDriver BurnDrvnes_daydredav = {
	"nes_daydredav", NULL, NULL, NULL, "1992",
	"Day Dreamin' Davey (USA)\0", NULL, "HAL Laboratory", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_daydredavRomInfo, nes_daydredavRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Days of Thunder (USA)
static struct BurnRomInfo nes_daysofthunderRomDesc[] = {
	{ "Days of Thunder (USA)(1990)(Mindscape).nes",          393232, 0x3616c7dd, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_daysofthunder)
STD_ROM_FN(nes_daysofthunder)

struct BurnDriver BurnDrvnes_daysofthunder = {
	"nes_daysofthunder", NULL, NULL, NULL, "1990",
	"Days of Thunder (USA)\0", NULL, "Mindscape", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_daysofthunderRomInfo, nes_daysofthunderRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Daikaijuu Deburas (Japan)
static struct BurnRomInfo nes_ddeburasjRomDesc[] = {
	{ "Daikaijuu Deburas (Japan)(1990)(Data East).nes",          393232, 0x7fdf1bb3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ddeburasj)
STD_ROM_FN(nes_ddeburasj)

struct BurnDriver BurnDrvnes_ddeburasj = {
	"nes_ddeburasj", "nes_ddeburas", NULL, NULL, "1990",
	"Daikaijuu Deburas (Japan)\0", NULL, "Data East", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_ddeburasjRomInfo, nes_ddeburasjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Daikaijuu Deburas ~ Giant Monster Flaburas (Hack, English)
// https://www.romhacking.net/translations/7022/
static struct BurnRomInfo nes_ddeburasRomDesc[] = {
	{ "Daikaijuu Deburas T-Eng (2023)(BlackPaladin).nes",          524304, 0x9c135435, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ddeburas)
STD_ROM_FN(nes_ddeburas)

struct BurnDriver BurnDrvnes_ddeburas = {
	"nes_ddeburas", NULL, NULL, NULL, "2023",
	"Daikaijuu Deburas ~ Giant Monster Flaburas (Hack, English)\0", NULL, "BlackPaladin", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_ddeburasRomInfo, nes_ddeburasRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dead Fox (Japan)
static struct BurnRomInfo nes_deadfoxRomDesc[] = {
	{ "Dead Fox (Japan)(1990)(Capcom).nes",          262160, 0xf316b497, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_deadfox)
STD_ROM_FN(nes_deadfox)

struct BurnDriver BurnDrvnes_deadfox = {
	"nes_deadfox", "nes_codenam", NULL, NULL, "1990",
	"Dead Fox (Japan)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_deadfoxRomInfo, nes_deadfoxRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Deadly Towers (USA)
static struct BurnRomInfo nes_deadlytowersRomDesc[] = {
	{ "Deadly Towers (USA)(1987)(Broderbund).nes",          131088, 0x25225c70, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_deadlytowers)
STD_ROM_FN(nes_deadlytowers)

struct BurnDriver BurnDrvnes_deadlytowers = {
	"nes_deadlytowers", NULL, NULL, NULL, "1987",
	"Deadly Towers (USA)\0", NULL, "Broderbund", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_deadlytowersRomInfo, nes_deadlytowersRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Death Race (USA) (Unl)
static struct BurnRomInfo nes_deathraceRomDesc[] = {
	{ "Death Race (USA)(Unl)(1990)(AGCI).nes",          131088, 0x837c5171, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_deathrace)
STD_ROM_FN(nes_deathrace)

struct BurnDriver BurnDrvnes_deathrace = {
	"nes_deathrace", NULL, NULL, NULL, "1990",
	"Death Race (USA) (Unl)\0", NULL, "AGCI", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_deathraceRomInfo, nes_deathraceRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Deathbots (USA, Rev 1) (Unl)
static struct BurnRomInfo nes_deathbotsRomDesc[] = {
	{ "Deathbots (USA, Rev 1)(Unl)(1990)(AVE).nes",          131088, 0xcd12d2be, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_deathbots)
STD_ROM_FN(nes_deathbots)

struct BurnDriver BurnDrvnes_deathbots = {
	"nes_deathbots", NULL, NULL, NULL, "1990",
	"Deathbots (USA, Rev 1) (Unl)\0", NULL, "American Video Entertainment", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_deathbotsRomInfo, nes_deathbotsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Deblock (Japan)
static struct BurnRomInfo nes_deblockRomDesc[] = {
	{ "Deblock (Japan)(1991)(Athena).nes",          65552, 0x70eac605, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_deblock)
STD_ROM_FN(nes_deblock)

struct BurnDriver BurnDrvnes_deblock = {
	"nes_deblock", NULL, NULL, NULL, "1991",
	"Deblock (Japan)\0", NULL, "Athena", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_deblockRomInfo, nes_deblockRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Defender II (USA)
static struct BurnRomInfo nes_defenderiiRomDesc[] = {
	{ "Defender II (USA)(1988)(HAL Lab.).nes",          24592, 0xc0b2aa1f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_defenderii)
STD_ROM_FN(nes_defenderii)

struct BurnDriver BurnDrvnes_defenderii = {
	"nes_defenderii", NULL, NULL, NULL, "1988",
	"Defender II (USA)\0", NULL, "HAL Laboratory", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_defenderiiRomInfo, nes_defenderiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Defender of the Crown (USA)
static struct BurnRomInfo nes_defencroRomDesc[] = {
	{ "Defender of the Crown (USA)(1989)(Ultra Games).nes",          262160, 0x79123682, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_defencro)
STD_ROM_FN(nes_defencro)

struct BurnDriver BurnDrvnes_defencro = {
	"nes_defencro", NULL, NULL, NULL, "1989",
	"Defender of the Crown (USA)\0", NULL, "Ultra Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ADV | GBF_STRATEGY, 0,
	NESGetZipName, nes_defencroRomInfo, nes_defencroRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Defenders of Dynatron City (USA)
static struct BurnRomInfo nes_defendyncitRomDesc[] = {
	{ "Defenders of Dynatron City (USA)(1992)(JVC).nes",          262160, 0x8db6ba41, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_defendyncit)
STD_ROM_FN(nes_defendyncit)

struct BurnDriver BurnDrvnes_defendyncit = {
	"nes_defendyncit", NULL, NULL, NULL, "1992",
	"Defenders of Dynatron City (USA)\0", NULL, "JVC", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_defendyncitRomInfo, nes_defendyncitRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Deja Vu (USA)
static struct BurnRomInfo nes_dejavuRomDesc[] = {
	{ "Deja Vu (USA).nes",          393232, 0x67b25db5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dejavu)
STD_ROM_FN(nes_dejavu)

struct BurnDriver BurnDrvnes_dejavu = {
	"nes_dejavu", NULL, NULL, NULL, "1990",
	"Deja Vu (USA)\0", NULL, "Kemco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_dejavuRomInfo, nes_dejavuRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Demon Sword (USA)
static struct BurnRomInfo nes_demonswordRomDesc[] = {
	{ "Demon Sword (USA).nes",          262160, 0x2b324834, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_demonsword)
STD_ROM_FN(nes_demonsword)

struct BurnDriver BurnDrvnes_demonsword = {
	"nes_demonsword", NULL, NULL, NULL, "1990",
	"Demon Sword (USA)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_demonswordRomInfo, nes_demonswordRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dengeki - Big Bang! (Japan)
static struct BurnRomInfo nes_dengekiRomDesc[] = {
	{ "Dengeki - Big Bang! (Japan).nes",          262160, 0x4e0c2429, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dengeki)
STD_ROM_FN(nes_dengeki)

struct BurnDriver BurnDrvnes_dengeki = {
	"nes_dengeki", "nes_clashatdem", NULL, NULL, "1989",
	"Dengeki - Big Bang! (Japan)\0", NULL, "Vic Tokai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_dengekiRomInfo, nes_dengekiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dengeki - Big Bang! (Hack, English v2.8a)
// https://www.romhacking.net/translations/6913/
static struct BurnRomInfo nes_dengekienRomDesc[] = {
	{ "Dengeki - Big Bang! (T-Eng)(2023)(StripyMonk).nes",          262160, 0x6a89092e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dengekien)
STD_ROM_FN(nes_dengekien)

struct BurnDriver BurnDrvnes_dengekien = {
	"nes_dengekien", "nes_clashatdem", NULL, NULL, "2023",
	"Dengeki - Big Bang! (Hack, English v2.8a)\0", NULL, "StripyMonk", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_dengekienRomInfo, nes_dengekienRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Destination Earthstar (USA)
static struct BurnRomInfo nes_destiearRomDesc[] = {
	{ "Destination Earthstar (USA).nes",          65552, 0xa4b27af2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_destiear)
STD_ROM_FN(nes_destiear)

struct BurnDriver BurnDrvnes_destiear = {
	"nes_destiear", NULL, NULL, NULL, "1990",
	"Destination Earthstar (USA)\0", NULL, "Acclaim", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_destiearRomInfo, nes_destiearRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Destiny of an Emperor (USA)
static struct BurnRomInfo nes_destianempRomDesc[] = {
	{ "Destiny of an Emperor (USA).nes",          262160, 0xc0f73d85, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_destianemp)
STD_ROM_FN(nes_destianemp)

struct BurnDriver BurnDrvnes_destianemp = {
	"nes_destianemp", NULL, NULL, NULL, "1990",
	"Destiny of an Emperor (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_destianempRomInfo, nes_destianempRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Destroyer (Unl)
static struct BurnRomInfo nes_destroyerRomDesc[] = {
	{ "Destroyer (1992)(Mega Soft).nes",          65552, 0xd9362123, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_destroyer)
STD_ROM_FN(nes_destroyer)

struct BurnDriver BurnDrvnes_destroyer = {
	"nes_destroyer", NULL, NULL, NULL, "1992",
	"Destroyer (Unl)\0", NULL, "Mega Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_destroyerRomInfo, nes_destroyerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Destructor, El (Unl)
static struct BurnRomInfo nes_destructorelRomDesc[] = {
	{ "Destructor, El (Spain) (Gluk Video) (Unl).nes",          65552, 0xeb33ea3b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_destructorel)
STD_ROM_FN(nes_destructorel)

struct BurnDriver BurnDrvnes_destructorel = {
	"nes_destructorel", NULL, NULL, NULL, "1992",
	"Destructor, El (Unl)\0", NULL, "Gluk Video", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_destructorelRomInfo, nes_destructorelRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Devil Man (Japan)
static struct BurnRomInfo nes_devilmanjRomDesc[] = {
	{ "Devil Man (Japan).nes",          262160, 0xc4c1ab20, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_devilmanj)
STD_ROM_FN(nes_devilmanj)

struct BurnDriver BurnDrvnes_devilmanj = {
	"nes_devilmanj", "nes_devilman", NULL, NULL, "1989",
	"Devil Man (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_devilmanjRomInfo, nes_devilmanjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Devil Man (Hack, English)
// https://www.romhacking.net/translations/1386/
static struct BurnRomInfo nes_devilmanRomDesc[] = {
	{ "Devil Man (T-eng).nes",          262160, 0x0be5f3e3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_devilman)
STD_ROM_FN(nes_devilman)

struct BurnDriver BurnDrvnes_devilman = {
	"nes_devilman", NULL, NULL, NULL, "2009",
	"Devil Man (Hack, English)\0", NULL, "snark", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_devilmanRomInfo, nes_devilmanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Devil World (Japan) (Rev A)
static struct BurnRomInfo nes_devilworldRomDesc[] = {
	{ "Devil World (Japan) (Rev A).nes",          24592, 0x9fc60476, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_devilworld)
STD_ROM_FN(nes_devilworld)

struct BurnDriver BurnDrvnes_devilworld = {
	"nes_devilworld", NULL, NULL, NULL, "1984",
	"Devil World (Japan) (Rev A)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_MAZE | GBF_ACTION, 0,
	NESGetZipName, nes_devilworldRomInfo, nes_devilworldRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Diablo II (Hack)
static struct BurnRomInfo nes_diabloiiRomDesc[] = {
	{ "Diablo II (Hack).nes",          2097168, 0xb870d5cd, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_diabloii)
STD_ROM_FN(nes_diabloii)

struct BurnDriver BurnDrvnes_diabloii = {
	"nes_diabloii", NULL, NULL, NULL, "19??",
	"Diablo II (Hack)\0", NULL, "Shenzan Nanjing", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_diabloiiRomInfo, nes_diabloiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_dicktracyRomDesc[] = {
	{ "Dick Tracy (USA)(1990)(Bandai).nes",          131088, 0xe431136d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dicktracy)
STD_ROM_FN(nes_dicktracy)

struct BurnDriver BurnDrvnes_dicktracy = {
	"nes_dicktracy", NULL, NULL, NULL, "1990",
	"Dick Tracy (USA)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_dicktracyRomInfo, nes_dicktracyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_diehardRomDesc[] = {
	{ "Die Hard (USA).nes",          262160, 0x65eec6e7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_diehard)
STD_ROM_FN(nes_diehard)

struct BurnDriver BurnDrvnes_diehard = {
	"nes_diehard", NULL, NULL, NULL, "1992",
	"Die Hard (USA)\0", NULL, "Activision", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_diehardRomInfo, nes_diehardRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_digdugRomDesc[] = {
	{ "Dig Dug (Japan).nes",          24592, 0x3ae8289a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_digdug)
STD_ROM_FN(nes_digdug)

struct BurnDriver BurnDrvnes_digdug = {
	"nes_digdug", NULL, NULL, NULL, "1985",
	"Dig Dug (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_digdugRomInfo, nes_digdugRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_digdugiiRomDesc[] = {
	{ "Dig Dug II (Japan).nes",          40976, 0xcc904e37, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_digdugii)
STD_ROM_FN(nes_digdugii)

struct BurnDriver BurnDrvnes_digdugii = {
	"nes_digdugii", NULL, NULL, NULL, "1986",
	"Dig Dug II (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_digdugiiRomInfo, nes_digdugiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_digdugiitroinpaRomDesc[] = {
	{ "Dig Dug II - Trouble in Paradise (USA).nes",          40976, 0x3cc270fb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_digdugiitroinpa)
STD_ROM_FN(nes_digdugiitroinpa)

struct BurnDriver BurnDrvnes_digdugiitroinpa = {
	"nes_digdugiitroinpa", NULL, NULL, NULL, "1989",
	"Dig Dug II - Trouble in Paradise (USA)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_digdugiitroinpaRomInfo, nes_digdugiitroinpaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_diggerRomDesc[] = {
	{ "Digger - The Legend of the Lost City (USA).nes",          131088, 0xec41647e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_digger)
STD_ROM_FN(nes_digger)

struct BurnDriver BurnDrvnes_digger = {
	"nes_digger", NULL, NULL, NULL, "1990",
	"Digger - The Legend of the Lost City (USA)\0", NULL, "Milton Bradley", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_diggerRomInfo, nes_diggerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Digital Devil Monogatari - Megami Tensei (Japan)
static struct BurnRomInfo nes_digitdevmonmegtejRomDesc[] = {
	{ "Digital Devil Monogatari - Megami Tensei (Japan).nes",          262160, 0xf906acab, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_digitdevmonmegtej)
STD_ROM_FN(nes_digitdevmonmegtej)

struct BurnDriver BurnDrvnes_digitdevmonmegtej = {
	"nes_digitdevmonmegtej", "nes_digitdevmonmegte", NULL, NULL, "1987",
	"Digital Devil Monogatari - Megami Tensei (Japan)\0", NULL, "Namcot", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_digitdevmonmegtejRomInfo, nes_digitdevmonmegtejRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Digital Devil Monogatari - Megami Tensei (Hack, English)
static struct BurnRomInfo nes_digitdevmonmegteRomDesc[] = {
	{ "Digital Devil Monogatari - Megami Tensei (T-eng).nes",          393232, 0xac5acc89, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_digitdevmonmegte)
STD_ROM_FN(nes_digitdevmonmegte)

struct BurnDriver BurnDrvnes_digitdevmonmegte = {
	"nes_digitdevmonmegte", NULL, NULL, NULL, "2018",
	"Digital Devil Monogatari - Megami Tensei (Hack, English)\0", NULL, "Stardust Crusaders", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_digitdevmonmegteRomInfo, nes_digitdevmonmegteRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Digital Devil Monogatari - Megami Tensei II (Japan) (Rev A)
static struct BurnRomInfo nes_digitdevmonmegteiijRomDesc[] = {
	{ "Digital Devil Story - Megami Tensei II (J)(Rev A)(1990)(Namcot).nes",          524304, 0xcbb8c4cc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_digitdevmonmegteiij)
STD_ROM_FN(nes_digitdevmonmegteiij)

struct BurnDriver BurnDrvnes_digitdevmonmegteiij = {
	"nes_digitdevmonmegteiij", "nes_digitdevmonmegteii", NULL, NULL, "1990",
	"Digital Devil Monogatari - Megami Tensei II (Japan) (Rev A)\0", NULL, "Namcot", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_digitdevmonmegteiijRomInfo, nes_digitdevmonmegteiijRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Digital Devil Monogatari - Megami Tensei II (Hack, English v1.04)
// https://www.romhacking.net/translations/6403/
static struct BurnRomInfo nes_digitdevmonmegteiiRomDesc[] = {
	{ "Digital Devil Story - Megami Tensei II T-Eng v1.04 (2022)(Stardust Crusaders).nes",          786448, 0xe74e6dd4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_digitdevmonmegteii)
STD_ROM_FN(nes_digitdevmonmegteii)

struct BurnDriver BurnDrvnes_digitdevmonmegteii = {
	"nes_digitdevmonmegteii", NULL, NULL, NULL, "2022",
	"Digital Devil Monogatari - Megami Tensei II (Hack, English v1.04)\0", NULL, "Stardust Crusaders", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_digitdevmonmegteiiRomInfo, nes_digitdevmonmegteiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dino Hockey (Prototype)
static struct BurnRomInfo nes_dinohockeyRomDesc[] = {
	{ "Dino Hockey (Proto)(1991)(Virgin Games).nes",          262160, 0xc3710b73, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dinohockey)
STD_ROM_FN(nes_dinohockey)

struct BurnDriver BurnDrvnes_dinohockey = {
	"nes_dinohockey", NULL, NULL, NULL, "1991",
	"Dino Hockey (Prototype)\0", NULL, "Sunsoft - Virgin Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_PROTOTYPE, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_dinohockeyRomInfo, nes_dinohockeyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dirty Harry - The War Against Drugs (USA)
static struct BurnRomInfo nes_dirtyharRomDesc[] = {
	{ "Dirty Harry - The War Against Drugs (USA).nes",          393232, 0x293952bd, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dirtyhar)
STD_ROM_FN(nes_dirtyhar)

struct BurnDriver BurnDrvnes_dirtyhar = {
	"nes_dirtyhar", NULL, NULL, NULL, "1990",
	"Dirty Harry - The War Against Drugs (USA)\0", NULL, "Mindscape", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_dirtyharRomInfo, nes_dirtyharRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dizzy The Adventurer (USA)
static struct BurnRomInfo nes_dizzyadvRomDesc[] = {
	{ "Dizzy The Adventurer (USA).nes",          131088, 0x92847456, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dizzyadv)
STD_ROM_FN(nes_dizzyadv)

struct BurnDriver BurnDrvnes_dizzyadv = {
	"nes_dizzyadv", NULL, NULL, NULL, "1992",
	"Dizzy The Adventurer (USA)\0", NULL, "Camerica", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_dizzyadvRomInfo, nes_dizzyadvRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Doki!Doki! Yuuenchi - Crazy Land Daisakusen (Japan)
static struct BurnRomInfo nes_dokidokyuujRomDesc[] = {
	{ "Doki!Doki! Yuuenchi - Crazy Land Daisakusen (Japan).nes",          262160, 0x6058397f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dokidokyuuj)
STD_ROM_FN(nes_dokidokyuuj)

struct BurnDriver BurnDrvnes_dokidokyuuj = {
	"nes_dokidokyuuj", "nes_dokidokyuu", NULL, NULL, "1991",
	"Doki!Doki! Yuuenchi - Crazy Land Daisakusen (Japan)\0", NULL, "Vap", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_dokidokyuujRomInfo, nes_dokidokyuujRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Doki!Doki! Yuuenchi - Crazy Land Daisakusen (Hack, English)
static struct BurnRomInfo nes_dokidokyuuRomDesc[] = {
	{ "Doki!Doki! Yuuenchi - Crazy Land Daisakusen (T-Eng).nes",          262160, 0x9aad9b7a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dokidokyuu)
STD_ROM_FN(nes_dokidokyuu)

struct BurnDriver BurnDrvnes_dokidokyuu = {
	"nes_dokidokyuu", NULL, NULL, NULL, "2016",
	"Doki!Doki! Yuuenchi - Crazy Land Daisakusen (Hack, English)\0", NULL, "pacnsacdave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_dokidokyuuRomInfo, nes_dokidokyuuRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Don Doko Don (Japan)
static struct BurnRomInfo nes_dondokodonRomDesc[] = {
	{ "Don Doko Don (Japan).nes",          393232, 0x6db7e711, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dondokodon)
STD_ROM_FN(nes_dondokodon)

struct BurnDriver BurnDrvnes_dondokodon = {
	"nes_dondokodon", NULL, NULL, NULL, "1990",
	"Don Doko Don (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_dondokodonRomInfo, nes_dondokodonRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Don Doko Don 2 (Japan)
static struct BurnRomInfo nes_dondokodon2jRomDesc[] = {
	{ "Don Doko Don 2 (Japan).nes",          393232, 0xf583796b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dondokodon2j)
STD_ROM_FN(nes_dondokodon2j)

struct BurnDriver BurnDrvnes_dondokodon2j = {
	"nes_dondokodon2j", "nes_dondokodon2", NULL, NULL, "1992",
	"Don Doko Don 2 (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_dondokodon2jRomInfo, nes_dondokodon2jRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Don Doko Don 2 (Hack, English)
static struct BurnRomInfo nes_dondokodon2RomDesc[] = {
	{ "Don Doko Don 2 (T-Eng).nes",          393232, 0x560142bc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dondokodon2)
STD_ROM_FN(nes_dondokodon2)

struct BurnDriver BurnDrvnes_dondokodon2 = {
	"nes_dondokodon2", NULL, NULL, NULL, "2014",
	"Don Doko Don 2 (Hack, English)\0", NULL, "MrRichard999", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_dondokodon2RomInfo, nes_dondokodon2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Donald Duck (Japan)
static struct BurnRomInfo nes_donaldduckRomDesc[] = {
	{ "Donald Duck (Japan).nes",          262160, 0x8bd8fce1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_donaldduck)
STD_ROM_FN(nes_donaldduck)

struct BurnDriver BurnDrvnes_donaldduck = {
	"nes_donaldduck", NULL, NULL, NULL, "1988",
	"Donald Duck (Japan)\0", NULL, "Kemco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_donaldduckRomInfo, nes_donaldduckRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Donald Land (Japan)
static struct BurnRomInfo nes_donaldlandRomDesc[] = {
	{ "Donald Land (Japan).nes",          262160, 0x4b539429, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_donaldland)
STD_ROM_FN(nes_donaldland)

struct BurnDriver BurnDrvnes_donaldland = {
	"nes_donaldland", NULL, NULL, NULL, "1988",
	"Donald Land (Japan)\0", NULL, "Data East", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_donaldlandRomInfo, nes_donaldlandRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Donkey Kong (World, Rev A)
static struct BurnRomInfo nes_donkeykongRomDesc[] = {
	{ "Donkey Kong (World)(Rev A)(1983)(Nintendo).nes",          24592, 0xe40b593b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_donkeykong)
STD_ROM_FN(nes_donkeykong)

struct BurnDriver BurnDrvnes_donkeykong = {
	"nes_donkeykong", NULL, NULL, NULL, "1983",
	"Donkey Kong (World, Rev A)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_donkeykongRomInfo, nes_donkeykongRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Donkey Kong 3 (USA)
static struct BurnRomInfo nes_donkeykong3RomDesc[] = {
	{ "Donkey Kong 3 (USA)(1984)(Nintendo).nes",          24592, 0xd1cac3c2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_donkeykong3)
STD_ROM_FN(nes_donkeykong3)

struct BurnDriver BurnDrvnes_donkeykong3 = {
	"nes_donkeykong3", NULL, NULL, NULL, "1984",
	"Donkey Kong 3 (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_donkeykong3RomInfo, nes_donkeykong3RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Donkey Kong Country 4 (Unl)
static struct BurnRomInfo nes_donkekoncou4RomDesc[] = {
	{ "Donkey Kong Country 4 (Unl)(1997)(J.Y. Company).nes",          524304, 0x5ae55685, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_donkekoncou4)
STD_ROM_FN(nes_donkekoncou4)

struct BurnDriver BurnDrvnes_donkekoncou4 = {
	"nes_donkekoncou4", NULL, NULL, NULL, "1997",
	"Donkey Kong Country 4 (Unl)\0", NULL, "J.Y. Company", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_donkekoncou4RomInfo, nes_donkekoncou4RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Donkey Kong Jr. (World, Rev A)
static struct BurnRomInfo nes_donkeykongjrRomDesc[] = {
	{ "Donkey Kong Jr. (World)(Rev A)(1983)(Nintendo).nes",          24592, 0x2a794ccb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_donkeykongjr)
STD_ROM_FN(nes_donkeykongjr)

struct BurnDriver BurnDrvnes_donkeykongjr = {
	"nes_donkeykongjr", NULL, NULL, NULL, "1983",
	"Donkey Kong Jr. (World, Rev A)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_donkeykongjrRomInfo, nes_donkeykongjrRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dooly Bravo Land (Korea)
static struct BurnRomInfo nes_doolybravolandRomDesc[] = {
	{ "Dooly Bravo Land (Korea)(1992)(Daou Infosys).nes",          262160, 0xe7740e47, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_doolybravoland)
STD_ROM_FN(nes_doolybravoland)

struct BurnDriver BurnDrvnes_doolybravoland = {
	"nes_doolybravoland", NULL, NULL, NULL, "1992",
	"Dooly Bravo Land (Korea)\0", NULL, "Daou Infosys", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_doolybravolandRomInfo, nes_doolybravolandRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Door Door (Japan)
static struct BurnRomInfo nes_doordoorRomDesc[] = {
	{ "Door Door (Japan)(1985)(Enix).nes",          24592, 0x70fb44b6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_doordoor)
STD_ROM_FN(nes_doordoor)

struct BurnDriver BurnDrvnes_doordoor = {
	"nes_doordoor", NULL, NULL, NULL, "1985",
	"Door Door (Japan)\0", NULL, "Enix", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_doordoorRomInfo, nes_doordoorRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Doraemon (Japan, Rev A)
static struct BurnRomInfo nes_doraemonRomDesc[] = {
	{ "Doraemon (Japan)(Rev A)(1986)(Hudson Soft).nes",          163856, 0x2768309d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_doraemon)
STD_ROM_FN(nes_doraemon)

struct BurnDriver BurnDrvnes_doraemon = {
	"nes_doraemon", NULL, NULL, NULL, "1986",
	"Doraemon (Japan, Rev A)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_doraemonRomInfo, nes_doraemonRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Doraemon - Giga Zombie no Gyakushuu (Japan)
static struct BurnRomInfo nes_doraejRomDesc[] = {
	{ "Doraemon - Giga Zombie no Gyakushuu (Japan)(1990)(Epoch Co.).nes",          262160, 0xb28e9ea4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_doraej)
STD_ROM_FN(nes_doraej)

struct BurnDriver BurnDrvnes_doraej = {
	"nes_doraej", "nes_dorae", NULL, NULL, "1990",
	"Doraemon - Giga Zombie no Gyakushuu (Japan)\0", NULL, "Epoch Co.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_doraejRomInfo, nes_doraejRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Doraemon - Giga Zombie no Gyakushuu (Hack, English)
// https://www.romhacking.net/translations/120/
static struct BurnRomInfo nes_doraeRomDesc[] = {
	{ "Doraemon - Giga Zombie no Gyakushuu T-Eng (1999)(WakdHacks).nes",          262160, 0xa9c510ac, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dorae)
STD_ROM_FN(nes_dorae)

struct BurnDriver BurnDrvnes_dorae = {
	"nes_dorae", NULL, NULL, NULL, "1999",
	"Doraemon - Giga Zombie no Gyakushuu (Hack, English)\0", NULL, "WakdHacks", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_doraeRomInfo, nes_doraeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Double Dare (USA)
static struct BurnRomInfo nes_doubledareRomDesc[] = {
	{ "Double Dare (USA)(1990)(GameTek).nes",          262160, 0xb631f92a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_doubledare)
STD_ROM_FN(nes_doubledare)

struct BurnDriver BurnDrvnes_doubledare = {
	"nes_doubledare", NULL, NULL, NULL, "1990",
	"Double Dare (USA)\0", NULL, "GameTek", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_MINIGAMES | GBF_QUIZ, 0,
	NESGetZipName, nes_doubledareRomInfo, nes_doubledareRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Double Dragon (USA)
static struct BurnRomInfo nes_doubledragonRomDesc[] = {
	{ "Double Dragon (USA)(1988)(Technos).nes",          262160, 0x62afe166, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_doubledragon)
STD_ROM_FN(nes_doubledragon)

struct BurnDriver BurnDrvnes_doubledragon = {
	"nes_doubledragon", NULL, NULL, NULL, "1988",
	"Double Dragon (USA)\0", NULL, "Technos", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_doubledragonRomInfo, nes_doubledragonRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Double Dragon (Japan)
static struct BurnRomInfo nes_doubledragonjRomDesc[] = {
	{ "Double Dragon (Japan)(1988)(Technos).nes",          262160, 0x915780a5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_doubledragonj)
STD_ROM_FN(nes_doubledragonj)

struct BurnDriver BurnDrvnes_doubledragonj = {
	"nes_doubledragonj", "nes_doubledragon", NULL, NULL, "1988",
	"Double Dragon (Japan)\0", NULL, "Technos Japan", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_doubledragonjRomInfo, nes_doubledragonjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Double Dragon II - The Revenge (USA)
static struct BurnRomInfo nes_doubldraiiRomDesc[] = {
	{ "Double Dragon II - The Revenge (USA)(1990)(Acclaim).nes",          262160, 0xcecfbf92, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_doubldraii)
STD_ROM_FN(nes_doubldraii)

struct BurnDriver BurnDrvnes_doubldraii = {
	"nes_doubldraii", NULL, NULL, NULL, "1990",
	"Double Dragon II - The Revenge (USA)\0", NULL, "Acclaim Entertainment", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_doubldraiiRomInfo, nes_doubldraiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Double Dragon II - The Revenge (Japan)
static struct BurnRomInfo nes_doubldraiijRomDesc[] = {
	{ "Double Dragon II - The Revenge (Japan)(1989)(Technos).nes",          262160, 0x1ddc74e3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_doubldraiij)
STD_ROM_FN(nes_doubldraiij)

struct BurnDriver BurnDrvnes_doubldraiij = {
	"nes_doubldraiij", "nes_doubldraii", NULL, NULL, "1989",
	"Double Dragon II - The Revenge (Japan)\0", NULL, "Technos Japan", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_doubldraiijRomInfo, nes_doubldraiijRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Double Dragon III - The Sacred Stones (USA)
static struct BurnRomInfo nes_doubldraiiiRomDesc[] = {
	{ "Double Dragon III - The Sacred Stones (USA)(1991)(Acclaim).nes",          262160, 0x7a6e0454, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_doubldraiii)
STD_ROM_FN(nes_doubldraiii)

struct BurnDriver BurnDrvnes_doubldraiii = {
	"nes_doubldraiii", NULL, NULL, NULL, "1991",
	"Double Dragon III - The Sacred Stones (USA)\0", NULL, "Acclaim Entertainment", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_doubldraiiiRomInfo, nes_doubldraiiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Double Dragon III - The Rosetta Stones (Japan)
static struct BurnRomInfo nes_doubldraiiijRomDesc[] = {
	{ "Double Dragon III - The Rosetta Stone (Japan)(1991)(Technos).nes",          262160, 0xd15f701d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_doubldraiiij)
STD_ROM_FN(nes_doubldraiiij)

struct BurnDriver BurnDrvnes_doubldraiiij = {
	"nes_doubldraiiij", "nes_doubldraiii", NULL, NULL, "1991",
	"Double Dragon III - The Rosetta Stones (Japan)\0", NULL, "Technos Japan", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_doubldraiiijRomInfo, nes_doubldraiiijRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Double Dribble (USA)
static struct BurnRomInfo nes_doubledribbleRomDesc[] = {
	{ "Double Dribble (USA)(1987)(Konami).nes",          131088, 0x7077a85d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_doubledribble)
STD_ROM_FN(nes_doubledribble)

struct BurnDriver BurnDrvnes_doubledribble = {
	"nes_doubledribble", NULL, NULL, NULL, "1987",
	"Double Dribble (USA)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_doubledribbleRomInfo, nes_doubledribbleRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Double Moon Densetsu (Japan)
static struct BurnRomInfo nes_doublmoodenjRomDesc[] = {
	{ "Double Moon Densetsu (Japan)(1992)(Masaya).nes",          524304, 0xe6ecf970, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_doublmoodenj)
STD_ROM_FN(nes_doublmoodenj)

struct BurnDriver BurnDrvnes_doublmoodenj = {
	"nes_doublmoodenj", "nes_doublmooden", NULL, NULL, "1992",
	"Double Moon Densetsu (Japan)\0", NULL, "Masaya", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_doublmoodenjRomInfo, nes_doublmoodenjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Double Moon Densetsu (Hack, English)
// https://www.romhacking.net/translations/2336/
static struct BurnRomInfo nes_doublmoodenRomDesc[] = {
	{ "Double Moon Densetsu T-Eng (2020)(Stardust Crusaders).nes",          524304, 0x2c2c43a4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_doublmooden)
STD_ROM_FN(nes_doublmooden)

struct BurnDriver BurnDrvnes_doublmooden = {
	"nes_doublmooden", NULL, NULL, NULL, "2020",
	"Double Moon Densetsu (Hack, English)\0", NULL, "Stardust Crusaders", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_doublmoodenRomInfo, nes_doublmoodenRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Double Strike (Unl)
static struct BurnRomInfo nes_doublestrikeRomDesc[] = {
	{ "Double Strike (Unl)(1990)(AVE).nes",          65552, 0xf4bb370a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_doublestrike)
STD_ROM_FN(nes_doublestrike)

struct BurnDriver BurnDrvnes_doublestrike = {
	"nes_doublestrike", NULL, NULL, NULL, "1990",
	"Double Strike (Unl)\0", NULL, "American Video Entertainment", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_doublestrikeRomInfo, nes_doublestrikeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dough Boy (Japan)
static struct BurnRomInfo nes_doughboyRomDesc[] = {
	{ "Dough Boy (Japan)(1985)(Kemco).nes",          40976, 0x1012eb15, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_doughboy)
STD_ROM_FN(nes_doughboy)

struct BurnDriver BurnDrvnes_doughboy = {
	"nes_doughboy", NULL, NULL, NULL, "1985",
	"Dough Boy (Japan)\0", NULL, "Kemco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_doughboyRomInfo, nes_doughboyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Downtown - Nekketsu Koushinkyoku - Soreyuke Daiundoukai (Japan)
static struct BurnRomInfo nes_downtnekkousordaRomDesc[] = {
	{ "Downtown - Nekketsu Koushinkyoku - Soreyuke Daiundoukai (Japan)(1990)(Technos).nes",          262160, 0xe34fc4af, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_downtnekkousorda)
STD_ROM_FN(nes_downtnekkousorda)

struct BurnDriver BurnDrvnes_downtnekkousorda = {
	"nes_downtnekkousorda", NULL, NULL, NULL, "1990",
	"Downtown - Nekketsu Koushinkyoku - Soreyuke Daiundoukai (Japan)\0", NULL, "Technos", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_downtnekkousordaRomInfo, nes_downtnekkousordaRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NESHori4pInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Downtown - Nekketsu Monogatari (Japan)
static struct BurnRomInfo nes_downtnekmonRomDesc[] = {
	{ "Downtown - Nekketsu Monogatari (Japan)(1989)(Technos).nes",          262160, 0xf7346e46, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_downtnekmon)
STD_ROM_FN(nes_downtnekmon)

struct BurnDriver BurnDrvnes_downtnekmon = {
	"nes_downtnekmon", NULL, NULL, NULL, "1989",
	"Downtown - Nekketsu Monogatari (Japan)\0", NULL, "Technos", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_downtnekmonRomInfo, nes_downtnekmonRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Downtown Special - Kunio-kun no Jidaigeki Da yo Zenin Shuugou! (Japan)
static struct BurnRomInfo nes_downtspekunkunnojidRomDesc[] = {
	{ "Downtown Special - Kunio-kun no Jidaigeki Da yo Zenin Shuugou! (Japan)(1991)(Technos).nes",          262160, 0x014d63c9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_downtspekunkunnojid)
STD_ROM_FN(nes_downtspekunkunnojid)

struct BurnDriver BurnDrvnes_downtspekunkunnojid = {
	"nes_downtspekunkunnojid", NULL, NULL, NULL, "1991",
	"Downtown Special - Kunio-kun no Jidaigeki Da yo Zenin Shuugou! (Japan)\0", NULL, "Technos", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_downtspekunkunnojidRomInfo, nes_downtspekunkunnojidRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dr. Chaos (USA)
static struct BurnRomInfo nes_drchaosRomDesc[] = {
	{ "Dr. Chaos (USA).nes",          131088, 0x406bda35, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_drchaos)
STD_ROM_FN(nes_drchaos)

struct BurnDriver BurnDrvnes_drchaos = {
	"nes_drchaos", NULL, NULL, NULL, "1988",
	"Dr. Chaos (USA)\0", NULL, "FCI", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_drchaosRomInfo, nes_drchaosRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dr. Jekyll and Mr. Hyde (USA)
static struct BurnRomInfo nes_drjekandmrhyRomDesc[] = {
	{ "Dr. Jekyll and Mr. Hyde (USA).nes",          163856, 0xc006a41b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_drjekandmrhy)
STD_ROM_FN(nes_drjekandmrhy)

struct BurnDriver BurnDrvnes_drjekandmrhy = {
	"nes_drjekandmrhy", NULL, NULL, NULL, "1989",
	"Dr. Jekyll and Mr. Hyde (USA)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_drjekandmrhyRomInfo, nes_drjekandmrhyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dr. Mario (Japan, USA) (Rev A)
static struct BurnRomInfo nes_drmarioRomDesc[] = {
	{ "Dr. Mario (Japan, USA) (Rev A).nes",          65552, 0x7623dffd, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_drmario)
STD_ROM_FN(nes_drmario)

struct BurnDriver BurnDrvnes_drmario = {
	"nes_drmario", NULL, NULL, NULL, "1990",
	"Dr. Mario (Japan, USA) (Rev A)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_drmarioRomInfo, nes_drmarioRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dr. Mario Turbo (Hack, v1.0)
// https://www.romhacking.net/hacks/6158/
static struct BurnRomInfo nes_drmariotRomDesc[] = {
	{ "Dr. Mario Turbo Hack v1.0 (2021)(TheExactSame).nes",          262160, 0xc1605818, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_drmariot)
STD_ROM_FN(nes_drmariot)

struct BurnDriver BurnDrvnes_drmariot = {
	"nes_drmariot", "nes_drmario", NULL, NULL, "2021",
	"Dr. Mario Turbo (Hack, v1.0)\0", NULL, "TheExactSame", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_drmariotRomInfo, nes_drmariotRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dr. Mario - Input Fixes (Hack, v1.0)
// https://www.romhacking.net/hacks/8200/
static struct BurnRomInfo nes_drmarioifRomDesc[] = {
	{ "Dr. Mario - Input Fixes (2023)(TakuikaNinja).nes",          65552, 0x91fe1811, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_drmarioif)
STD_ROM_FN(nes_drmarioif)

struct BurnDriver BurnDrvnes_drmarioif = {
	"nes_drmarioif", "nes_drmario", NULL, NULL, "2023",
	"Dr. Mario - Input Fixes (Hack, v1.0)\0", NULL, "TakuikaNinja", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_drmarioifRomInfo, nes_drmarioifRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Drac's Night Out (USA) (Prototype)
static struct BurnRomInfo nes_dracsnightoutRomDesc[] = {
	{ "Drac's Night Out (USA) (Prototype).nes",          262160, 0x2f81e727, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dracsnightout)
STD_ROM_FN(nes_dracsnightout)

struct BurnDriver BurnDrvnes_dracsnightout = {
	"nes_dracsnightout", NULL, NULL, NULL, "1991",
	"Drac's Night Out (USA) (Prototype)\0", NULL, "Parker Brothers", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_PROTOTYPE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_dracsnightoutRomInfo, nes_dracsnightoutRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Ball - Dai Maou Fukkatsu (Japan)
static struct BurnRomInfo nes_dragobaldaimaofujRomDesc[] = {
	{ "Dragon Ball - Dai Maou Fukkatsu (Japan).nes",          262160, 0xbeff8c77, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragobaldaimaofuj)
STD_ROM_FN(nes_dragobaldaimaofuj)

struct BurnDriver BurnDrvnes_dragobaldaimaofuj = {
	"nes_dragobaldaimaofuj", "nes_dragobaldaimaofu", NULL, NULL, "1988",
	"Dragon Ball - Dai Maou Fukkatsu (Japan)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_dragobaldaimaofujRomInfo, nes_dragobaldaimaofujRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Ball - Dai Maou Fukkatsu (Hack, English)
static struct BurnRomInfo nes_dragobaldaimaofuRomDesc[] = {
	{ "Dragon Ball - Dai Maou Fukkatsu (T-Eng).nes",          393232, 0x69beb7a5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragobaldaimaofu)
STD_ROM_FN(nes_dragobaldaimaofu)

struct BurnDriver BurnDrvnes_dragobaldaimaofu = {
	"nes_dragobaldaimaofu", NULL, NULL, NULL, "2011",
	"Dragon Ball - Dai Maou Fukkatsu (Hack, English)\0", NULL, "Stardust Crusaders", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_dragobaldaimaofuRomInfo, nes_dragobaldaimaofuRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Ball - Shen Long no Nazo (Japan)
static struct BurnRomInfo nes_dragobalshelonnonajRomDesc[] = {
	{ "Dragon Ball - Shen Long no Nazo (Japan).nes",          163856, 0x815a4bad, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragobalshelonnonaj)
STD_ROM_FN(nes_dragobalshelonnonaj)

struct BurnDriver BurnDrvnes_dragobalshelonnonaj = {
	"nes_dragobalshelonnonaj", "nes_dragonpower", NULL, NULL, "1986",
	"Dragon Ball - Shen Long no Nazo (Japan)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ADV | GBF_ACTION, 0,
	NESGetZipName, nes_dragobalshelonnonajRomInfo, nes_dragobalshelonnonajRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Ball - Shen Long no Nazo (Hack, English)
static struct BurnRomInfo nes_dragobalshelonnonaRomDesc[] = {
	{ "Dragon Ball - Shen Long no Nazo (T-Eng).nes",          163856, 0xb4e31bf4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragobalshelonnona)
STD_ROM_FN(nes_dragobalshelonnona)

struct BurnDriver BurnDrvnes_dragobalshelonnona = {
	"nes_dragobalshelonnona", "nes_dragonpower", NULL, NULL, "2016",
	"Dragon Ball - Shen Long no Nazo (Hack, English)\0", NULL, "TransBRC", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_ADV | GBF_ACTION, 0,
	NESGetZipName, nes_dragobalshelonnonaRomInfo, nes_dragobalshelonnonaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Ball 3 - Gokuu Den (Japan)
static struct BurnRomInfo nes_dragobal3gokdenRomDesc[] = {
	{ "Dragon Ball 3 - Gokuu Den (Japan).nes",          393232, 0x0544b2a4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragobal3gokden)
STD_ROM_FN(nes_dragobal3gokden)

struct BurnDriver BurnDrvnes_dragobal3gokden = {
	"nes_dragobal3gokden", NULL, NULL, NULL, "1989",
	"Dragon Ball 3 - Gokuu Den (Japan)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_dragobal3gokdenRomInfo, nes_dragobal3gokdenRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Ball Z - Kyoushuu! Saiya Jin (Japan)
static struct BurnRomInfo nes_dragobalzkyosajinjRomDesc[] = {
	{ "Dragon Ball Z - Kyoushuu! Saiya Jin (Japan).nes",          524304, 0xd78484b7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragobalzkyosajinj)
STD_ROM_FN(nes_dragobalzkyosajinj)

struct BurnDriver BurnDrvnes_dragobalzkyosajinj = {
	"nes_dragobalzkyosajinj", "nes_dragobalzkyosajin", NULL, NULL, "1990",
	"Dragon Ball Z - Kyoushuu! Saiya Jin (Japan)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_dragobalzkyosajinjRomInfo, nes_dragobalzkyosajinjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Ball Z - Kyoushuu! Saiya Jin (Hack, English)
static struct BurnRomInfo nes_dragobalzkyosajinRomDesc[] = {
	{ "Dragon Ball Z - Kyoushuu! Saiya Jin (T-Eng).nes",          524304, 0x31d0d50a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragobalzkyosajin)
STD_ROM_FN(nes_dragobalzkyosajin)

struct BurnDriver BurnDrvnes_dragobalzkyosajin = {
	"nes_dragobalzkyosajin", NULL, NULL, NULL, "2005",
	"Dragon Ball Z - Kyoushuu! Saiya Jin (Hack, English)\0", NULL, "Twilight Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_dragobalzkyosajinRomInfo, nes_dragobalzkyosajinRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Ball Z - Super Butouden 2 (Japan)
static struct BurnRomInfo nes_dragobalzsupbu2jRomDesc[] = {
	{ "Dragon Ball Z - Super Butouden 2 (Japan).nes",          393232, 0x2490d360, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragobalzsupbu2j)
STD_ROM_FN(nes_dragobalzsupbu2j)

struct BurnDriver BurnDrvnes_dragobalzsupbu2j = {
	"nes_dragobalzsupbu2j", "nes_dragobalzsupbu2", NULL, NULL, "1989?",
	"Dragon Ball Z - Super Butouden 2 (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_dragobalzsupbu2jRomInfo, nes_dragobalzsupbu2jRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Ball Z - Super Butouden 2 (Hack, English)
static struct BurnRomInfo nes_dragobalzsupbu2RomDesc[] = {
	{ "Dragon Ball Z - Super Butouden 2 (T-Eng).nes",          393232, 0xdf87586f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragobalzsupbu2)
STD_ROM_FN(nes_dragobalzsupbu2)

struct BurnDriver BurnDrvnes_dragobalzsupbu2 = {
	"nes_dragobalzsupbu2", NULL, NULL, NULL, "2019",
	"Dragon Ball Z - Super Butouden 2 (Hack, English)\0", NULL, "Green Jerry", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_dragobalzsupbu2RomInfo, nes_dragobalzsupbu2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Ball Z 5 (China) (Unl)
static struct BurnRomInfo nes_dragonballz5RomDesc[] = {
	{ "Dragon Ball Z 5 (China).nes",          786448, 0x1f2b86ea, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragonballz5)
STD_ROM_FN(nes_dragonballz5)

struct BurnDriver BurnDrvnes_dragonballz5 = {
	"nes_dragonballz5", NULL, NULL, NULL, "19??",
	"Dragon Ball Z 5 (China) (Unl)\0", NULL, "Rex Game Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_dragonballz5RomInfo, nes_dragonballz5RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Ball Z Gaiden - Saiya Jin Zetsumetsu Keikaku (Japan)
static struct BurnRomInfo nes_dragobalzgaisajinzejeRomDesc[] = {
	{ "Dragon Ball Z Gaiden - Saiya Jin Zetsumetsu Keikaku (Japan).nes",          524304, 0x69ae6291, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragobalzgaisajinzeje)
STD_ROM_FN(nes_dragobalzgaisajinzeje)

struct BurnDriver BurnDrvnes_dragobalzgaisajinzeje = {
	"nes_dragobalzgaisajinzeje", "nes_dragobalzgaisajinze", NULL, NULL, "1993",
	"Dragon Ball Z Gaiden - Saiya Jin Zetsumetsu Keikaku (Japan)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ADV | GBF_STRATEGY, 0,
	NESGetZipName, nes_dragobalzgaisajinzejeRomInfo, nes_dragobalzgaisajinzejeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Ball Z Gaiden - Saiya Jin Zetsumetsu Keikaku (Hack, English)
static struct BurnRomInfo nes_dragobalzgaisajinzeRomDesc[] = {
	{ "Dragon Ball Z Gaiden - Saiya Jin Zetsumetsu Keikaku (T-Eng).nes",          524304, 0xe7a5a03d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragobalzgaisajinze)
STD_ROM_FN(nes_dragobalzgaisajinze)

struct BurnDriver BurnDrvnes_dragobalzgaisajinze = {
	"nes_dragobalzgaisajinze", NULL, NULL, NULL, "2007",
	"Dragon Ball Z Gaiden - Saiya Jin Zetsumetsu Keikaku (Hack, English)\0", NULL, "Twilight Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_ADV | GBF_STRATEGY, 0,
	NESGetZipName, nes_dragobalzgaisajinzeRomInfo, nes_dragobalzgaisajinzeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Ball Z II - Gekishin Freeza!! (Japan)
static struct BurnRomInfo nes_dragobalziigefrjRomDesc[] = {
	{ "Dragon Ball Z II - Gekishin Freeza!! (Japan).nes",          524304, 0xd396d28a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragobalziigefrj)
STD_ROM_FN(nes_dragobalziigefrj)

struct BurnDriver BurnDrvnes_dragobalziigefrj = {
	"nes_dragobalziigefrj", "nes_dragobalziigefr", NULL, NULL, "1991",
	"Dragon Ball Z II - Gekishin Freeza!! (Japan)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ADV | GBF_STRATEGY, 0,
	NESGetZipName, nes_dragobalziigefrjRomInfo, nes_dragobalziigefrjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Ball Z II - Gekishin Freeza!! (Hack, English v1.02)
static struct BurnRomInfo nes_dragobalziigefrRomDesc[] = {
	{ "Dragon Ball Z II - Gekishin Freeza!! (T-Eng).nes",          524304, 0xffa1e20e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragobalziigefr)
STD_ROM_FN(nes_dragobalziigefr)

struct BurnDriver BurnDrvnes_dragobalziigefr = {
	"nes_dragobalziigefr", NULL, NULL, NULL, "2019",
	"Dragon Ball Z II - Gekishin Freeza!! (Hack, English v1.02)\0", NULL, "Gyroballer", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_ADV | GBF_STRATEGY, 0,
	NESGetZipName, nes_dragobalziigefrRomInfo, nes_dragobalziigefrRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Ball Z III - Ressen Jinzou Ningen (Japan)
static struct BurnRomInfo nes_dragobalziiirejinijRomDesc[] = {
	{ "Dragon Ball Z III - Ressen Jinzou Ningen (Japan).nes",          524304, 0xa69079d4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragobalziiirejinij)
STD_ROM_FN(nes_dragobalziiirejinij)

struct BurnDriver BurnDrvnes_dragobalziiirejinij = {
	"nes_dragobalziiirejinij", "nes_dragobalziiirejini", NULL, NULL, "1992",
	"Dragon Ball Z III - Ressen Jinzou Ningen (Japan)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ADV | GBF_STRATEGY, 0,
	NESGetZipName, nes_dragobalziiirejinijRomInfo, nes_dragobalziiirejinijRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Ball Z III - Ressen Jinzou Ningen (Hack, English)
static struct BurnRomInfo nes_dragobalziiirejiniRomDesc[] = {
	{ "Dragon Ball Z III - Ressen Jinzou Ningen (T-Eng).nes",          524304, 0x209955ea, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragobalziiirejini)
STD_ROM_FN(nes_dragobalziiirejini)

struct BurnDriver BurnDrvnes_dragobalziiirejini = {
	"nes_dragobalziiirejini", NULL, NULL, NULL, "2007",
	"Dragon Ball Z III - Ressen Jinzou Ningen (Hack, English)\0", NULL, "Twilight Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_ADV | GBF_STRATEGY, 0,
	NESGetZipName, nes_dragobalziiirejiniRomInfo, nes_dragobalziiirejiniRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Buster (Japan)
static struct BurnRomInfo nes_dragonbusterRomDesc[] = {
	{ "Dragon Buster (Japan).nes",          163856, 0xabb83b0f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragonbuster)
STD_ROM_FN(nes_dragonbuster)

struct BurnDriver BurnDrvnes_dragonbuster = {
	"nes_dragonbuster", NULL, NULL, NULL, "1987",
	"Dragon Buster (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_dragonbusterRomInfo, nes_dragonbusterRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Buster II - Yami no Fuuin (Japan)
static struct BurnRomInfo nes_dragobusiijRomDesc[] = {
	{ "Dragon Buster II - Yami no Fuuin (Japan).nes",          196624, 0xfa3c1312, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragobusiij)
STD_ROM_FN(nes_dragobusiij)

struct BurnDriver BurnDrvnes_dragobusiij = {
	"nes_dragobusiij", "nes_dragobusii", NULL, NULL, "1989",
	"Dragon Buster II - Yami no Fuuin (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ACTION | GBF_RPG, 0,
	NESGetZipName, nes_dragobusiijRomInfo, nes_dragobusiijRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Buster II - Yami no Fuuin (Hack, English)
static struct BurnRomInfo nes_dragobusiiRomDesc[] = {
	{ "Dragon Buster II - Yami no Fuuin (T-eng).nes",          196624, 0xba54967b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragobusii)
STD_ROM_FN(nes_dragobusii)

struct BurnDriver BurnDrvnes_dragobusii = {
	"nes_dragobusii", NULL, NULL, NULL, "2003",
	"Dragon Buster II - Yami no Fuuin (Hack, English)\0", NULL, "PentarouZero", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_ACTION | GBF_RPG, 0,
	NESGetZipName, nes_dragobusiiRomInfo, nes_dragobusiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Fighter (USA)
static struct BurnRomInfo nes_dragonfighterRomDesc[] = {
	{ "Dragon Fighter (USA).nes",          262160, 0xccd575a1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragonfighter)
STD_ROM_FN(nes_dragonfighter)

struct BurnDriver BurnDrvnes_dragonfighter = {
	"nes_dragonfighter", NULL, NULL, NULL, "1992",
	"Dragon Fighter (USA)\0", NULL, "Sofel", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_dragonfighterRomInfo, nes_dragonfighterRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Ninja (Japan)
static struct BurnRomInfo nes_dragninjajRomDesc[] = {
	{ "Dragon Ninja (Japan)(1989)(Namco).nes",          262160, 0x2cf535ca, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragninjaj)
STD_ROM_FN(nes_dragninjaj)

struct BurnDriver BurnDrvnes_dragninjaj = {
	"nes_dragninjaj", "nes_baddudes", NULL, NULL, "1989",
	"Dragon Ninja (Japan)\0", NULL, "Namco - Data East", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_dragninjajRomInfo, nes_dragninjajRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Ninja (Hack, English)
// https://www.romhacking.net/translations/1544/
static struct BurnRomInfo nes_dragninjaeRomDesc[] = {
	{ "Dragon Ninja (T-Eng)(2010)(Stardust Crusaders).nes",          262160, 0xd4e941c6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragninjae)
STD_ROM_FN(nes_dragninjae)

struct BurnDriver BurnDrvnes_dragninjae = {
	"nes_dragninjae", "nes_baddudes", NULL, NULL, "2010",
	"Dragon Ninja (Hack, English)\0", NULL, "Stardust Crusaders", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_dragninjaeRomInfo, nes_dragninjaeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Power (USA)
static struct BurnRomInfo nes_dragonpowerRomDesc[] = {
	{ "Dragon Power (USA).nes",          163856, 0x9517a5ab, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragonpower)
STD_ROM_FN(nes_dragonpower)

struct BurnDriver BurnDrvnes_dragonpower = {
	"nes_dragonpower", NULL, NULL, NULL, "1988",
	"Dragon Power (USA)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ADV | GBF_ACTION, 0,
	NESGetZipName, nes_dragonpowerRomInfo, nes_dragonpowerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Running (Unl)
static struct BurnRomInfo nes_dragonrunningRomDesc[] = {
	{ "Dragon Running (Unl).nes",          262160, 0xdfb4c50a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragonrunning)
STD_ROM_FN(nes_dragonrunning)

struct BurnDriver BurnDrvnes_dragonrunning = {
	"nes_dragonrunning", NULL, NULL, NULL, "199?",
	"Dragon Running (Unl)\0", NULL, "ABAB Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_dragonrunningRomInfo, nes_dragonrunningRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Scroll - Yomigaerishi Maryuu (Japan)
static struct BurnRomInfo nes_dragoscrRomDesc[] = {
	{ "Dragon Scroll - Yomigaerishi Maryuu (Japan).nes",          262160, 0x9475bafc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragoscr)
STD_ROM_FN(nes_dragoscr)

struct BurnDriver BurnDrvnes_dragoscr = {
	"nes_dragoscr", NULL, NULL, NULL, "1987",
	"Dragon Scroll - Yomigaerishi Maryuu (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_ADV, 0,
	NESGetZipName, nes_dragoscrRomInfo, nes_dragoscrRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Slayer 4 - Drasle Family (Japan)
static struct BurnRomInfo nes_dragosla4RomDesc[] = {
	{ "Dragon Slayer 4 - Drasle Family (Japan).nes",          196624, 0x8870a286, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragosla4)
STD_ROM_FN(nes_dragosla4)

struct BurnDriver BurnDrvnes_dragosla4 = {
	"nes_dragosla4", NULL, NULL, NULL, "1987",
	"Dragon Slayer 4 - Drasle Family (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_dragosla4RomInfo, nes_dragosla4RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Spirit - Aratanaru Densetsu (Japan)
static struct BurnRomInfo nes_dragospiaradenRomDesc[] = {
	{ "Dragon Spirit - Aratanaru Densetsu (Japan).nes",          262160, 0x28b33380, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragospiaraden)
STD_ROM_FN(nes_dragospiaraden)

struct BurnDriver BurnDrvnes_dragospiaraden = {
	"nes_dragospiaraden", NULL, NULL, NULL, "1989",
	"Dragon Spirit - Aratanaru Densetsu (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_dragospiaradenRomInfo, nes_dragospiaradenRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Spirit - The New Legend (USA)
static struct BurnRomInfo nes_dragospinewlegRomDesc[] = {
	{ "Dragon Spirit - The New Legend (USA).nes",          262160, 0xfd719491, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragospinewleg)
STD_ROM_FN(nes_dragospinewleg)

struct BurnDriver BurnDrvnes_dragospinewleg = {
	"nes_dragospinewleg", NULL, NULL, NULL, "1990",
	"Dragon Spirit - The New Legend (USA)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_dragospinewlegRomInfo, nes_dragospinewlegRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Warrior (USA)
static struct BurnRomInfo nes_dragonwarriorRomDesc[] = {
	{ "Dragon Warrior (USA).nes",          81936, 0xd4d5f5d7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragonwarrior)
STD_ROM_FN(nes_dragonwarrior)

struct BurnDriver BurnDrvnes_dragonwarrior = {
	"nes_dragonwarrior", NULL, NULL, NULL, "1989",
	"Dragon Warrior (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_dragonwarriorRomInfo, nes_dragonwarriorRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Warrior II (USA)
static struct BurnRomInfo nes_dragowariiRomDesc[] = {
	{ "Dragon Warrior II (USA).nes",          262160, 0xe9f5be99, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragowarii)
STD_ROM_FN(nes_dragowarii)

struct BurnDriver BurnDrvnes_dragowarii = {
	"nes_dragowarii", NULL, NULL, NULL, "1990",
	"Dragon Warrior II (USA)\0", NULL, "Enix", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_dragowariiRomInfo, nes_dragowariiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Warrior III (USA)
static struct BurnRomInfo nes_dragowariiiRomDesc[] = {
	{ "Dragon Warrior III (USA).nes",          524304, 0x0eb63e83, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragowariii)
STD_ROM_FN(nes_dragowariii)

struct BurnDriver BurnDrvnes_dragowariii = {
	"nes_dragowariii", NULL, NULL, NULL, "1992",
	"Dragon Warrior III (USA)\0", NULL, "Enix", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_dragowariiiRomInfo, nes_dragowariiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon Warrior IV (USA)
static struct BurnRomInfo nes_dragowarivRomDesc[] = {
	{ "Dragon Warrior IV (USA).nes",          524304, 0xf6b24806, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragowariv)
STD_ROM_FN(nes_dragowariv)

struct BurnDriver BurnDrvnes_dragowariv = {
	"nes_dragowariv", NULL, NULL, NULL, "1992",
	"Dragon Warrior IV (USA)\0", NULL, "Enix", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_dragowarivRomInfo, nes_dragowarivRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dragon's Lair (USA)
static struct BurnRomInfo nes_dragonslairRomDesc[] = {
	{ "Dragon's Lair (USA).nes",          131088, 0xf90ae80e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dragonslair)
STD_ROM_FN(nes_dragonslair)

struct BurnDriver BurnDrvnes_dragonslair = {
	"nes_dragonslair", NULL, NULL, NULL, "1990",
	"Dragon's Lair (USA)\0", NULL, "Sony Imagesoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_dragonslairRomInfo, nes_dragonslairRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dreamworld Pogie (Prototype)
static struct BurnRomInfo nes_dreamworldpogieRomDesc[] = {
	{ "Dreamworld Pogie (Prototype).nes",          131088, 0x2ace2f1b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dreamworldpogie)
STD_ROM_FN(nes_dreamworldpogie)

struct BurnDriver BurnDrvnes_dreamworldpogie = {
	"nes_dreamworldpogie", NULL, NULL, NULL, "1993",
	"Dreamworld Pogie (Prototype)\0", NULL, "Camerica", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_PROTOTYPE, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_dreamworldpogieRomInfo, nes_dreamworldpogieRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Dropzone (Euro)
static struct BurnRomInfo nes_dropzoneRomDesc[] = {
	{ "Dropzone (Europe).nes",          65552, 0xab29ab28, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dropzone)
STD_ROM_FN(nes_dropzone)

struct BurnDriver BurnDrvnes_dropzone = {
	"nes_dropzone", NULL, NULL, NULL, "1992",
	"Dropzone (Euro)\0", NULL, "Mindscape", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_dropzoneRomInfo, nes_dropzoneRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL, SCREEN_WIDTH, SCREEN_HEIGHT_PAL
};

// Druaga no Tou (Japan)
static struct BurnRomInfo nes_druaganotouRomDesc[] = {
	{ "Druaga no Tou (Japan).nes",          40976, 0x0c045fb9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_druaganotou)
STD_ROM_FN(nes_druaganotou)

struct BurnDriver BurnDrvnes_druaganotou = {
	"nes_druaganotou", NULL, NULL, NULL, "1985",
	"Druaga no Tou (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_MAZE | GBF_ACTION, 0,
	NESGetZipName, nes_druaganotouRomInfo, nes_druaganotouRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Duck Hunt (USA)
static struct BurnRomInfo nes_duckhuntRomDesc[] = {
	{ "Duck Hunt (USA).nes",          24592, 0x4644085e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_duckhunt)
STD_ROM_FN(nes_duckhunt)

struct BurnDriver BurnDrvnes_duckhunt = {
	"nes_duckhunt", NULL, NULL, NULL, "1984",
	"Duck Hunt (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_duckhuntRomInfo, nes_duckhuntRomName, NULL, NULL, NULL, NULL, NESZapperInputInfo, NESZapperDIPInfo,
	NESZapperInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Duck Maze (USA)
static struct BurnRomInfo nes_duckmazeRomDesc[] = {
	{ "Duck Maze (USA).nes",          40976, 0x01c1ca36, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_duckmaze)
STD_ROM_FN(nes_duckmaze)

struct BurnDriver BurnDrvnes_duckmaze = {
	"nes_duckmaze", NULL, NULL, NULL, "1987",
	"Duck Maze (USA)\0", NULL, "Bit Corp.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_duckmazeRomInfo, nes_duckmazeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// DuckTales (USA)
static struct BurnRomInfo nes_ducktalesRomDesc[] = {
	{ "DuckTales (USA).nes",          131088, 0x06b994b2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ducktales)
STD_ROM_FN(nes_ducktales)

struct BurnDriver BurnDrvnes_ducktales = {
	"nes_ducktales", NULL, NULL, NULL, "1989",
	"DuckTales (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_ducktalesRomInfo, nes_ducktalesRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Della DuckTales (GlobalHack)(2022)(Garrett Gilchrist)
// https://www.romhacking.net/hacks/6776/
static struct BurnRomInfo nes_dellatalesRomDesc[] = {
	{ "Della DuckTales (GlobalHack)(2022)(Garrett Gilchrist).nes",          131088, 0x43e9a226, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dellatales)
STD_ROM_FN(nes_dellatales)

struct BurnDriver BurnDrvnes_dellatales = {
	"nes_dellatales", "nes_ducktales", NULL, NULL, "2022",
	"Della DuckTales (Hack)\0", NULL, "Garrett Gilchrist", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_dellatalesRomInfo, nes_dellatalesRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// DuckTales 2 (USA)
static struct BurnRomInfo nes_ducktales2RomDesc[] = {
	{ "DuckTales 2 (USA).nes",          131088, 0x40ce2fc0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ducktales2)
STD_ROM_FN(nes_ducktales2)

struct BurnDriver BurnDrvnes_ducktales2 = {
	"nes_ducktales2", NULL, NULL, NULL, "1993",
	"DuckTales 2 (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_ducktales2RomInfo, nes_ducktales2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_dudeswitattRomDesc[] = {
	{ "Dudes With Attitude (Unl).nes",          65552, 0xe9151645, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dudeswitatt)
STD_ROM_FN(nes_dudeswitatt)

struct BurnDriver BurnDrvnes_dudeswitatt = {
	"nes_dudeswitatt", NULL, NULL, NULL, "1990",
	"Dudes With Attitude (Unl)\0", NULL, "American Video Entertainment", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_dudeswitattRomInfo, nes_dudeswitattRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_dungemagRomDesc[] = {
	{ "Dungeon Magic - Sword of the Elements (USA).nes",          262160, 0x7a365bf8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dungemag)
STD_ROM_FN(nes_dungemag)

struct BurnDriver BurnDrvnes_dungemag = {
	"nes_dungemag", NULL, NULL, NULL, "1990",
	"Dungeon Magic - Sword of the Elements (USA)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_dungemagRomInfo, nes_dungemagRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_dustydiasallstsoRomDesc[] = {
	{ "Dusty Diamond's All-Star Softball (USA).nes",          262160, 0x5506b1ca, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dustydiasallstso)
STD_ROM_FN(nes_dustydiasallstso)

struct BurnDriver BurnDrvnes_dustydiasallstso = {
	"nes_dustydiasallstso", NULL, NULL, NULL, "1990",
	"Dusty Diamond's All-Star Softball (USA)\0", NULL, "Broderbund", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_dustydiasallstsoRomInfo, nes_dustydiasallstsoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_dynamitebatmanRomDesc[] = {
	{ "Dynamite Batman (Japan).nes",          393232, 0xed509c6b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dynamitebatman)
STD_ROM_FN(nes_dynamitebatman)

struct BurnDriver BurnDrvnes_dynamitebatman = {
	"nes_dynamitebatman", "nes_batmaretjok", NULL, NULL, "1991",
	"Dynamite Batman (Japan)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_dynamitebatmanRomInfo, nes_dynamitebatmanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_dynamitebowlRomDesc[] = {
	{ "Dynamite Bowl (Japan).nes",          65552, 0x4779d33a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dynamitebowl)
STD_ROM_FN(nes_dynamitebowl)

struct BurnDriver BurnDrvnes_dynamitebowl = {
	"nes_dynamitebowl", NULL, NULL, NULL, "1987",
	"Dynamite Bowl (Japan)\0", NULL, "Toemiland", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 5, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_dynamitebowlRomInfo, nes_dynamitebowlRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_dynowRomDesc[] = {
	{ "Dynowarz - Destruction of Spondylus (USA).nes",          262160, 0xd05a18b7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_dynow)
STD_ROM_FN(nes_dynow)

struct BurnDriver BurnDrvnes_dynow = {
	"nes_dynow", NULL, NULL, NULL, "1990",
	"Dynowarz - Destruction of Spondylus (USA)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_dynowRomInfo, nes_dynowRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_earthboundRomDesc[] = {
	{ "Earthbound (USA) (Prototype).nes",          524304, 0xf5ef5002, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_earthbound)
STD_ROM_FN(nes_earthbound)

struct BurnDriver BurnDrvnes_earthbound = {
	"nes_earthbound", NULL, NULL, NULL, "1990",
	"Earthbound (USA) (Prototype)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_PROTOTYPE, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_earthboundRomInfo, nes_earthboundRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Egypt (Japan)
static struct BurnRomInfo nes_egyptjRomDesc[] = {
	{ "Egypt (Japan).nes",          65552, 0x38df4be7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_egyptj)
STD_ROM_FN(nes_egyptj)

struct BurnDriver BurnDrvnes_egyptj = {
	"nes_egyptj", "nes_egypt", NULL, NULL, "1991",
	"Egypt (Japan)\0", NULL, "Human Entertainment", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_egyptjRomInfo, nes_egyptjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Egypt (Hack, English)
// https://www.romhacking.net/translations/524/
static struct BurnRomInfo nes_egyptoRomDesc[] = {
	{ "Egypt (T-Eng).nes",          65552, 0xbb7f1c06, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_egypto)
STD_ROM_FN(nes_egypto)

struct BurnDriver BurnDrvnes_egypto = {
	"nes_egypto", "nes_egypt", NULL, NULL, "2016",
	"Egypt (Hack, English)\0", NULL, "Dodgy Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_egyptoRomInfo, nes_egyptoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Egypt (Hack, English v1.0a)
// https://www.romhacking.net/translations/7002/
static struct BurnRomInfo nes_egyptRomDesc[] = {
	{ "Egypt T-Eng v1.0a (2023)(BlackPaladin).nes",          65552, 0x0095e346, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_egypt)
STD_ROM_FN(nes_egypt)

struct BurnDriver BurnDrvnes_egypt = {
	"nes_egypt", NULL, NULL, NULL, "2023",
	"Egypt (Hack, English v1.0a)\0", NULL, "BlackPaladin", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_egyptRomInfo, nes_egyptRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Elevator Action (USA)
static struct BurnRomInfo nes_elevatoractionRomDesc[] = {
	{ "Elevator Action (USA).nes",          40976, 0xd415571f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_elevatoraction)
STD_ROM_FN(nes_elevatoraction)

struct BurnDriver BurnDrvnes_elevatoraction = {
	"nes_elevatoraction", NULL, NULL, NULL, "1987",
	"Elevator Action (USA)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_elevatoractionRomInfo, nes_elevatoractionRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Eliminator Boat Duel (USA)
static struct BurnRomInfo nes_elimiboadueRomDesc[] = {
	{ "Eliminator Boat Duel (USA).nes",          262160, 0x682d2df1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_elimiboadue)
STD_ROM_FN(nes_elimiboadue)

struct BurnDriver BurnDrvnes_elimiboadue = {
	"nes_elimiboadue", NULL, NULL, NULL, "1991",
	"Eliminator Boat Duel (USA)\0", NULL, "Electro Brain", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_elimiboadueRomInfo, nes_elimiboadueRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Elite (Euro)
static struct BurnRomInfo nes_eliteRomDesc[] = {
	{ "Elite (Europe).nes",          131088, 0x4cf12d39, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_elite)
STD_ROM_FN(nes_elite)

struct BurnDriver BurnDrvnes_elite = {
	"nes_elite", NULL, NULL, NULL, "1991",
	"Elite (Euro)\0", NULL, "Imagineer", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SIM, 0,
	NESGetZipName, nes_eliteRomInfo, nes_eliteRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL, SCREEN_WIDTH, SCREEN_HEIGHT_PAL
};

// Elnark no Zaihou (Japan)
static struct BurnRomInfo nes_elnarknozaihouRomDesc[] = {
	{ "Elnark no Zaihou (Japan).nes",          131088, 0xc759080e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_elnarknozaihou)
STD_ROM_FN(nes_elnarknozaihou)

struct BurnDriver BurnDrvnes_elnarknozaihou = {
	"nes_elnarknozaihou", NULL, NULL, NULL, "1987",
	"Elnark no Zaihou (Japan)\0", NULL, "Towa Chiki", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_elnarknozaihouRomInfo, nes_elnarknozaihouRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Empire City - 1931 (Japan)
static struct BurnRomInfo nes_empircitRomDesc[] = {
	{ "Empire City - 1931 (Japan).nes",          131088, 0xbd736ec8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_empircit)
STD_ROM_FN(nes_empircit)

struct BurnDriver BurnDrvnes_empircit = {
	"nes_empircit", NULL, NULL, NULL, "1987",
	"Empire City - 1931 (Japan)\0", NULL, "Toshiba Emi", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_empircitRomInfo, nes_empircitRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Erika to Satoru no Yume Bouken (Japan)
static struct BurnRomInfo nes_erikajRomDesc[] = {
	{ "Erika to Satoru no Yume Bouken (J)(Namco)(1988).nes",          262160, 0xe9f199aa, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_erikaj)
STD_ROM_FN(nes_erikaj)

struct BurnDriver BurnDrvnes_erikaj = {
	"nes_erikaj", "nes_erika", NULL, NULL, "1988",
	"Erika to Satoru no Yume Bouken (Japan)\0", NULL, "Namcot", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_erikajRomInfo, nes_erikajRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Erika and Satoru's Dream Adventure (Hack, English)
static struct BurnRomInfo nes_erikaRomDesc[] = {
	{ "Erika to Satoru no Yume Bouken (T-Eng)(2022)(Stardust Crusaders).nes",          393232, 0xcfb795ac, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_erika)
STD_ROM_FN(nes_erika)

struct BurnDriver BurnDrvnes_erika = {
	"nes_erika", NULL, NULL, NULL, "2022",
	"Erika and Satoru's Dream Adventure (Hack, English)\0", NULL, "Stardust Crusaders", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_erikaRomInfo, nes_erikaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Escape From Atlantis, The (Prototype)
static struct BurnRomInfo nes_escapfroatlRomDesc[] = {
	{ "Escape From Atlantis, The (Prototype).nes",          131088, 0x3c550fd5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_escapfroatl)
STD_ROM_FN(nes_escapfroatl)

struct BurnDriver BurnDrvnes_escapfroatl = {
	"nes_escapfroatl", NULL, NULL, NULL, "199?",
	"Escape From Atlantis, The (Prototype)\0", NULL, "Color Dreams", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_PROTOTYPE, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_escapfroatlRomInfo, nes_escapfroatlRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Esper Bouken Tai (Japan)
static struct BurnRomInfo nes_esperboukentaiRomDesc[] = {
	{ "Esper Bouken Tai (Japan).nes",          262160, 0x56b7dfe3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_esperboukentai)
STD_ROM_FN(nes_esperboukentai)

struct BurnDriver BurnDrvnes_esperboukentai = {
	"nes_esperboukentai", NULL, NULL, NULL, "1987",
	"Esper Bouken Tai (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_esperboukentaiRomInfo, nes_esperboukentaiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Esper Dream 2 - Aratanaru Tatakai (Japan)
static struct BurnRomInfo nes_esperdre2jRomDesc[] = {
	{ "Esper Dream 2 - Aratanaru Tatakai (Japan).nes",          393232, 0x72344f1d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_esperdre2j)
STD_ROM_FN(nes_esperdre2j)

struct BurnDriver BurnDrvnes_esperdre2j = {
	"nes_esperdre2j", "nes_esperdre2", NULL, NULL, "1992",
	"Esper Dream 2 - Aratanaru Tatakai (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_esperdre2jRomInfo, nes_esperdre2jRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Esper Dream 2 - Aratanaru Tatakai (Hack, English)
static struct BurnRomInfo nes_esperdre2RomDesc[] = {
	{ "Esper Dream 2 - Aratanaru Tatakai (T-Eng).nes",          393232, 0x892b32eb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_esperdre2)
STD_ROM_FN(nes_esperdre2)

struct BurnDriver BurnDrvnes_esperdre2 = {
	"nes_esperdre2", NULL, NULL, NULL, "2006",
	"Esper Dream 2 - Aratanaru Tatakai (Hack, English)\0", NULL, "Aeon Genesis", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_esperdre2RomInfo, nes_esperdre2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Excitebike (Japan, USA)
static struct BurnRomInfo nes_excitebikeRomDesc[] = {
	{ "Excitebike (Japan, USA).nes",          24592, 0x2bb33c69, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_excitebike)
STD_ROM_FN(nes_excitebike)

struct BurnDriver BurnDrvnes_excitebike = {
	"nes_excitebike", NULL, NULL, NULL, "1984",
	"Excitebike (Japan, USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_excitebikeRomInfo, nes_excitebikeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_excitingboxingRomDesc[] = {
	{ "Exciting Boxing (Japan).nes",          262160, 0xb374b6b0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_excitingboxing)
STD_ROM_FN(nes_excitingboxing)

struct BurnDriver BurnDrvnes_excitingboxing = {
	"nes_excitingboxing", NULL, NULL, NULL, "1987",
	"Exciting Boxing (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_excitingboxingRomInfo, nes_excitingboxingRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_excitralRomDesc[] = {
	{ "Exciting Rally - World Rally Championship (Japan).nes",          262160, 0x8cefb613, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_excitral)
STD_ROM_FN(nes_excitral)

struct BurnDriver BurnDrvnes_excitral = {
	"nes_excitral", NULL, NULL, NULL, "1992",
	"Exciting Rally - World Rally Championship (Japan)\0", NULL, "Kaken Corp.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_excitralRomInfo, nes_excitralRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_exerionRomDesc[] = {
	{ "Exerion (Japan).nes",          24592, 0x352f9a62, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_exerion)
STD_ROM_FN(nes_exerion)

struct BurnDriver BurnDrvnes_exerion = {
	"nes_exerion", NULL, NULL, NULL, "1985",
	"Exerion (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_exerionRomInfo, nes_exerionRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_exodusRomDesc[] = {
	{ "Exodus - Journey to the Promised Land (USA) (Unl).nes",          262160, 0x4b334bdf, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_exodus)
STD_ROM_FN(nes_exodus)

struct BurnDriver BurnDrvnes_exodus = {
	"nes_exodus", NULL, NULL, NULL, "1991",
	"Exodus - Journey to the Promised Land (USA) (Unl)\0", NULL, "Wisdom Tree", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_exodusRomInfo, nes_exodusRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_explodingfistRomDesc[] = {
	{ "Exploding Fist (USA, Prototype).nes",          65552, 0xc52ea831, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_explodingfist)
STD_ROM_FN(nes_explodingfist)

struct BurnDriver BurnDrvnes_explodingfist = {
	"nes_explodingfist", NULL, NULL, NULL, "1990",
	"Exploding Fist (USA) (Prototype)\0", NULL, "Tradewest", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_PROTOTYPE, 3, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_explodingfistRomInfo, nes_explodingfistRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// F-1 Hero (Japan)
static struct BurnRomInfo nes_f1heroRomDesc[] = {
	{ "F-1 Hero (Japan).nes",          262160, 0xab82d025, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_f1hero)
STD_ROM_FN(nes_f1hero)

struct BurnDriver BurnDrvnes_f1hero = {
	"nes_f1hero", NULL, NULL, NULL, "1988",
	"F-1 Hero (Japan)\0", NULL, "Varie", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_f1heroRomInfo, nes_f1heroRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// F-1 Hero 2 (Japan)
static struct BurnRomInfo nes_f1hero2RomDesc[] = {
	{ "F-1 Hero 2 (Japan).nes",          262160, 0x36b9506d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_f1hero2)
STD_ROM_FN(nes_f1hero2)

struct BurnDriver BurnDrvnes_f1hero2 = {
	"nes_f1hero2", NULL, NULL, NULL, "1991",
	"F-1 Hero 2 (Japan)\0", NULL, "Varie", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_f1hero2RomInfo, nes_f1hero2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// F-1 Race (Japan)
static struct BurnRomInfo nes_f1raceRomDesc[] = {
	{ "F-1 Race (Japan).nes",          24592, 0x827dc0b9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_f1race)
STD_ROM_FN(nes_f1race)

struct BurnDriver BurnDrvnes_f1race = {
	"nes_f1race", NULL, NULL, NULL, "1984",
	"F-1 Race (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_f1raceRomInfo, nes_f1raceRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// F-1 Sensation (Japan)
static struct BurnRomInfo nes_f1sensationRomDesc[] = {
	{ "F-1 Sensation (Japan).nes",          262160, 0xabb7157e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_f1sensation)
STD_ROM_FN(nes_f1sensation)

struct BurnDriver BurnDrvnes_f1sensation = {
	"nes_f1sensation", NULL, NULL, NULL, "1993",
	"F-1 Sensation (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_f1sensationRomInfo, nes_f1sensationRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// F-117A Stealth Fighter (USA)
static struct BurnRomInfo nes_f117stefigRomDesc[] = {
	{ "F-117A Stealth Fighter (USA).nes",          524304, 0x6aa0a7ad, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_f117stefig)
STD_ROM_FN(nes_f117stefig)

struct BurnDriver BurnDrvnes_f117stefig = {
	"nes_f117stefig", NULL, NULL, NULL, "1992",
	"F-117A Stealth Fighter (USA)\0", NULL, "Microprose", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SIM, 0,
	NESGetZipName, nes_f117stefigRomInfo, nes_f117stefigRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// F-15 City War (USA) (Unl)
static struct BurnRomInfo nes_f15citywarRomDesc[] = {
	{ "F-15 City War (USA) (Unl).nes",          65552, 0xa7b81c02, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_f15citywar)
STD_ROM_FN(nes_f15citywar)

struct BurnDriver BurnDrvnes_f15citywar = {
	"nes_f15citywar", NULL, NULL, NULL, "1990",
	"F-15 City War (USA) (Unl)\0", NULL, "American Video Entertainment", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_f15citywarRomInfo, nes_f15citywarRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// F-15 Strike Eagle (USA)
static struct BurnRomInfo nes_f15streagRomDesc[] = {
	{ "F-15 Strike Eagle (USA).nes",          524304, 0x6b1461ae, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_f15streag)
STD_ROM_FN(nes_f15streag)

struct BurnDriver BurnDrvnes_f15streag = {
	"nes_f15streag", NULL, NULL, NULL, "1992",
	"F-15 Strike Eagle (USA)\0", NULL, "Microprose", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SIM, 0,
	NESGetZipName, nes_f15streagRomInfo, nes_f15streagRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// F1 Circus (Japan)
static struct BurnRomInfo nes_f1circusjRomDesc[] = {
	{ "F1 Circus (Japan).nes",          393232, 0x1f19532d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_f1circusj)
STD_ROM_FN(nes_f1circusj)

struct BurnDriver BurnDrvnes_f1circusj = {
	"nes_f1circusj", "nes_f1circus", NULL, NULL, "1992",
	"F1 Circus (Japan)\0", NULL, "Nichibutsu", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_f1circusjRomInfo, nes_f1circusjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// F1 Circus (Hack, English)
static struct BurnRomInfo nes_f1circusRomDesc[] = {
	{ "F1 Circus (T-Eng).nes",          393232, 0x67c75e53, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_f1circus)
STD_ROM_FN(nes_f1circus)

struct BurnDriver BurnDrvnes_f1circus = {
	"nes_f1circus", NULL, NULL, NULL, "2016",
	"F1 Circus (Hack, English)\0", NULL, "MrRichard999", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_f1circusRomInfo, nes_f1circusRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Famicom Jump - Eiyuu Retsuden (Japan)
static struct BurnRomInfo nes_famicjumRomDesc[] = {
	{ "Famicom Jump - Eiyuu Retsuden (Japan).nes",          393232, 0xb91afcaf, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_famicjum)
STD_ROM_FN(nes_famicjum)

struct BurnDriver BurnDrvnes_famicjum = {
	"nes_famicjum", NULL, NULL, NULL, "1989",
	"Famicom Jump - Eiyuu Retsuden (Japan)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_famicjumRomInfo, nes_famicjumRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Famicom Jump II - Saikyou no 7 Nin (Japan)
static struct BurnRomInfo nes_famicjumiiRomDesc[] = {
	{ "Famicom Jump II - Saikyou no 7 Nin (Japan).nes",          524304, 0x6b41421c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_famicjumii)
STD_ROM_FN(nes_famicjumii)

struct BurnDriver BurnDrvnes_famicjumii = {
	"nes_famicjumii", NULL, NULL, NULL, "1991",
	"Famicom Jump II - Saikyou no 7 Nin (Japan)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_famicjumiiRomInfo, nes_famicjumiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Famicom Wars (Japan)
static struct BurnRomInfo nes_famicomwarsjRomDesc[] = {
	{ "Famicom Wars (Japan).nes",          196624, 0x29f3a0f7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_famicomwarsj)
STD_ROM_FN(nes_famicomwarsj)

struct BurnDriver BurnDrvnes_famicomwarsj = {
	"nes_famicomwarsj", "nes_famicomwars", NULL, NULL, "1988",
	"Famicom Wars (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_famicomwarsjRomInfo, nes_famicomwarsjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Famicom Wars (Hack, English)
static struct BurnRomInfo nes_famicomwarsRomDesc[] = {
	{ "Famicom Wars (T-Eng).nes",          196624, 0x896759d8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_famicomwars)
STD_ROM_FN(nes_famicomwars)

struct BurnDriver BurnDrvnes_famicomwars = {
	"nes_famicomwars", NULL, NULL, NULL, "2016",
	"Famicom Wars (Hack, English)\0", NULL, "Spinner 8 and friends", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_famicomwarsRomInfo, nes_famicomwarsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// NES Wars (Hack, English)
// https://www.romhacking.net/translations/6828/
static struct BurnRomInfo nes_neswarsRomDesc[] = {
	{ "NES Wars T-Eng (2023)(Stardust Crusaders).nes",          196624, 0x35da4b73, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_neswars)
STD_ROM_FN(nes_neswars)

struct BurnDriver BurnDrvnes_neswars = {
	"nes_neswars", "nes_famicomwars", NULL, NULL, "2023",
	"NES Wars (Hack, English)\0", NULL, "Stardust Crusaders", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_neswarsRomInfo, nes_neswarsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Family Boxing (Japan)
static struct BurnRomInfo nes_familyboxingRomDesc[] = {
	{ "Family Boxing (Japan).nes",          131088, 0x381b51f3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_familyboxing)
STD_ROM_FN(nes_familyboxing)

struct BurnDriver BurnDrvnes_familyboxing = {
	"nes_familyboxing", NULL, NULL, NULL, "1987",
	"Family Boxing (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_familyboxingRomInfo, nes_familyboxingRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Family Circuit '91 (Japan)
static struct BurnRomInfo nes_familcir91RomDesc[] = {
	{ "Family Circuit '91 (Japan).nes",          655376, 0xcfbb646d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_familcir91)
STD_ROM_FN(nes_familcir91)

struct BurnDriver BurnDrvnes_familcir91 = {
	"nes_familcir91", NULL, NULL, NULL, "1991",
	"Family Circuit '91 (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_familcir91RomInfo, nes_familcir91RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Family Circuit (Japan)
static struct BurnRomInfo nes_familycircuitjRomDesc[] = {
	{ "Family Circuit (Japan).nes",          163856, 0x51ce0655, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_familycircuitj)
STD_ROM_FN(nes_familycircuitj)

struct BurnDriver BurnDrvnes_familycircuitj = {
	"nes_familycircuitj", "nes_familycircuit", NULL, NULL, "1988",
	"Family Circuit (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_familycircuitjRomInfo, nes_familycircuitjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Family Circuit (Hack, English)
static struct BurnRomInfo nes_familycircuitRomDesc[] = {
	{ "Family Circuit (T-Eng).nes",          163856, 0xe44892f7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_familycircuit)
STD_ROM_FN(nes_familycircuit)

struct BurnDriver BurnDrvnes_familycircuit = {
	"nes_familycircuit", NULL, NULL, NULL, "2016",
	"Family Circuit (Hack, English)\0", NULL, "MrRichard999", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_familycircuitRomInfo, nes_familycircuitRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Family Pinball (Japan)
static struct BurnRomInfo nes_familypinballRomDesc[] = {
	{ "Family Pinball (Japan).nes",          196624, 0x0da8a7b2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_familypinball)
STD_ROM_FN(nes_familypinball)

struct BurnDriver BurnDrvnes_familypinball = {
	"nes_familypinball", NULL, NULL, NULL, "1989",
	"Family Pinball (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PINBALL, 0,
	NESGetZipName, nes_familypinballRomInfo, nes_familypinballRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Famista '89 (Japan)
static struct BurnRomInfo nes_famista89RomDesc[] = {
	{ "Famista '89 (Japan).nes",          196624, 0x62b90039, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_famista89)
STD_ROM_FN(nes_famista89)

struct BurnDriver BurnDrvnes_famista89 = {
	"nes_famista89", NULL, NULL, NULL, "1989",
	"Famista '89 (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_famista89RomInfo, nes_famista89RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Famista '90 (Japan)
static struct BurnRomInfo nes_famista90RomDesc[] = {
	{ "Famista '90 (Japan).nes",          262160, 0xc942dfe9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_famista90)
STD_ROM_FN(nes_famista90)

struct BurnDriver BurnDrvnes_famista90 = {
	"nes_famista90", NULL, NULL, NULL, "1989",
	"Famista '90 (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_famista90RomInfo, nes_famista90RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Famista '91 (Japan)
static struct BurnRomInfo nes_famista91RomDesc[] = {
	{ "Famista '91 (Japan).nes",          262160, 0x7195ca38, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_famista91)
STD_ROM_FN(nes_famista91)

struct BurnDriver BurnDrvnes_famista91 = {
	"nes_famista91", NULL, NULL, NULL, "1990",
	"Famista '91 (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_famista91RomInfo, nes_famista91RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Famista '92 (Japan)
static struct BurnRomInfo nes_famista92RomDesc[] = {
	{ "Famista '92 (Japan).nes",          262160, 0xfb6bdb9d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_famista92)
STD_ROM_FN(nes_famista92)

struct BurnDriver BurnDrvnes_famista92 = {
	"nes_famista92", NULL, NULL, NULL, "1991",
	"Famista '92 (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_famista92RomInfo, nes_famista92RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Famista '93 (Japan)
static struct BurnRomInfo nes_famista93RomDesc[] = {
	{ "Famista '93 (Japan).nes",          262160, 0x38511037, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_famista93)
STD_ROM_FN(nes_famista93)

struct BurnDriver BurnDrvnes_famista93 = {
	"nes_famista93", NULL, NULL, NULL, "1992",
	"Famista '93 (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_famista93RomInfo, nes_famista93RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Famista '93 (Hack, English)
// https://www.romhacking.net/
static struct BurnRomInfo nes_famista93eRomDesc[] = {
	{ "famista '93 (t-eng).nes",          262160, 0xd9301c12, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_famista93e)
STD_ROM_FN(nes_famista93e)

struct BurnDriver BurnDrvnes_famista93e = {
	"nes_famista93e", "nes_famista93", NULL, NULL, "20??",
	"Famista '93 (Hack, English)\0", NULL, "FlashPV", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_famista93eRomInfo, nes_famista93eRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Famista '94 (Japan)
static struct BurnRomInfo nes_famista94RomDesc[] = {
	{ "Famista '94 (Japan).nes",          262160, 0xd73fc5b1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_famista94)
STD_ROM_FN(nes_famista94)

struct BurnDriver BurnDrvnes_famista94 = {
	"nes_famista94", NULL, NULL, NULL, "1993",
	"Famista '94 (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_famista94RomInfo, nes_famista94RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Fantastic Adventures of Dizzy, The (USA)
static struct BurnRomInfo nes_fantaadvdizRomDesc[] = {
	{ "Fantastic Adventures of Dizzy, The (USA).nes",          262160, 0x59318584, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_fantaadvdiz)
STD_ROM_FN(nes_fantaadvdiz)

struct BurnDriver BurnDrvnes_fantaadvdiz = {
	"nes_fantaadvdiz", NULL, NULL, NULL, "1991",
	"Fantastic Adventures of Dizzy, The (USA)\0", NULL, "Camerica", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_fantaadvdizRomInfo, nes_fantaadvdizRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Fantasy Zone (Japan)
static struct BurnRomInfo nes_fantasyzonejRomDesc[] = {
	{ "Fantasy Zone (Japan).nes",          131088, 0xdd119b43, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_fantasyzonej)
STD_ROM_FN(nes_fantasyzonej)

struct BurnDriver BurnDrvnes_fantasyzonej = {
	"nes_fantasyzonej", "nes_fantasyzone", NULL, NULL, "1987",
	"Fantasy Zone (Japan)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_fantasyzonejRomInfo, nes_fantasyzonejRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Fantasy Zone (USA)
static struct BurnRomInfo nes_fantasyzoneRomDesc[] = {
	{ "Fantasy Zone (Tengen) (USA).nes",          131088, 0x9c546b0b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_fantasyzone)
STD_ROM_FN(nes_fantasyzone)

struct BurnDriver BurnDrvnes_fantasyzone = {
	"nes_fantasyzone", NULL, NULL, NULL, "1989",
	"Fantasy Zone (USA)\0", NULL, "Tengen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_fantasyzoneRomInfo, nes_fantasyzoneRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Fantasy Zone II - Opa-Opa no Namida (Japan)
static struct BurnRomInfo nes_fantazoniiRomDesc[] = {
	{ "Fantasy Zone II - Opa-Opa no Namida (Japan).nes",          262160, 0x6faf6db1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_fantazonii)
STD_ROM_FN(nes_fantazonii)

struct BurnDriver BurnDrvnes_fantazonii = {
	"nes_fantazonii", NULL, NULL, NULL, "1988",
	"Fantasy Zone II - Opa-Opa no Namida (Japan)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_fantazoniiRomInfo, nes_fantazoniiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_fariaRomDesc[] = {
	{ "Faria - A World of Mystery & Danger! (USA).nes",          262160, 0x1c059dfb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_faria)
STD_ROM_FN(nes_faria)

struct BurnDriver BurnDrvnes_faria = {
	"nes_faria", NULL, NULL, NULL, "1991",
	"Faria - A World of Mystery & Danger! (USA)\0", NULL, "Nexoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_fariaRomInfo, nes_fariaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_fariajRomDesc[] = {
	{ "Faria - Fuuin no Tsurugi (Japan).nes",          262160, 0xa17079e4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_fariaj)
STD_ROM_FN(nes_fariaj)

struct BurnDriver BurnDrvnes_fariaj = {
	"nes_fariaj", "nes_faria", NULL, NULL, "1989",
	"Faria - Fuuin no Tsurugi (Japan)\0", NULL, "Game Arts", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_fariajRomInfo, nes_fariajRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Faxanadu (Japan)
static struct BurnRomInfo nes_faxanadujRomDesc[] = {
	{ "Faxanadu (Japan).nes",          262160, 0xf9e6e6ad, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_faxanaduj)
STD_ROM_FN(nes_faxanaduj)

struct BurnDriver BurnDrvnes_faxanaduj = {
	"nes_faxanaduj", "nes_faxanadu", NULL, NULL, "1987",
	"Faxanadu (Japan)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_faxanadujRomInfo, nes_faxanadujRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Faxanadu (Hack, English)
static struct BurnRomInfo nes_faxanadutRomDesc[] = {
	{ "Faxanadu (T-Eng).nes",          524304, 0xed0a6836, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_faxanadut)
STD_ROM_FN(nes_faxanadut)

struct BurnDriver BurnDrvnes_faxanadut = {
	"nes_faxanadut", "nes_faxanadu", NULL, NULL, "2019",
	"Faxanadu (Hack, English)\0", NULL, "Unsavory Maggot", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_faxanadutRomInfo, nes_faxanadutRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Faxanadu (USA) (Rev A)
static struct BurnRomInfo nes_faxanaduRomDesc[] = {
	{ "Faxanadu (USA) (Rev A).nes",          262160, 0xb6f4f544, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_faxanadu)
STD_ROM_FN(nes_faxanadu)

struct BurnDriver BurnDrvnes_faxanadu = {
	"nes_faxanadu", NULL, NULL, NULL, "1989",
	"Faxanadu (USA) (Rev A)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_faxanaduRomInfo, nes_faxanaduRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Felix the Cat (USA)
static struct BurnRomInfo nes_felixthecatRomDesc[] = {
	{ "Felix the Cat (USA).nes",          262160, 0x0639e88e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_felixthecat)
STD_ROM_FN(nes_felixthecat)

struct BurnDriver BurnDrvnes_felixthecat = {
	"nes_felixthecat", NULL, NULL, NULL, "1992",
	"Felix the Cat (USA)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_felixthecatRomInfo, nes_felixthecatRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ferrari Grand Prix Challenge (USA)
static struct BurnRomInfo nes_ferragraprichaRomDesc[] = {
	{ "Ferrari Grand Prix Challenge (USA).nes",          262160, 0xa3c49590, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ferragrapricha)
STD_ROM_FN(nes_ferragrapricha)

struct BurnDriver BurnDrvnes_ferragrapricha = {
	"nes_ferragrapricha", NULL, NULL, NULL, "1992",
	"Ferrari Grand Prix Challenge (USA)\0", NULL, "Acclaim", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_ferragraprichaRomInfo, nes_ferragraprichaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Fester's Quest (USA)
static struct BurnRomInfo nes_festersquestRomDesc[] = {
	{ "Fester's Quest (USA).nes",          262160, 0xdb0c7019, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_festersquest)
STD_ROM_FN(nes_festersquest)

struct BurnDriver BurnDrvnes_festersquest = {
	"nes_festersquest", NULL, NULL, NULL, "1989",
	"Fester's Quest (USA)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_ADV, 0,
	NESGetZipName, nes_festersquestRomInfo, nes_festersquestRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Field Combat (Japan)
static struct BurnRomInfo nes_fieldcombatRomDesc[] = {
	{ "Field Combat (Japan).nes",          24592, 0x90d93924, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_fieldcombat)
STD_ROM_FN(nes_fieldcombat)

struct BurnDriver BurnDrvnes_fieldcombat = {
	"nes_fieldcombat", NULL, NULL, NULL, "1985",
	"Field Combat (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_fieldcombatRomInfo, nes_fieldcombatRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Fighting Golf (Japan)
static struct BurnRomInfo nes_fightinggolfRomDesc[] = {
	{ "Fighting Golf (Japan).nes",          262160, 0xeebbdff9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_fightinggolf)
STD_ROM_FN(nes_fightinggolf)

struct BurnDriver BurnDrvnes_fightinggolf = {
	"nes_fightinggolf", NULL, NULL, NULL, "1988",
	"Fighting Golf (Japan)\0", NULL, "SNK", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_fightinggolfRomInfo, nes_fightinggolfRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Fighting Hero (Unl)
static struct BurnRomInfo nes_fightingheroRomDesc[] = {
	{ "Fighting Hero (Unl).nes",          393232, 0x2093f0e1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_fightinghero)
STD_ROM_FN(nes_fightinghero)

struct BurnDriver BurnDrvnes_fightinghero = {
	"nes_fightinghero", NULL, NULL, NULL, "1991",
	"Fighting Hero (Unl)\0", NULL, "Mega Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_fightingheroRomInfo, nes_fightingheroRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Fighting Hero III (Unl)
static struct BurnRomInfo nes_fightheriiiRomDesc[] = {
	{ "Fighting Hero III (Unl).nes",          786448, 0x52b2045f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_fightheriii)
STD_ROM_FN(nes_fightheriii)

struct BurnDriver BurnDrvnes_fightheriii = {
	"nes_fightheriii", NULL, NULL, NULL, "1993",
	"Fighting Hero III (Unl)\0", NULL, "NTDEC", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_fightheriiiRomInfo, nes_fightheriiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Fighting Road (Japan)
static struct BurnRomInfo nes_fightingroadjRomDesc[] = {
	{ "Fighting Road (Japan).nes",          262160, 0xbdde0fd7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_fightingroadj)
STD_ROM_FN(nes_fightingroadj)

struct BurnDriver BurnDrvnes_fightingroadj = {
	"nes_fightingroadj", "nes_fightingroad", NULL, NULL, "1988",
	"Fighting Road (Japan)\0", NULL, "Toei Animation", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_fightingroadjRomInfo, nes_fightingroadjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Fighting Road (Hack, English)
static struct BurnRomInfo nes_fightingroadRomDesc[] = {
	{ "Fighting Road (T-Eng).nes",          262160, 0x3b9e7aa1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_fightingroad)
STD_ROM_FN(nes_fightingroad)

struct BurnDriver BurnDrvnes_fightingroad = {
	"nes_fightingroad", NULL, NULL, NULL, "2016",
	"Fighting Road (Hack, English)\0", NULL, "Immutable", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_fightingroadRomInfo, nes_fightingroadRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Final Combat (Unl) (Asia)
static struct BurnRomInfo nes_finalcombatRomDesc[] = {
	{ "Final Combat (Asia) (NTSC) (Unl).nes",          81936, 0xa7afcc45, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_finalcombat)
STD_ROM_FN(nes_finalcombat)

struct BurnDriver BurnDrvnes_finalcombat = {
	"nes_finalcombat", NULL, NULL, NULL, "1992",
	"Final Combat (Unl) (Asia)\0", NULL, "Sachen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_finalcombatRomInfo, nes_finalcombatRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Final Fantasy (USA)
static struct BurnRomInfo nes_finalfantasyRomDesc[] = {
	{ "Final Fantasy (USA).nes",          262160, 0x5c892f3b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_finalfantasy)
STD_ROM_FN(nes_finalfantasy)

struct BurnDriver BurnDrvnes_finalfantasy = {
	"nes_finalfantasy", NULL, NULL, NULL, "1990",
	"Final Fantasy (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_finalfantasyRomInfo, nes_finalfantasyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Final Fantasy 1 & 2 (Japan)
static struct BurnRomInfo nes_finalfan12jRomDesc[] = {
	{ "Final Fantasy 1 & 2 (Japan).nes",          524304, 0x6f8906ad, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_finalfan12j)
STD_ROM_FN(nes_finalfan12j)

struct BurnDriver BurnDrvnes_finalfan12j = {
	"nes_finalfan12j", "nes_finalfan12", NULL, NULL, "1994",
	"Final Fantasy 1 & 2 (Japan)\0", NULL, "Square", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_finalfan12jRomInfo, nes_finalfan12jRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Final Fantasy 1 & 2 (Hack, English)
static struct BurnRomInfo nes_finalfan12RomDesc[] = {
	{ "Final Fantasy 1 & 2 (T-eng).nes",          524304, 0x6f5f3bd2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_finalfan12)
STD_ROM_FN(nes_finalfan12)

struct BurnDriver BurnDrvnes_finalfan12 = {
	"nes_finalfan12", NULL, NULL, NULL, "2016",
	"Final Fantasy 1 & 2 (Hack, English)\0", NULL, "Demiforce", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_finalfan12RomInfo, nes_finalfan12RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Final Fantasy II (USA) (Prototype)
static struct BurnRomInfo nes_finalfantasyiiRomDesc[] = {
	{ "Final Fantasy II (USA) (Proto).nes",          262160, 0xf60d282c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_finalfantasyii)
STD_ROM_FN(nes_finalfantasyii)

struct BurnDriver BurnDrvnes_finalfantasyii = {
	"nes_finalfantasyii", NULL, NULL, NULL, "1991",
	"Final Fantasy II (USA) (Prototype)\0", NULL, "Square", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_PROTOTYPE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_finalfantasyiiRomInfo, nes_finalfantasyiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Final Fantasy III (Japan)
static struct BurnRomInfo nes_finalfaniiiRomDesc[] = {
	{ "Final Fantasy III (Japan).nes",          524304, 0x99f5db31, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_finalfaniii)
STD_ROM_FN(nes_finalfaniii)

struct BurnDriver BurnDrvnes_finalfaniii = {
	"nes_finalfaniii", NULL, NULL, NULL, "1990",
	"Final Fantasy III (Japan)\0", NULL, "Square", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_finalfaniiiRomInfo, nes_finalfaniiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Final Fantasy VII (China) (Unl)
static struct BurnRomInfo nes_finalfanviiRomDesc[] = {
	{ "Final Fantasy VII (China).nes",          2097168, 0xe5bf8f0c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_finalfanvii)
STD_ROM_FN(nes_finalfanvii)

struct BurnDriver BurnDrvnes_finalfanvii = {
	"nes_finalfanvii", "nes_finalfanviiadvch", NULL, NULL, "2005",
	"Final Fantasy VII (China) (Unl)\0", NULL, "ShenZhen Nanjing Technology", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_finalfanviiRomInfo, nes_finalfanviiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Final Fantasy VII - Advent Children (Hack, English)
static struct BurnRomInfo nes_finalfanviiadvchRomDesc[] = {
	{ "Final Fantasy VII - Advent Children (T-Eng).nes",          2097168, 0x8de6d62f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_finalfanviiadvch)
STD_ROM_FN(nes_finalfanviiadvch)

struct BurnDriver BurnDrvnes_finalfanviiadvch = {
	"nes_finalfanviiadvch", NULL, NULL, NULL, "2015",
	"Final Fantasy VII - Advent Children (Hack, English)\0", NULL, "Lindblum", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_finalfanviiadvchRomInfo, nes_finalfanviiadvchRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Final Fight 3 (Unl)
static struct BurnRomInfo nes_finalfight3RomDesc[] = {
	{ "Final Fight 3 (Unl).nes",          786448, 0x97f05116, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_finalfight3)
STD_ROM_FN(nes_finalfight3)

struct BurnDriver BurnDrvnes_finalfight3 = {
	"nes_finalfight3", NULL, NULL, NULL, "1998",
	"Final Fight 3 (Unl)\0", NULL, "J.Y. Company", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_finalfight3RomInfo, nes_finalfight3RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Final Lap (Japan)
static struct BurnRomInfo nes_finallapRomDesc[] = {
	{ "Final Lap (Japan).nes",          262160, 0xa65568a9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_finallap)
STD_ROM_FN(nes_finallap)

struct BurnDriver BurnDrvnes_finallap = {
	"nes_finallap", NULL, NULL, NULL, "1988",
	"Final Lap (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_finallapRomInfo, nes_finallapRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Final Mission (Japan)
static struct BurnRomInfo nes_finalmissionjRomDesc[] = {
	{ "Final Mission (Japan).nes",          262160, 0xb8273b87, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_finalmissionj)
STD_ROM_FN(nes_finalmissionj)

struct BurnDriver BurnDrvnes_finalmissionj = {
	"nes_finalmissionj", "nes_scat", NULL, NULL, "1990",
	"Final Mission (Japan)\0", NULL, "Natsume", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_finalmissionjRomInfo, nes_finalmissionjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Final Mission (Hack, English)
static struct BurnRomInfo nes_finalmissionRomDesc[] = {
	{ "Final Mission (T-Eng).nes",          393232, 0x01c4633e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_finalmission)
STD_ROM_FN(nes_finalmission)

struct BurnDriver BurnDrvnes_finalmission = {
	"nes_finalmission", "nes_scat", NULL, NULL, "1990",
	"Final Mission (Hack, English)\0", NULL, "Natsume", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_finalmissionRomInfo, nes_finalmissionRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Fire 'n Ice (USA)
static struct BurnRomInfo nes_fireniceRomDesc[] = {
	{ "Fire 'n Ice (USA).nes",          262160, 0x083c02c1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_firenice)
STD_ROM_FN(nes_firenice)

struct BurnDriver BurnDrvnes_firenice = {
	"nes_firenice", NULL, NULL, NULL, "1993",
	"Fire 'n Ice (USA)\0", NULL, "Tecmo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PUZZLE | GBF_PLATFORM, 0,
	NESGetZipName, nes_fireniceRomInfo, nes_fireniceRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Fire 'n Ice - The Lost Levels (Hack, v1.1)
static struct BurnRomInfo nes_firenicellRomDesc[] = {
	{ "Fire 'n Ice - The Lost Levels v1.1 (2021)(Renaldo).nes",          262160, 0x99e61dff, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_firenicell)
STD_ROM_FN(nes_firenicell)

struct BurnDriver BurnDrvnes_firenicell = {
	"nes_firenicell", "nes_firenice", NULL, NULL, "2021",
	"Fire 'n Ice - The Lost Levels (Hack, v1.1)\0", NULL, "Renaldo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PUZZLE | GBF_PLATFORM, 0,
	NESGetZipName, nes_firenicellRomInfo, nes_firenicellRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Sangokushi - Chuugen no Hasha (Japan)
static struct BurnRomInfo nes_sangokushiRomDesc[] = {
	{ "Sangokushi - Chuugen no Hasha (Japan).nes",          262160, 0x231ec446, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sangokushi)
STD_ROM_FN(nes_sangokushi)

struct BurnDriver BurnDrvnes_sangokushi = {
	"nes_sangokushi", NULL, NULL, NULL, "1988",
	"Sangokushi - Chuugen no Hasha (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_sangokushiRomInfo, nes_sangokushiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Solomon no Kagi 2 - Coolmintou Kyuushutsu Sakusen (Japan)
static struct BurnRomInfo nes_solonokagi2RomDesc[] = {
	{ "Solomon no Kagi 2 - Coolmintou Kyuushutsu Sakusen (Jpn)(1992)(Tecmo).nes",          262160, 0xf033b827, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_solonokagi2)
STD_ROM_FN(nes_solonokagi2)

struct BurnDriver BurnDrvnes_solonokagi2 = {
	"nes_solonokagi2", "nes_firenice", NULL, NULL, "1992",
	"Solomon no Kagi 2 - Coolmintou Kyuushutsu Sakusen (Japan)\0", NULL, "Tecmo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM | GBF_PUZZLE | GBF_PLATFORM, 0,
	NESGetZipName, nes_solonokagi2RomInfo, nes_solonokagi2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Solomon no Kagi 2 - Kitsune Attacks! (Hack, v1.6)
// http://www.romhacking.net/hacks/5940/
static struct BurnRomInfo nes_solonokagi2hRomDesc[] = {
	{ "Solomon no Kagi 2 - Kitsune Attacks! (Hack, v1.6).nes",          262160, 0x039d14fd, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_solonokagi2h)
STD_ROM_FN(nes_solonokagi2h)

struct BurnDriver BurnDrvnes_solonokagi2h = {
	"nes_solonokagi2h", "nes_firenice", NULL, NULL, "2022",
	"Solomon no Kagi 2 - Kitsune Attacks! (Hack, v1.6)\0", "100 new levels", "FoxyShadow", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_PUZZLE | GBF_PLATFORM, 0,
	NESGetZipName, nes_solonokagi2hRomInfo, nes_solonokagi2hRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Fire Emblem - Ankoku Ryuu to Hikari no Tsurugi (Japan)
static struct BurnRomInfo nes_fireembjRomDesc[] = {
	{ "Fire Emblem - Ankoku Ryuu to Hikari no Tsurugi (Japan).nes",          393232, 0xab8057b9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_fireembj)
STD_ROM_FN(nes_fireembj)

struct BurnDriver BurnDrvnes_fireembj = {
	"nes_fireembj", "nes_fireemb", NULL, NULL, "1990",
	"Fire Emblem - Ankoku Ryuu to Hikari no Tsurugi (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_STRATEGY | GBF_RPG, 0,
	NESGetZipName, nes_fireembjRomInfo, nes_fireembjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Fire Emblem - Ankoku Ryuu to Hikari no Tsurugi (Hack, English)
// https://www.romhacking.net/translations/1593/
static struct BurnRomInfo nes_fireembRomDesc[] = {
	{ "Fire Emblem - Ankoku Ryuu to Hikari no Tsurugi (T-Eng).nes",          393232, 0xdc848ddd, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_fireemb)
STD_ROM_FN(nes_fireemb)

struct BurnDriver BurnDrvnes_fireemb = {
	"nes_fireemb", NULL, NULL, NULL, "2011",
	"Fire Emblem - Ankoku Ryuu to Hikari no Tsurugi (Hack, English)\0", NULL, "Quirino", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_STRATEGY | GBF_RPG, 0,
	NESGetZipName, nes_fireembRomInfo, nes_fireembRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Fire Emblem Gaiden (Japan)
static struct BurnRomInfo nes_fireembgaijRomDesc[] = {
	{ "Fire Emblem Gaiden (Japan).nes",          393232, 0x0a187cb4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_fireembgaij)
STD_ROM_FN(nes_fireembgaij)

struct BurnDriver BurnDrvnes_fireembgaij = {
	"nes_fireembgaij", "nes_fireembgai", NULL, NULL, "1992",
	"Fire Emblem Gaiden (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_STRATEGY | GBF_RPG, 0,
	NESGetZipName, nes_fireembgaijRomInfo, nes_fireembgaijRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Fire Emblem Gaiden (Hack, English)
// https://www.romhacking.net/translations/1445/
static struct BurnRomInfo nes_fireembgaiRomDesc[] = {
	{ "Fire Emblem Gaiden (T-Eng).nes",          393232, 0xed74e1fa, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_fireembgai)
STD_ROM_FN(nes_fireembgai)

struct BurnDriver BurnDrvnes_fireembgai = {
	"nes_fireembgai", NULL, NULL, NULL, "2009",
	"Fire Emblem Gaiden (Hack, English)\0", NULL, "Artemis251", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_STRATEGY | GBF_RPG, 0,
	NESGetZipName, nes_fireembgaiRomInfo, nes_fireembgaiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Fire Hawk (USA) (Unl)
static struct BurnRomInfo nes_firehawkRomDesc[] = {
	{ "Fire Hawk (USA) (Unl).nes",          131088, 0xa2259bd3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_firehawk)
STD_ROM_FN(nes_firehawk)

struct BurnDriver BurnDrvnes_firehawk = {
	"nes_firehawk", NULL, NULL, NULL, "1991",
	"Fire Hawk (USA) (Unl)\0", NULL, "Camerica", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_firehawkRomInfo, nes_firehawkRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Firehouse Rescue (USA)
static struct BurnRomInfo nes_firehouserescueRomDesc[] = {
	{ "Firehouse Rescue (USA).nes",          65552, 0x77bf765f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_firehouserescue)
STD_ROM_FN(nes_firehouserescue)

struct BurnDriver BurnDrvnes_firehouserescue = {
	"nes_firehouserescue", NULL, NULL, NULL, "1992",
	"Firehouse Rescue (USA)\0", NULL, "GameTek", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_firehouserescueRomInfo, nes_firehouserescueRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Fist of the North Star (USA)
static struct BurnRomInfo nes_fistnorstaRomDesc[] = {
	{ "Fist of the North Star (USA).nes",          131088, 0x35deffb7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_fistnorsta)
STD_ROM_FN(nes_fistnorsta)

struct BurnDriver BurnDrvnes_fistnorsta = {
	"nes_fistnorsta", NULL, NULL, NULL, "1989",
	"Fist of the North Star (USA)\0", NULL, "Taxan", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_fistnorstaRomInfo, nes_fistnorstaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Flappy (Japan)
static struct BurnRomInfo nes_flappyRomDesc[] = {
	{ "Flappy (Japan).nes",          40976, 0x31ad3838, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_flappy)
STD_ROM_FN(nes_flappy)

struct BurnDriver BurnDrvnes_flappy = {
	"nes_flappy", NULL, NULL, NULL, "1985",
	"Flappy (Japan)\0", NULL, "dB-SOFT", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_flappyRomInfo, nes_flappyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Flight of the Intruder (USA)
static struct BurnRomInfo nes_flighintRomDesc[] = {
	{ "Flight of the Intruder (USA).nes",          131088, 0xca2234c6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_flighint)
STD_ROM_FN(nes_flighint)

struct BurnDriver BurnDrvnes_flighint = {
	"nes_flighint", NULL, NULL, NULL, "1991",
	"Flight of the Intruder (USA)\0", NULL, "Mindscape", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SIM, 0,
	NESGetZipName, nes_flighintRomInfo, nes_flighintRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Flintstones, The - The Rescue of Dino & Hoppy (Japan)
static struct BurnRomInfo nes_flintresdinhopjRomDesc[] = {
	{ "Flintstones, The - The Rescue of Dino & Hoppy (Japan).nes",          393232, 0x12f38740, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_flintresdinhopj)
STD_ROM_FN(nes_flintresdinhopj)

struct BurnDriver BurnDrvnes_flintresdinhopj = {
	"nes_flintresdinhopj", "nes_flintresdinhop", NULL, NULL, "1991",
	"Flintstones, The - The Rescue of Dino & Hoppy (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_flintresdinhopjRomInfo, nes_flintresdinhopjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Flintstones, The - The Rescue of Dino & Hoppy (USA)
static struct BurnRomInfo nes_flintresdinhopRomDesc[] = {
	{ "Flintstones, The - The Rescue of Dino & Hoppy (USA).nes",          393232, 0x0b804cdc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_flintresdinhop)
STD_ROM_FN(nes_flintresdinhop)

struct BurnDriver BurnDrvnes_flintresdinhop = {
	"nes_flintresdinhop", NULL, NULL, NULL, "1991",
	"Flintstones, The - The Rescue of Dino & Hoppy (USA)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_flintresdinhopRomInfo, nes_flintresdinhopRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Flintstones, The - The Surprise at Dinosaur Peak! (USA)
static struct BurnRomInfo nes_flintsuratdinpeRomDesc[] = {
	{ "Flintstones, The - The Surprise at Dinosaur Peak! (USA).nes",          393232, 0xfeda0b39, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_flintsuratdinpe)
STD_ROM_FN(nes_flintsuratdinpe)

struct BurnDriver BurnDrvnes_flintsuratdinpe = {
	"nes_flintsuratdinpe", NULL, NULL, NULL, "1994",
	"Flintstones, The - The Surprise at Dinosaur Peak! (USA)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_flintsuratdinpeRomInfo, nes_flintsuratdinpeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Flipull - An Exciting Cube Game (Japan)
static struct BurnRomInfo nes_flipullRomDesc[] = {
	{ "Flipull - An Exciting Cube Game (Japan).nes",          65552, 0xb0e199e3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_flipull)
STD_ROM_FN(nes_flipull)

struct BurnDriver BurnDrvnes_flipull = {
	"nes_flipull", NULL, NULL, NULL, "1989",
	"Flipull - An Exciting Cube Game (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_flipullRomInfo, nes_flipullRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Flying Dragon - The Secret Scroll (USA)
static struct BurnRomInfo nes_flyindraRomDesc[] = {
	{ "Flying Dragon - The Secret Scroll (USA).nes",          131088, 0xc2f70a8c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_flyindra)
STD_ROM_FN(nes_flyindra)

struct BurnDriver BurnDrvnes_flyindra = {
	"nes_flyindra", NULL, NULL, NULL, "1989",
	"Flying Dragon - The Secret Scroll (USA)\0", NULL, "Culture Brain", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_flyindraRomInfo, nes_flyindraRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Flying Hero (Japan)
static struct BurnRomInfo nes_flyingheroRomDesc[] = {
	{ "Flying Hero (Japan).nes",          131088, 0x358277ef, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_flyinghero)
STD_ROM_FN(nes_flyinghero)

struct BurnDriver BurnDrvnes_flyinghero = {
	"nes_flyinghero", NULL, NULL, NULL, "1989",
	"Flying Hero (Japan)\0", NULL, "ASCII Corp.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_flyingheroRomInfo, nes_flyingheroRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Flying Warriors (USA)
static struct BurnRomInfo nes_flyingwarriorsRomDesc[] = {
	{ "Flying Warriors (USA).nes",          262160, 0x7dab215c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_flyingwarriors)
STD_ROM_FN(nes_flyingwarriors)

struct BurnDriver BurnDrvnes_flyingwarriors = {
	"nes_flyingwarriors", NULL, NULL, NULL, "1991",
	"Flying Warriors (USA)\0", NULL, "Culture Brain", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_flyingwarriorsRomInfo, nes_flyingwarriorsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Formation Z (Japan) (Rev A)
static struct BurnRomInfo nes_formationzRomDesc[] = {
	{ "Formation Z (Japan) (Rev A).nes",          24592, 0x629eae68, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_formationz)
STD_ROM_FN(nes_formationz)

struct BurnDriver BurnDrvnes_formationz = {
	"nes_formationz", NULL, NULL, NULL, "1985",
	"Formation Z (Japan) (Rev A)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_formationzRomInfo, nes_formationzRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Formula One - Built To Win (USA)
static struct BurnRomInfo nes_formuoneRomDesc[] = {
	{ "Formula One - Built To Win (USA).nes",          262160, 0x037eed7d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_formuone)
STD_ROM_FN(nes_formuone)

struct BurnDriver BurnDrvnes_formuone = {
	"nes_formuone", NULL, NULL, NULL, "1990",
	"Formula One - Built To Win (USA)\0", NULL, "Seta", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_formuoneRomInfo, nes_formuoneRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Frankenstein - The Monster Returns (USA)
static struct BurnRomInfo nes_frankRomDesc[] = {
	{ "Frankenstein - The Monster Returns (USA).nes",          262160, 0x84f0cd63, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_frank)
STD_ROM_FN(nes_frank)

struct BurnDriver BurnDrvnes_frank = {
	"nes_frank", NULL, NULL, NULL, "1991",
	"Frankenstein - The Monster Returns (USA)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, nes_frankRomInfo, nes_frankRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_freefallRomDesc[] = {
	{ "Free Fall (USA) (Proto).nes",          131088, 0x913ec888, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_freefall)
STD_ROM_FN(nes_freefall)

struct BurnDriver BurnDrvnes_freefall = {
	"nes_freefall", NULL, NULL, NULL, "199?",
	"Free Fall (USA) (Prototype)\0", NULL, "Color Dreams", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_PROTOTYPE, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_freefallRomInfo, nes_freefallRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_freedomforceRomDesc[] = {
	{ "Freedom Force (USA).nes",          262160, 0x53eb8950, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_freedomforce)
STD_ROM_FN(nes_freedomforce)

struct BurnDriver BurnDrvnes_freedomforce = {
	"nes_freedomforce", NULL, NULL, NULL, "1988",
	"Freedom Force (USA)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_freedomforceRomInfo, nes_freedomforceRomName, NULL, NULL, NULL, NULL, NESZapperInputInfo, NESZapperDIPInfo,
	NESZapperInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_fridaythe13thRomDesc[] = {
	{ "Friday the 13th (USA).nes",          65552, 0xf19a4249, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_fridaythe13th)
STD_ROM_FN(nes_fridaythe13th)

struct BurnDriver BurnDrvnes_fridaythe13th = {
	"nes_fridaythe13th", NULL, NULL, NULL, "1989",
	"Friday the 13th (USA)\0", NULL, "Ljn", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ADV | GBF_PLATFORM, 0,
	NESGetZipName, nes_fridaythe13thRomInfo, nes_fridaythe13thRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_frontlineRomDesc[] = {
	{ "Front Line (Japan).nes",          24592, 0x44d123a4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_frontline)
STD_ROM_FN(nes_frontline)

struct BurnDriver BurnDrvnes_frontline = {
	"nes_frontline", NULL, NULL, NULL, "1985",
	"Front Line (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_frontlineRomInfo, nes_frontlineRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_fudoumyououdenRomDesc[] = {
	{ "Fudou Myouou Den (Japan).nes",          393232, 0x64d10448, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_fudoumyououden)
STD_ROM_FN(nes_fudoumyououden)

struct BurnDriver BurnDrvnes_fudoumyououden = {
	"nes_fudoumyououden", "nes_demonsword", NULL, NULL, "1988",
	"Fudou Myouou Den (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM | GBF_RUNGUN, 0,
	NESGetZipName, nes_fudoumyououdenRomInfo, nes_fudoumyououdenRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_funhouseRomDesc[] = {
	{ "Fun House (USA).nes",          131088, 0x6463dedc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_funhouse)
STD_ROM_FN(nes_funhouse)

struct BurnDriver BurnDrvnes_funhouse = {
	"nes_funhouse", NULL, NULL, NULL, "1991",
	"Fun House (USA)\0", NULL, "Hi Tech Expressions", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_funhouseRomInfo, nes_funhouseRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Fuzzical Fighter (Japan)
static struct BurnRomInfo nes_fuzzicalfighterjRomDesc[] = {
	{ "Fuzzical Fighter (Japan).nes",          262160, 0x74b7e648, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_fuzzicalfighterj)
STD_ROM_FN(nes_fuzzicalfighterj)

struct BurnDriver BurnDrvnes_fuzzicalfighterj = {
	"nes_fuzzicalfighterj", "nes_fuzzicalfighter", NULL, NULL, "1991",
	"Fuzzical Fighter (Japan)\0", NULL, "Sigma Enterprises", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG | GBF_HORSHOOT, 0,
	NESGetZipName, nes_fuzzicalfighterjRomInfo, nes_fuzzicalfighterjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Fuzzical Fighter (Hack, English)
static struct BurnRomInfo nes_fuzzicalfighterRomDesc[] = {
	{ "Fuzzical Fighter (T-Eng).nes",          262160, 0x7bbbacc3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_fuzzicalfighter)
STD_ROM_FN(nes_fuzzicalfighter)

struct BurnDriver BurnDrvnes_fuzzicalfighter = {
	"nes_fuzzicalfighter", NULL, NULL, NULL, "2000",
	"Fuzzical Fighter (Hack, English)\0", NULL, "WakdHacks", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG | GBF_HORSHOOT, 0,
	NESGetZipName, nes_fuzzicalfighterRomInfo, nes_fuzzicalfighterRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_gijoeareamheRomDesc[] = {
	{ "G.I. Joe - A Real American Hero (USA).nes",          393232, 0x394fd25a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gijoeareamhe)
STD_ROM_FN(nes_gijoeareamhe)

struct BurnDriver BurnDrvnes_gijoeareamhe = {
	"nes_gijoeareamhe", NULL, NULL, NULL, "1991",
	"G.I. Joe - A Real American Hero (USA)\0", NULL, "Taxan", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, nes_gijoeareamheRomInfo, nes_gijoeareamheRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_gijoeatlfaRomDesc[] = {
	{ "G.I. Joe - The Atlantis Factor (USA).nes",          393232, 0xa8efac13, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gijoeatlfa)
STD_ROM_FN(nes_gijoeatlfa)

struct BurnDriver BurnDrvnes_gijoeatlfa = {
	"nes_gijoeatlfa", NULL, NULL, NULL, "1992",
	"G.I. Joe - The Atlantis Factor (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM | GBF_SCRFIGHT, 0,
	NESGetZipName, nes_gijoeatlfaRomInfo, nes_gijoeatlfaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_gaiapolisRomDesc[] = {
	{ "Gaiapolis (Asia).nes",          393232, 0x838dce25, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gaiapolis)
STD_ROM_FN(nes_gaiapolis)

struct BurnDriver BurnDrvnes_gaiapolis = {
	"nes_gaiapolis", NULL, NULL, NULL, "1990",
	"Gaiapolis (Asia) (Unl)\0", NULL, "Sachen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_gaiapolisRomInfo, nes_gaiapolisRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_galaccruRomDesc[] = {
	{ "Galactic Crusader (USA) (Unl).nes",          65552, 0xce3f8820, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_galaccru)
STD_ROM_FN(nes_galaccru)

struct BurnDriver BurnDrvnes_galaccru = {
	"nes_galaccru", NULL, NULL, NULL, "1990",
	"Galactic Crusader (USA) (Unl)\0", NULL, "Sachen / Joy Van", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_galaccruRomInfo, nes_galaccruRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_galagaRomDesc[] = {
	{ "Galaga - Demons of Death (USA).nes",          40976, 0xe36d5991, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_galaga)
STD_ROM_FN(nes_galaga)

struct BurnDriver BurnDrvnes_galaga = {
	"nes_galaga", NULL, NULL, NULL, "1988",
	"Galaga - Demons of Death (USA)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_galagaRomInfo, nes_galagaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_galaxianRomDesc[] = {
	{ "Galaxian (Japan).nes",          24592, 0x6e4d873b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_galaxian)
STD_ROM_FN(nes_galaxian)

struct BurnDriver BurnDrvnes_galaxian = {
	"nes_galaxian", NULL, NULL, NULL, "1984",
	"Galaxian (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_galaxianRomInfo, nes_galaxianRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// http://www.romhacking.net/hacks/2696/
static struct BurnRomInfo nes_galaxianeRomDesc[] = {
	{ "Galaxian Enhanced Hack v1.0 (2016)(TimeLord).nes",          24592, 0x47c2da76, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_galaxiane)
STD_ROM_FN(nes_galaxiane)

struct BurnDriver BurnDrvnes_galaxiane = {
	"nes_galaxiane", "nes_galaxian", NULL, NULL, "2016",
	"Galaxian Enhanced (Hack)\0", NULL, "TimeLord", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_galaxianeRomInfo, nes_galaxianeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_galaxy5000RomDesc[] = {
	{ "Galaxy 5000 (USA).nes",          262160, 0x37b3ad54, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_galaxy5000)
STD_ROM_FN(nes_galaxy5000)

struct BurnDriver BurnDrvnes_galaxy5000 = {
	"nes_galaxy5000", NULL, NULL, NULL, "1991",
	"Galaxy 5000 (USA)\0", NULL, "Activision", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_galaxy5000RomInfo, nes_galaxy5000RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_gamepartyRomDesc[] = {
	{ "Game Party (Japan).nes",          262160, 0x9c744bc3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gameparty)
STD_ROM_FN(nes_gameparty)

struct BurnDriver BurnDrvnes_gameparty = {
	"nes_gameparty", NULL, NULL, NULL, "1990",
	"Game Party (Japan)\0", NULL, "Coconuts", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_MINIGAMES, 0,
	NESGetZipName, nes_gamepartyRomInfo, nes_gamepartyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ganbare Goemon 2 (Japan)
static struct BurnRomInfo nes_ganbaregoemon2jRomDesc[] = {
	{ "Ganbare Goemon 2 (Japan).nes",          262160, 0x3424d0dc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ganbaregoemon2j)
STD_ROM_FN(nes_ganbaregoemon2j)

struct BurnDriver BurnDrvnes_ganbaregoemon2j = {
	"nes_ganbaregoemon2j", "nes_ganbaregoemon2", NULL, NULL, "1989",
	"Ganbare Goemon 2 (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ACTION | GBF_RPG, 0,
	NESGetZipName, nes_ganbaregoemon2jRomInfo, nes_ganbaregoemon2jRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ganbare Goemon 2 (Hack, English)
static struct BurnRomInfo nes_ganbaregoemon2RomDesc[] = {
	{ "Ganbare Goemon 2 (T-Eng).nes",          262160, 0xb2fe26c7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ganbaregoemon2)
STD_ROM_FN(nes_ganbaregoemon2)

struct BurnDriver BurnDrvnes_ganbaregoemon2 = {
	"nes_ganbaregoemon2", NULL, NULL, NULL, "2011",
	"Ganbare Goemon 2 (Hack, English)\0", NULL, "Stardust Crusaders", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_NES, GBF_ACTION | GBF_RPG, 0,
	NESGetZipName, nes_ganbaregoemon2RomInfo, nes_ganbaregoemon2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ganbare Goemon Gaiden - Kieta Ougon Kiseru (Japan)
static struct BurnRomInfo nes_ganbagoegaijRomDesc[] = {
	{ "Ganbare Goemon Gaiden - Kieta Ougon Kiseru (Japan).nes",          524304, 0x1d2dbc90, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ganbagoegaij)
STD_ROM_FN(nes_ganbagoegaij)

struct BurnDriver BurnDrvnes_ganbagoegaij = {
	"nes_ganbagoegaij", "nes_ganbagoegai", NULL, NULL, "1990",
	"Ganbare Goemon Gaiden - Kieta Ougon Kiseru (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_ganbagoegaijRomInfo, nes_ganbagoegaijRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ganbare Goemon Gaiden - Kieta Ougon Kiseru (Hack, English)
static struct BurnRomInfo nes_ganbagoegaiRomDesc[] = {
	{ "Ganbare Goemon Gaiden - Kieta Ougon Kiseru (T-eng).nes",          524304, 0xa1c4c69e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ganbagoegai)
STD_ROM_FN(nes_ganbagoegai)

struct BurnDriver BurnDrvnes_ganbagoegai = {
	"nes_ganbagoegai", NULL, NULL, NULL, "2017",
	"Ganbare Goemon Gaiden - Kieta Ougon Kiseru (Hack, English)\0", NULL, "Adventurous Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_ganbagoegaiRomInfo, nes_ganbagoegaiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ganbare Goemon Gaiden 2 - Tenka no Zaihou (Japan)
static struct BurnRomInfo nes_ganbagoegai2jRomDesc[] = {
	{ "Ganbare Goemon Gaiden 2 - Tenka no Zaihou (Japan).nes",          524304, 0xad961658, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ganbagoegai2j)
STD_ROM_FN(nes_ganbagoegai2j)

struct BurnDriver BurnDrvnes_ganbagoegai2j = {
	"nes_ganbagoegai2j", "nes_ganbagoegai2", NULL, NULL, "1992",
	"Ganbare Goemon Gaiden 2 - Tenka no Zaihou (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_ganbagoegai2jRomInfo, nes_ganbagoegai2jRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ganbare Goemon Gaiden 2 - Tenka no Zaihou (Hack, English)
static struct BurnRomInfo nes_ganbagoegai2RomDesc[] = {
	{ "Ganbare Goemon Gaiden 2 - Tenka no Zaihou (T-eng).nes",          524304, 0x3de94076, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ganbagoegai2)
STD_ROM_FN(nes_ganbagoegai2)

struct BurnDriver BurnDrvnes_ganbagoegai2 = {
	"nes_ganbagoegai2", NULL, NULL, NULL, "2019",
	"Ganbare Goemon Gaiden 2 - Tenka no Zaihou (Hack, English)\0", NULL, "Adventurous Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_ganbagoegai2RomInfo, nes_ganbagoegai2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ganbare Goemon! - Karakuri Douchuu (Japan)
static struct BurnRomInfo nes_ganbagoejRomDesc[] = {
	{ "Ganbare Goemon! - Karakuri Douchuu (Japan).nes",          262160, 0x50fdb91f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ganbagoej)
STD_ROM_FN(nes_ganbagoej)

struct BurnDriver BurnDrvnes_ganbagoej = {
	"nes_ganbagoej", "nes_ganbagoe", NULL, NULL, "1986",
	"Ganbare Goemon! - Karakuri Douchuu (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_ADV | GBF_ACTION, 0,
	NESGetZipName, nes_ganbagoejRomInfo, nes_ganbagoejRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ganbare Goemon! - Karakuri Douchuu (Hack, English)
static struct BurnRomInfo nes_ganbagoeRomDesc[] = {
	{ "Ganbare Goemon! - Karakuri Douchuu (T-Eng).nes",          262160, 0x83fab5ff, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ganbagoe)
STD_ROM_FN(nes_ganbagoe)

struct BurnDriver BurnDrvnes_ganbagoe = {
	"nes_ganbagoe", NULL, NULL, NULL, "2010",
	"Ganbare Goemon! - Karakuri Douchuu (Hack, English)\0", NULL, "Spinner 8 and friends", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_NES, GBF_ADV | GBF_ACTION, 0,
	NESGetZipName, nes_ganbagoeRomInfo, nes_ganbagoeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ganbare Pennant Race! (Japan)
static struct BurnRomInfo nes_ganbapenracRomDesc[] = {
	{ "Ganbare Pennant Race! (Japan).nes",          262160, 0xd15edc9a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ganbapenrac)
STD_ROM_FN(nes_ganbapenrac)

struct BurnDriver BurnDrvnes_ganbapenrac = {
	"nes_ganbapenrac", NULL, NULL, NULL, "1989",
	"Ganbare Pennant Race! (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_ganbapenracRomInfo, nes_ganbapenracRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ganso Saiyuuki - Super Monkey Daibouken (Japan)
static struct BurnRomInfo nes_gansosaijRomDesc[] = {
	{ "Ganso Saiyuuki - Super Monkey Daibouken (Japan).nes",          65552, 0x74de437a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gansosaij)
STD_ROM_FN(nes_gansosaij)

struct BurnDriver BurnDrvnes_gansosaij = {
	"nes_gansosaij", "nes_gansosai", NULL, NULL, "1986",
	"Ganso Saiyuuki - Super Monkey Daibouken (Japan)\0", NULL, "Vap", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_gansosaijRomInfo, nes_gansosaijRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ganso Saiyuuki - Super Monkey Daibouken (Hack, English)
static struct BurnRomInfo nes_gansosaiRomDesc[] = {
	{ "Ganso Saiyuuki - Super Monkey Daibouken (T-Eng).nes",          65552, 0xf6bc9964, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gansosai)
STD_ROM_FN(nes_gansosai)

struct BurnDriver BurnDrvnes_gansosai = {
	"nes_gansosai", NULL, NULL, NULL, "2015",
	"Ganso Saiyuuki - Super Monkey Daibouken (Hack, English)\0", NULL, "GAFF Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_gansosaiRomInfo, nes_gansosaiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Garfield no Isshukan - A Week of Garfield (Japan)
static struct BurnRomInfo nes_garfiRomDesc[] = {
	{ "Garfield - A Week of Garfield (Japan).nes",          163856, 0x39c68f84, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_garfi)
STD_ROM_FN(nes_garfi)

struct BurnDriver BurnDrvnes_garfi = {
	"nes_garfi", NULL, NULL, NULL, "1989",
	"Garfield no Isshukan - A Week of Garfield (Japan)\0", NULL, "Towa Chiki", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_garfiRomInfo, nes_garfiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Garfield - A Week of Garfield OVERHAUL Project (Hack)
static struct BurnRomInfo nes_garfiopRomDesc[] = {
	{ "Garfield - A Week of Garfield OVERHAUL Project (2022)(Rani Baker).nes",          163856, 0x46f0726f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_garfiop)
STD_ROM_FN(nes_garfiop)

struct BurnDriver BurnDrvnes_garfiop = {
	"nes_garfiop", "nes_garfi", NULL, NULL, "2022",
	"Garfield - A Week of Garfield OVERHAUL Project (Hack)\0", "Graphics improvement", "Rani Baker", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_garfiopRomInfo, nes_garfiopRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gargoyle's Quest II (USA)
static struct BurnRomInfo nes_gargosqueiiRomDesc[] = {
	{ "Gargoyle's Quest II (USA).nes",          262160, 0xda7a9f89, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gargosqueii)
STD_ROM_FN(nes_gargosqueii)

struct BurnDriver BurnDrvnes_gargosqueii = {
	"nes_gargosqueii", NULL, NULL, NULL, "1992",
	"Gargoyle's Quest II (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_gargosqueiiRomInfo, nes_gargosqueiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gauntlet (USA)
static struct BurnRomInfo nes_gauntletRomDesc[] = {
	{ "Gauntlet (USA).nes",          196624, 0x3efb001c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gauntlet)
STD_ROM_FN(nes_gauntlet)

struct BurnDriver BurnDrvnes_gauntlet = {
	"nes_gauntlet", NULL, NULL, NULL, "1988",
	"Gauntlet (USA)\0", NULL, "Tengen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RUNGUN | GBF_MAZE, 0,
	NESGetZipName, nes_gauntletRomInfo, nes_gauntletRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gauntlet II (USA)
static struct BurnRomInfo nes_gauntletiiRomDesc[] = {
	{ "Gauntlet II (USA).nes",          262160, 0x31e2c449, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gauntletii)
STD_ROM_FN(nes_gauntletii)

struct BurnDriver BurnDrvnes_gauntletii = {
	"nes_gauntletii", NULL, NULL, NULL, "1990",
	"Gauntlet II (USA)\0", NULL, "Mindscape", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_RUNGUN | GBF_MAZE, 0,
	NESGetZipName, nes_gauntletiiRomInfo, nes_gauntletiiRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gegege no Kitarou - Youkai Daimakyou (Japan)
static struct BurnRomInfo nes_gegegnokitRomDesc[] = {
	{ "Gegege no Kitarou - Youkai Daimakyou (Japan).nes",          65552, 0x6a6d9f5a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gegegnokit)
STD_ROM_FN(nes_gegegnokit)

struct BurnDriver BurnDrvnes_gegegnokit = {
	"nes_gegegnokit", NULL, NULL, NULL, "1986",
	"Gegege no Kitarou - Youkai Daimakyou (Japan)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_gegegnokitRomInfo, nes_gegegnokitRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Geimos (Japan)
static struct BurnRomInfo nes_geimosRomDesc[] = {
	{ "Geimos (Japan).nes",          40976, 0xe36038b7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_geimos)
STD_ROM_FN(nes_geimos)

struct BurnDriver BurnDrvnes_geimos = {
	"nes_geimos", NULL, NULL, NULL, "1985",
	"Geimos (Japan)\0", NULL, "ASCII Corp.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_geimosRomInfo, nes_geimosRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gekikame Ninja Den (Japan)
static struct BurnRomInfo nes_gekiknindenRomDesc[] = {
	{ "Gekikame Ninja Den (Japan).nes",          262160, 0x0913063b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gekikninden)
STD_ROM_FN(nes_gekikninden)

struct BurnDriver BurnDrvnes_gekikninden = {
	"nes_gekikninden", "nes_tmnt", NULL, NULL, "1989",
	"Gekikame Ninja Den (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_gekiknindenRomInfo, nes_gekiknindenRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gekitotsu Yonku Battle (Japan)
static struct BurnRomInfo nes_gekityonbatRomDesc[] = {
	{ "Gekitotsu Yonku Battle (Japan).nes",          131088, 0xc7e7f987, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gekityonbat)
STD_ROM_FN(nes_gekityonbat)

struct BurnDriver BurnDrvnes_gekityonbat = {
	"nes_gekityonbat", NULL, NULL, NULL, "1989",
	"Gekitotsu Yonku Battle (Japan)\0", NULL, "Irem", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_gekityonbatRomInfo, nes_gekityonbatRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gemfire (USA)
static struct BurnRomInfo nes_gemfireRomDesc[] = {
	{ "Gemfire (USA).nes",          524304, 0x2af6d3d6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gemfire)
STD_ROM_FN(nes_gemfire)

struct BurnDriver BurnDrvnes_gemfire = {
	"nes_gemfire", NULL, NULL, NULL, "1992",
	"Gemfire (USA)\0", NULL, "Koei", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_gemfireRomInfo, nes_gemfireRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Genghis Khan (USA)
static struct BurnRomInfo nes_genghiskhanRomDesc[] = {
	{ "Genghis Khan (USA).nes",          262160, 0x478a04d8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_genghiskhan)
STD_ROM_FN(nes_genghiskhan)

struct BurnDriver BurnDrvnes_genghiskhan = {
	"nes_genghiskhan", NULL, NULL, NULL, "1990",
	"Genghis Khan (USA)\0", NULL, "Koei", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_genghiskhanRomInfo, nes_genghiskhanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// George Foreman's KO Boxing (USA)
static struct BurnRomInfo nes_georgforskoboRomDesc[] = {
	{ "George Foreman's KO Boxing (USA).nes",          393232, 0x8b67b2db, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_georgforskobo)
STD_ROM_FN(nes_georgforskobo)

struct BurnDriver BurnDrvnes_georgforskobo = {
	"nes_georgforskobo", NULL, NULL, NULL, "1992",
	"George Foreman's KO Boxing (USA)\0", NULL, "Acclaim", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_georgforskoboRomInfo, nes_georgforskoboRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Getsu Fuuma Den (Japan)
static struct BurnRomInfo nes_getsufuumadenRomDesc[] = {
	{ "Getsu Fuuma Den (Japan).nes",          262160, 0x71ff1e76, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_getsufuumaden)
STD_ROM_FN(nes_getsufuumaden)

struct BurnDriver BurnDrvnes_getsufuumaden = {
	"nes_getsufuumaden", "nes_legenfum", NULL, NULL, "1987",
	"Getsu Fuuma Den (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_getsufuumadenRomInfo, nes_getsufuumadenRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ghost Lion, Legend of the (USA)
static struct BurnRomInfo nes_ghostlionRomDesc[] = {
	{ "Ghost Lion (USA).nes",          262160, 0x5d83c1e5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ghostlion)
STD_ROM_FN(nes_ghostlion)

struct BurnDriver BurnDrvnes_ghostlion = {
	"nes_ghostlion", NULL, NULL, NULL, "1992",
	"Ghost Lion, Legend of the (USA)\0", NULL, "Kemco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_ghostlionRomInfo, nes_ghostlionRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ghostbusters (USA)
static struct BurnRomInfo nes_ghostbustersRomDesc[] = {
	{ "Ghostbusters (USA).nes",          65552, 0xb30a3e39, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ghostbusters)
STD_ROM_FN(nes_ghostbusters)

struct BurnDriver BurnDrvnes_ghostbusters = {
	"nes_ghostbusters", NULL, NULL, NULL, "1988",
	"Ghostbusters (USA)\0", NULL, "Activision", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_ghostbustersRomInfo, nes_ghostbustersRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ghostbusters II (USA)
static struct BurnRomInfo nes_ghostbustersiiRomDesc[] = {
	{ "Ghostbusters II (USA).nes",          262160, 0x8d4e6fa3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ghostbustersii)
STD_ROM_FN(nes_ghostbustersii)

struct BurnDriver BurnDrvnes_ghostbustersii = {
	"nes_ghostbustersii", NULL, NULL, NULL, "1990",
	"Ghostbusters II (USA)\0", NULL, "Activision", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_ghostbustersiiRomInfo, nes_ghostbustersiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ghosts'n Goblins (USA)(Hack, Easy Mode v2.0)
static struct BurnRomInfo nes_ghostsngoblinshRomDesc[] = {
	{ "Ghosts'n Goblins (USA)(Hack, Very Easy Mode v2.0).nes",          131088, 0x66751cad, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ghostsngoblinsh)
STD_ROM_FN(nes_ghostsngoblinsh)

struct BurnDriver BurnDrvnes_ghostsngoblinsh = {
	"nes_ghostsngoblinsh", "nes_ghostsngoblins", NULL, NULL, "2019",
	"Ghosts'n Goblins (USA)(Hack, Easy Mode v2.0)\0", NULL, "chronix", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_ghostsngoblinshRomInfo, nes_ghostsngoblinshRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ghosts'n Goblins (USA)
static struct BurnRomInfo nes_ghostsngoblinsRomDesc[] = {
	{ "Ghosts'n Goblins (USA).nes",          131088, 0x983dd1de, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ghostsngoblins)
STD_ROM_FN(nes_ghostsngoblins)

struct BurnDriver BurnDrvnes_ghostsngoblins = {
	"nes_ghostsngoblins", NULL, NULL, NULL, "1986",
	"Ghosts'n Goblins (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_ghostsngoblinsRomInfo, nes_ghostsngoblinsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ghoul School (USA)
static struct BurnRomInfo nes_ghoulschoolRomDesc[] = {
	{ "Ghoul School (USA).nes",          262160, 0x46717c74, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ghoulschool)
STD_ROM_FN(nes_ghoulschool)

struct BurnDriver BurnDrvnes_ghoulschool = {
	"nes_ghoulschool", NULL, NULL, NULL, "1992",
	"Ghoul School (USA)\0", NULL, "Electro Brain", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_ghoulschoolRomInfo, nes_ghoulschoolRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gimmick! (Japan)
static struct BurnRomInfo nes_gimmickRomDesc[] = {
	{ "Gimmick! (Japan).nes",          393232, 0x15f688b6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gimmick)
STD_ROM_FN(nes_gimmick)

struct BurnDriver BurnDrvnes_gimmick = {
	"nes_gimmick", NULL, NULL, NULL, "1992",
	"Gimmick! (Japan)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_gimmickRomInfo, nes_gimmickRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gluk the Thunder Warrior (Spain) (Gluk Video) (Unl)
static struct BurnRomInfo nes_glukthuwarRomDesc[] = {
	{ "Gluk the Thunder Warrior (Spain) (Gluk Video) (Unl).nes",          262160, 0x5d615d1d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_glukthuwar)
STD_ROM_FN(nes_glukthuwar)

struct BurnDriver BurnDrvnes_glukthuwar = {
	"nes_glukthuwar", NULL, NULL, NULL, "1992",
	"Gluk the Thunder Warrior (Spain) (Gluk Video) (Unl)\0", NULL, "Gluk Video", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_glukthuwarRomInfo, nes_glukthuwarRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Go! Benny! (Unl)
static struct BurnRomInfo nes_gobennyRomDesc[] = {
	{ "Go! Benny! (Unl).nes",          65552, 0xc92325a0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gobenny)
STD_ROM_FN(nes_gobenny)

struct BurnDriver BurnDrvnes_gobenny = {
	"nes_gobenny", NULL, NULL, NULL, "1992",
	"Go! Benny! (Unl)\0", NULL, "Gluk Video", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_gobennyRomInfo, nes_gobennyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Go! Dizzy Go! (USA) (Unl)
static struct BurnRomInfo nes_godizzygoRomDesc[] = {
	{ "Go! Dizzy Go! (1992)(Codemasters, Camerica).nes",          65552, 0x78716f4f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_godizzygo)
STD_ROM_FN(nes_godizzygo)

struct BurnDriver BurnDrvnes_godizzygo = {
	"nes_godizzygo", NULL, NULL, NULL, "1992",
	"Go! Dizzy Go! (USA) (Unl)\0", NULL, "Camerica", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_MAZE | GBF_ACTION, 0,
	NESGetZipName, nes_godizzygoRomInfo, nes_godizzygoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Goal! (USA)
static struct BurnRomInfo nes_goalRomDesc[] = {
	{ "Goal! (USA).nes",          393232, 0xab800243, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_goal)
STD_ROM_FN(nes_goal)

struct BurnDriver BurnDrvnes_goal = {
	"nes_goal", NULL, NULL, NULL, "1989",
	"Goal! (USA)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSFOOTBALL, 0,
	NESGetZipName, nes_goalRomInfo, nes_goalRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Goal! Two (USA)
static struct BurnRomInfo nes_goaltwoRomDesc[] = {
	{ "Goal! Two (USA).nes",          262160, 0xc5b01401, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_goaltwo)
STD_ROM_FN(nes_goaltwo)

struct BurnDriver BurnDrvnes_goaltwo = {
	"nes_goaltwo", NULL, NULL, NULL, "1992",
	"Goal! Two (USA)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSFOOTBALL, 0,
	NESGetZipName, nes_goaltwoRomInfo, nes_goaltwoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// God Slayer - Haruka Tenkuu no Sonata (Japan)
static struct BurnRomInfo nes_godslaRomDesc[] = {
	{ "God Slayer - Haruka Tenkuu no Sonata (Japan).nes",          393232, 0x718fd0af, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_godsla)
STD_ROM_FN(nes_godsla)

struct BurnDriver BurnDrvnes_godsla = {
	"nes_godsla", "nes_crystalis", NULL, NULL, "1990",
	"God Slayer - Haruka Tenkuu no Sonata (Japan)\0", NULL, "SNK", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_godslaRomInfo, nes_godslaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Godzilla - Monster of Monsters! (USA)
static struct BurnRomInfo nes_godziRomDesc[] = {
	{ "Godzilla - Monster of Monsters! (USA).nes",          262160, 0x198b4e3b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_godzi)
STD_ROM_FN(nes_godzi)

struct BurnDriver BurnDrvnes_godzi = {
	"nes_godzi", NULL, NULL, NULL, "1989",
	"Godzilla - Monster of Monsters! (USA)\0", NULL, "Toho", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_godziRomInfo, nes_godziRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Godzilla 2 - War of the Monsters (USA)
static struct BurnRomInfo nes_godzi2RomDesc[] = {
	{ "Godzilla 2 - War of the Monsters (USA).nes",          262160, 0xf200080d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_godzi2)
STD_ROM_FN(nes_godzi2)

struct BurnDriver BurnDrvnes_godzi2 = {
	"nes_godzi2", NULL, NULL, NULL, "1992",
	"Godzilla 2 - War of the Monsters (USA)\0", NULL, "Toho", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_godzi2RomInfo, nes_godzi2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Golden Axe III (Unl)
static struct BurnRomInfo nes_goldenaxeiiiRomDesc[] = {
	{ "Golden Axe III (Unl).nes",          524304, 0x9cdbf17b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_goldenaxeiii)
STD_ROM_FN(nes_goldenaxeiii)

struct BurnDriver BurnDrvnes_goldenaxeiii = {
	"nes_goldenaxeiii", NULL, NULL, NULL, "2005",
	"Golden Axe III (Unl)\0", NULL, "Waixing", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_goldenaxeiiiRomInfo, nes_goldenaxeiiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Golden Five (Pegasus 5-in-1) (Unl)
static struct BurnRomInfo nes_goldenfiveRomDesc[] = {
	{ "Golden Five (Pegasus 5-in-1)(Unl).nes",          1310736, 0x6e8a695f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_goldenfive)
STD_ROM_FN(nes_goldenfive)

struct BurnDriver BurnDrvnes_goldenfive = {
	"nes_goldenfive", NULL, NULL, NULL, "199?",
	"Golden Five (Pegasus 5-in-1) (Unl)\0", NULL, "<unknown>", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_goldenfiveRomInfo, nes_goldenfiveRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Golf (USA)
static struct BurnRomInfo nes_golfRomDesc[] = {
	{ "Golf (USA).nes",          24592, 0x6c4e5a87, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_golf)
STD_ROM_FN(nes_golf)

struct BurnDriver BurnDrvnes_golf = {
	"nes_golf", NULL, NULL, NULL, "1987",
	"Golf (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_golfRomInfo, nes_golfRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Golf Grand Slam (USA)
static struct BurnRomInfo nes_golfgsRomDesc[] = {
	{ "Golf Grand Slam (USA)(1991)(Atlus).nes",          262160, 0xb4a1d511, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_golfgs)
STD_ROM_FN(nes_golfgs)

struct BurnDriver BurnDrvnes_golfgs = {
	"nes_golfgs", NULL, NULL, NULL, "1991",
	"Golf Grand Slam (USA)\0", NULL, "Atlus", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_golfgsRomInfo, nes_golfgsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Golf Grand Slam (Japan)
static struct BurnRomInfo nes_golfgsjRomDesc[] = {
	{ "Golf Grand Slam (Japan)(1991)(HECT).nes",          262160, 0x52bfa018, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_golfgsj)
STD_ROM_FN(nes_golfgsj)

struct BurnDriver BurnDrvnes_golfgsj = {
	"nes_golfgsj", "nes_golfgs", NULL, NULL, "1991",
	"Golf Grand Slam (Japan)\0", NULL, "HECT", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 4, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_golfgsjRomInfo, nes_golfgsjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Golgo 13 - Top Secret Episode (USA)
static struct BurnRomInfo nes_golgo13RomDesc[] = {
	{ "Golgo 13 - Top Secret Episode (USA).nes",          262160, 0x9881d1b4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_golgo13)
STD_ROM_FN(nes_golgo13)

struct BurnDriver BurnDrvnes_golgo13 = {
	"nes_golgo13", NULL, NULL, NULL, "1988",
	"Golgo 13 - Top Secret Episode (USA)\0", NULL, "Vic Tokai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_golgo13RomInfo, nes_golgo13RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gomoku Narabe Renju (Hack, English)
// https://www.romhacking.net/translations/3073/
static struct BurnRomInfo nes_gomokuRomDesc[] = {
	{ "Gomoku Narabe Renju (T-Eng).nes",          24592, 0x18513cfc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gomoku)
STD_ROM_FN(nes_gomoku)

struct BurnDriver BurnDrvnes_gomoku = {
	"nes_gomoku", NULL, NULL, NULL, "2017",
	"Gomoku Narabe Renju (Hack, English)\0", NULL, "Psyklax", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_BOARD, 0,
	NESGetZipName, nes_gomokuRomInfo, nes_gomokuRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gomoku Narabe Renju (Japan)
static struct BurnRomInfo nes_gomokujRomDesc[] = {
	{ "Gomoku Narabe Renju (Japan).nes",          24592, 0x28843bb1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gomokuj)
STD_ROM_FN(nes_gomokuj)

struct BurnDriver BurnDrvnes_gomokuj = {
	"nes_gomokuj", "nes_gomoku", NULL, NULL, "1983",
	"Gomoku Narabe Renju (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_BOARD, 0,
	NESGetZipName, nes_gomokujRomInfo, nes_gomokujRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Goonies, The (Japan)
static struct BurnRomInfo nes_gooniesRomDesc[] = {
	{ "Goonies (Japan).nes",          49168, 0x5589af04, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_goonies)
STD_ROM_FN(nes_goonies)

struct BurnDriver BurnDrvnes_goonies = {
	"nes_goonies", NULL, NULL, NULL, "1986",
	"Goonies, The (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_gooniesRomInfo, nes_gooniesRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Goonies II, The (USA)
static struct BurnRomInfo nes_gooniesiitheRomDesc[] = {
	{ "Goonies II, The (USA).nes",          131088, 0xaa9ca482, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gooniesiithe)
STD_ROM_FN(nes_gooniesiithe)

struct BurnDriver BurnDrvnes_gooniesiithe = {
	"nes_gooniesiithe", NULL, NULL, NULL, "1987",
	"Goonies II, The (USA)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_gooniesiitheRomInfo, nes_gooniesiitheRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gorby no Pipeline Daisakusen (Japan)
static struct BurnRomInfo nes_gorbynopipdaiRomDesc[] = {
	{ "Gorby no Pipeline Daisakusen (Japan).nes",          65552, 0xc136143b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gorbynopipdai)
STD_ROM_FN(nes_gorbynopipdai)

struct BurnDriver BurnDrvnes_gorbynopipdai = {
	"nes_gorbynopipdai", NULL, NULL, NULL, "1991",
	"Gorby no Pipeline Daisakusen (Japan)\0", NULL, "Tokuma Shoten", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_gorbynopipdaiRomInfo, nes_gorbynopipdaiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gotcha! - The Sport! (USA)
static struct BurnRomInfo nes_gotchaRomDesc[] = {
	{ "Gotcha! - The Sport! (USA).nes",          65552, 0x01be8b6f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gotcha)
STD_ROM_FN(nes_gotcha)

struct BurnDriver BurnDrvnes_gotcha = {
	"nes_gotcha", NULL, NULL, NULL, "1987",
	"Gotcha! - The Sport! (USA)\0", NULL, "Ljn", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_gotchaRomInfo, nes_gotchaRomName, NULL, NULL, NULL, NULL, NESZapperInputInfo, NESZapperDIPInfo,
	NESZapperInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gradius (Japan)
static struct BurnRomInfo nes_gradiusjRomDesc[] = {
	{ "Gradius (Japan).nes",          65552, 0x97c4eac3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gradiusj)
STD_ROM_FN(nes_gradiusj)

struct BurnDriver BurnDrvnes_gradiusj = {
	"nes_gradiusj", "nes_gradius", NULL, NULL, "1986",
	"Gradius (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_gradiusjRomInfo, nes_gradiusjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gradius (USA)
static struct BurnRomInfo nes_gradiusRomDesc[] = {
	{ "Gradius (USA).nes",          65552, 0x7a269942, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gradius)
STD_ROM_FN(nes_gradius)

struct BurnDriver BurnDrvnes_gradius = {
	"nes_gradius", NULL, NULL, NULL, "1986",
	"Gradius (USA)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_gradiusRomInfo, nes_gradiusRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gradius II (Japan)
static struct BurnRomInfo nes_gradiusiiRomDesc[] = {
	{ "Gradius II (Japan).nes",          262160, 0xd213aa0d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gradiusii)
STD_ROM_FN(nes_gradiusii)

struct BurnDriver BurnDrvnes_gradiusii = {
	"nes_gradiusii", NULL, NULL, NULL, "1988",
	"Gradius II (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_gradiusiiRomInfo, nes_gradiusiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gran Aventura Submarina, La (Spain)
static struct BurnRomInfo nes_granavesublaRomDesc[] = {
	{ "Gran Aventura Submarina, La (Spain).nes",          65552, 0x6483756a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_granavesubla)
STD_ROM_FN(nes_granavesubla)

struct BurnDriver BurnDrvnes_granavesubla = {
	"nes_granavesubla", NULL, NULL, NULL, "1989?",
	"Gran Aventura Submarina, La (Spain)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_granavesublaRomInfo, nes_granavesublaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Grand Master (Japan)
static struct BurnRomInfo nes_grandmasterjRomDesc[] = {
	{ "Grand Master (Japan).nes",          393232, 0xeff4603a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_grandmasterj)
STD_ROM_FN(nes_grandmasterj)

struct BurnDriver BurnDrvnes_grandmasterj = {
	"nes_grandmasterj", "nes_grandmaster", NULL, NULL, "1991",
	"Grand Master (Japan)\0", NULL, "Varie", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_grandmasterjRomInfo, nes_grandmasterjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Grand Master (Hack, English)
static struct BurnRomInfo nes_grandmasterRomDesc[] = {
	{ "Grand Master (T-Eng).nes",          393232, 0x51cd513e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_grandmaster)
STD_ROM_FN(nes_grandmaster)

struct BurnDriver BurnDrvnes_grandmaster = {
	"nes_grandmaster", NULL, NULL, NULL, "2013",
	"Grand Master (Hack, English)\0", NULL, "Stardust Crusaders", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_grandmasterRomInfo, nes_grandmasterRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Great Battle Cyber (Japan)
static struct BurnRomInfo nes_greatbatcybRomDesc[] = {
	{ "Great Battle Cyber (Japan).nes",          393232, 0x39eb20ab, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_greatbatcyb)
STD_ROM_FN(nes_greatbatcyb)

struct BurnDriver BurnDrvnes_greatbatcyb = {
	"nes_greatbatcyb", NULL, NULL, NULL, "1992",
	"Great Battle Cyber (Japan)\0", NULL, "Banpresto", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_greatbatcybRomInfo, nes_greatbatcybRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Great Boxing - Rush Up (Japan)
static struct BurnRomInfo nes_greatboxRomDesc[] = {
	{ "Great Boxing - Rush Up (Japan).nes",          262160, 0x3dcdd299, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_greatbox)
STD_ROM_FN(nes_greatbox)

struct BurnDriver BurnDrvnes_greatbox = {
	"nes_greatbox", "nes_worldchamp", NULL, NULL, "1990",
	"Great Boxing - Rush Up (Japan)\0", NULL, "Visco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_greatboxRomInfo, nes_greatboxRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Great Tank (Japan)
static struct BurnRomInfo nes_greattankRomDesc[] = {
	{ "Great Tank (Japan).nes",          262160, 0xbd2855f2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_greattank)
STD_ROM_FN(nes_greattank)

struct BurnDriver BurnDrvnes_greattank = {
	"nes_greattank", "nes_irontan", NULL, NULL, "1988",
	"Great Tank (Japan)\0", NULL, "SNK", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_greattankRomInfo, nes_greattankRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Great Waldo Search, The (USA)
static struct BurnRomInfo nes_greatwalseaRomDesc[] = {
	{ "Great Waldo Search, The (USA).nes",          262160, 0x404c5ef2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_greatwalsea)
STD_ROM_FN(nes_greatwalsea)

struct BurnDriver BurnDrvnes_greatwalsea = {
	"nes_greatwalsea", NULL, NULL, NULL, "1992",
	"Great Waldo Search, The (USA)\0", NULL, "THQ", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_greatwalseaRomInfo, nes_greatwalseaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gremlins 2 - The New Batch (USA)
static struct BurnRomInfo nes_greml2RomDesc[] = {
	{ "Gremlins 2 - The New Batch (USA).nes",          393232, 0x2abb2ee7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_greml2)
STD_ROM_FN(nes_greml2)

struct BurnDriver BurnDrvnes_greml2 = {
	"nes_greml2", NULL, NULL, NULL, "1990",
	"Gremlins 2 - The New Batch (USA)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_greml2RomInfo, nes_greml2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Greg Norman's Golf Power (USA)
 static struct BurnRomInfo nes_gngolfpRomDesc[] = {
	{ "Greg Norman's Golf Power (1992)(Gremlin Interactive).nes",          131088, 0xfb1e109d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gngolfp)
STD_ROM_FN(nes_gngolfp)

struct BurnDriver BurnDrvnes_gngolfp = {
	"nes_gngolfp", NULL, NULL, NULL, "1992",
	"Greg Norman's Golf Power (USA)\0", NULL, "Gremlin Interactive", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_gngolfpRomInfo, nes_gngolfpRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Guardian Legend, The (USA)
static struct BurnRomInfo nes_guardlegRomDesc[] = {
	{ "Guardian Legend, The (USA).nes",          131088, 0xc94ac75f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_guardleg)
STD_ROM_FN(nes_guardleg)

struct BurnDriver BurnDrvnes_guardleg = {
	"nes_guardleg", NULL, NULL, NULL, "1989",
	"Guardian Legend, The (USA)\0", NULL, "Broderbund", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT | GBF_ADV, 0,
	NESGetZipName, nes_guardlegRomInfo, nes_guardlegRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_guardicgaidenRomDesc[] = {
	{ "Guardic Gaiden (Japan).nes",          131088, 0xe9d15ff1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_guardicgaiden)
STD_ROM_FN(nes_guardicgaiden)

struct BurnDriver BurnDrvnes_guardicgaiden = {
	"nes_guardicgaiden", "nes_guardleg", NULL, NULL, "1987",
	"Guardic Gaiden (Japan)\0", NULL, "Irem", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_SHOOT | GBF_ADV, 0,
	NESGetZipName, nes_guardicgaidenRomInfo, nes_guardicgaidenRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_guerrillawarRomDesc[] = {
	{ "Guerrilla War (USA).nes",          262160, 0x16128767, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_guerrillawar)
STD_ROM_FN(nes_guerrillawar)

struct BurnDriver BurnDrvnes_guerrillawar = {
	"nes_guerrillawar", NULL, NULL, NULL, "1989",
	"Guerrilla War (USA)\0", NULL, "SNK", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_guerrillawarRomInfo, nes_guerrillawarRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_guevaraRomDesc[] = {
	{ "Guevara (Japan).nes",          262160, 0x0e77c00c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_guevara)
STD_ROM_FN(nes_guevara)

struct BurnDriver BurnDrvnes_guevara = {
	"nes_guevara", "nes_guerrillawar", NULL, NULL, "1988",
	"Guevara (Japan)\0", NULL, "SNK", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_guevaraRomInfo, nes_guevaraRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gumshoe (USA)
static struct BurnRomInfo nes_gumshoeRomDesc[] = {
	{ "Gumshoe (USA).nes",          163856, 0xaab00873, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gumshoe)
STD_ROM_FN(nes_gumshoe)

struct BurnDriver BurnDrvnes_gumshoe = {
	"nes_gumshoe", NULL, NULL, NULL, "1986",
	"Gumshoe (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_gumshoeRomInfo, nes_gumshoeRomName, NULL, NULL, NULL, NULL, NESZapperInputInfo, NESZapperDIPInfo,
	NESZapperInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Inspector Gadget (GlobalHack)(2022)(Garrett Gilchrist)
// https://www.romhacking.net/hacks/6830/
static struct BurnRomInfo nes_gadgetRomDesc[] = {
	{ "Inspector Gadget (GlobalHack)(2022)(Garrett Gilchrist).nes",          172048, 0x51a2c04b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gadget)
STD_ROM_FN(nes_gadget)

struct BurnDriver BurnDrvnes_gadget = {
	"nes_gadget", "nes_gumshoe", NULL, NULL, "2022",
	"Inspector Gadget (Hack)\0", NULL, "Garrett Gilchrist", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_gadgetRomInfo, nes_gadgetRomName, NULL, NULL, NULL, NULL, NESZapperInputInfo, NESZapperDIPInfo,
	NESZapperInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gun Nac (Japan)
static struct BurnRomInfo nes_gunnacjRomDesc[] = {
	{ "Gun Nac (Japan).nes",          262160, 0x04008279, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gunnacj)
STD_ROM_FN(nes_gunnacj)

struct BurnDriver BurnDrvnes_gunnacj = {
	"nes_gunnacj", "nes_gunnac", NULL, NULL, "1990",
	"Gun Nac (Japan)\0", NULL, "Tonkin House", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_gunnacjRomInfo, nes_gunnacjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gun Nac (Hack, English)
static struct BurnRomInfo nes_gunnactRomDesc[] = {
	{ "Gun Nac (T-Eng).nes",          262160, 0xc5fc33f0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gunnact)
STD_ROM_FN(nes_gunnact)

struct BurnDriver BurnDrvnes_gunnact = {
	"nes_gunnact", "nes_gunnac", NULL, NULL, "2017",
	"Gun Nac (Hack, English)\0", NULL, "Zynk Oxhyde", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_gunnactRomInfo, nes_gunnactRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gun Nac (USA)
static struct BurnRomInfo nes_gunnacRomDesc[] = {
	{ "Gun Nac (USA).nes",          262160, 0x0c950064, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gunnac)
STD_ROM_FN(nes_gunnac)

struct BurnDriver BurnDrvnes_gunnac = {
	"nes_gunnac", NULL, NULL, NULL, "1991",
	"Gun Nac (USA)\0", NULL, "Nexoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_gunnacRomInfo, nes_gunnacRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gun Sight (Japan)
static struct BurnRomInfo nes_gunsightRomDesc[] = {
	{ "Gun Sight (Japan).nes",          262160, 0x592d3855, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gunsight)
STD_ROM_FN(nes_gunsight)

struct BurnDriver BurnDrvnes_gunsight = {
	"nes_gunsight", NULL, NULL, NULL, "1991",
	"Gun Sight (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_gunsightRomInfo, nes_gunsightRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gun-Dec (Japan)
static struct BurnRomInfo nes_gundecjRomDesc[] = {
	{ "Gun-Dec (Japan).nes",          262160, 0x4b08e280, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gundecj)
STD_ROM_FN(nes_gundecj)

struct BurnDriver BurnDrvnes_gundecj = {
	"nes_gundecj", "nes_vice", NULL, NULL, "1991",
	"Gun-Dec (Japan)\0", NULL, "Sammy", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_SHOOT | GBF_PLATFORM, 0,
	NESGetZipName, nes_gundecjRomInfo, nes_gundecjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gun-Dec (Hack, English)
static struct BurnRomInfo nes_gundecRomDesc[] = {
	{ "Gun-Dec (T-Eng).nes",          393232, 0x0b7c7e99, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gundec)
STD_ROM_FN(nes_gundec)

struct BurnDriver BurnDrvnes_gundec = {
	"nes_gundec", "nes_vice", NULL, NULL, "2015",
	"Gun-Dec (Hack, English)\0", NULL, "Stardust Crusaders", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_SHOOT | GBF_PLATFORM, 0,
	NESGetZipName, nes_gundecRomInfo, nes_gundecRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gun.Smoke (USA)
static struct BurnRomInfo nes_gunsmokeRomDesc[] = {
	{ "Gun.Smoke (USA).nes",          131088, 0x6b8f23e0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gunsmoke)
STD_ROM_FN(nes_gunsmoke)

struct BurnDriver BurnDrvnes_gunsmoke = {
	"nes_gunsmoke", NULL, NULL, NULL, "1988",
	"Gun.Smoke (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_gunsmokeRomInfo, nes_gunsmokeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gunhed - Aratanaru Tatakai (Japan)
static struct BurnRomInfo nes_gunhedRomDesc[] = {
	{ "Gunhed - Aratanaru Tatakai (Japan).nes",          262160, 0xb14f0757, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gunhed)
STD_ROM_FN(nes_gunhed)

struct BurnDriver BurnDrvnes_gunhed = {
	"nes_gunhed", NULL, NULL, NULL, "1990",
	"Gunhed - Aratanaru Tatakai (Japan)\0", NULL, "Varie", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_gunhedRomInfo, nes_gunhedRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gyrodine (Japan)
static struct BurnRomInfo nes_gyrodineRomDesc[] = {
	{ "Gyrodine (Japan).nes",          40976, 0xce936921, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gyrodine)
STD_ROM_FN(nes_gyrodine)

struct BurnDriver BurnDrvnes_gyrodine = {
	"nes_gyrodine", NULL, NULL, NULL, "1986",
	"Gyrodine (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_gyrodineRomInfo, nes_gyrodineRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gyromite (USA)
static struct BurnRomInfo nes_gyromiteRomDesc[] = {
	{ "Gyromite (USA).nes",          40976, 0xe54840ec, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gyromite)
STD_ROM_FN(nes_gyromite)

struct BurnDriver BurnDrvnes_gyromite = {
	"nes_gyromite", NULL, NULL, NULL, "1987",
	"Gyromite (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM | GBF_PUZZLE, 0,
	NESGetZipName, nes_gyromiteRomInfo, nes_gyromiteRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gyromite Special Edition (Hack)
static struct BurnRomInfo nes_gyromiteseRomDesc[] = {
	{ "Gyromite Special Edition (2014)(the jabu).nes",          40976, 0x1495d355, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gyromitese)
STD_ROM_FN(nes_gyromitese)

struct BurnDriver BurnDrvnes_gyromitese = {
	"nes_gyromitese", "nes_gyromite", NULL, NULL, "2014",
	"Gyromite Special Edition (Hack)\0", "This hack allows to play the game on a traditional controller", "the jabu", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM | GBF_PUZZLE, 0,
	NESGetZipName, nes_gyromiteseRomInfo, nes_gyromiteseRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Gyruss (USA)
static struct BurnRomInfo nes_gyrussRomDesc[] = {
	{ "Gyruss (USA).nes",          65552, 0x526ad690, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gyruss)
STD_ROM_FN(nes_gyruss)

struct BurnDriver BurnDrvnes_gyruss = {
	"nes_gyruss", NULL, NULL, NULL, "1989",
	"Gyruss (USA)\0", NULL, "Ultra Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_gyrussRomInfo, nes_gyrussRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hammerin' Harry (Euro)
static struct BurnRomInfo nes_hammerinharryRomDesc[] = {
	{ "Hammerin' Harry (Europe).nes",          262160, 0x4d58c832, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hammerinharry)
STD_ROM_FN(nes_hammerinharry)

struct BurnDriver BurnDrvnes_hammerinharry = {
	"nes_hammerinharry", "nes_daikunogensan", NULL, NULL, "1992",
	"Hammerin' Harry (Euro)\0", NULL, "Irem", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_hammerinharryRomInfo, nes_hammerinharryRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL, SCREEN_WIDTH, SCREEN_HEIGHT_PAL
};

// Happy Camper (USA) (Prototype)
static struct BurnRomInfo nes_happycamperRomDesc[] = {
	{ "Happy Camper (USA) (Proto).nes",          131088, 0x100bb526, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_happycamper)
STD_ROM_FN(nes_happycamper)

struct BurnDriver BurnDrvnes_happycamper = {
	"nes_happycamper", NULL, NULL, NULL, "199?",
	"Happy Camper (USA) (Prototype)\0", NULL, "Color Dreams", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_PROTOTYPE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_happycamperRomInfo, nes_happycamperRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Harlem Globetrotters (USA)
static struct BurnRomInfo nes_harlegloRomDesc[] = {
	{ "Harlem Globetrotters (USA).nes",          262160, 0x43ddc8a3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_harleglo)
STD_ROM_FN(nes_harleglo)

struct BurnDriver BurnDrvnes_harleglo = {
	"nes_harleglo", NULL, NULL, NULL, "1991",
	"Harlem Globetrotters (USA)\0", NULL, "GameTek", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_harlegloRomInfo, nes_harlegloRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hatris (USA)
static struct BurnRomInfo nes_hatrisRomDesc[] = {
	{ "Hatris (USA).nes",          131088, 0x56dbfd1f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hatris)
STD_ROM_FN(nes_hatris)

struct BurnDriver BurnDrvnes_hatris = {
	"nes_hatris", NULL, NULL, NULL, "1992",
	"Hatris (USA)\0", NULL, "Bullet-Proof Software", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_hatrisRomInfo, nes_hatrisRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Heavy Barrel (USA)
static struct BurnRomInfo nes_heavybarrelRomDesc[] = {
	{ "Heavy Barrel (USA).nes",          262160, 0x1e79b8a6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_heavybarrel)
STD_ROM_FN(nes_heavybarrel)

struct BurnDriver BurnDrvnes_heavybarrel = {
	"nes_heavybarrel", NULL, NULL, NULL, "1990",
	"Heavy Barrel (USA)\0", NULL, "Data East", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_heavybarrelRomInfo, nes_heavybarrelRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Heavy Shreddin' (USA)
static struct BurnRomInfo nes_heavyshreddinRomDesc[] = {
	{ "Heavy Shreddin' (USA).nes",          262160, 0x86a637b0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_heavyshreddin)
STD_ROM_FN(nes_heavyshreddin)

struct BurnDriver BurnDrvnes_heavyshreddin = {
	"nes_heavyshreddin", NULL, NULL, NULL, "1990",
	"Heavy Shreddin' (USA)\0", NULL, "Parker Brothers", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_heavyshreddinRomInfo, nes_heavyshreddinRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hebereke (Japan)
static struct BurnRomInfo nes_heberekejRomDesc[] = {
	{ "Hebereke (Japan).nes",          262160, 0x2a137974, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_heberekej)
STD_ROM_FN(nes_heberekej)

struct BurnDriver BurnDrvnes_heberekej = {
	"nes_heberekej", "nes_ufouria", NULL, NULL, "1991",
	"Hebereke (Japan)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_heberekejRomInfo, nes_heberekejRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hebereke (Hack, English)
static struct BurnRomInfo nes_heberekeRomDesc[] = {
	{ "Hebereke (T-Eng).nes",          393232, 0xac2e16e9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hebereke)
STD_ROM_FN(nes_hebereke)

struct BurnDriver BurnDrvnes_hebereke = {
	"nes_hebereke", "nes_ufouria", NULL, NULL, "2013",
	"Hebereke (Hack, English)\0", NULL, "BMF54123", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_heberekeRomInfo, nes_heberekeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hector '87 (Japan)
static struct BurnRomInfo nes_hector87RomDesc[] = {
	{ "Hector '87 (Japan).nes",          131088, 0x4b4ba1c6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hector87)
STD_ROM_FN(nes_hector87)

struct BurnDriver BurnDrvnes_hector87 = {
	"nes_hector87", NULL, NULL, NULL, "1987",
	"Hector '87 (Japan)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_hector87RomInfo, nes_hector87RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Heisei Tensai Bakabon (Japan)
static struct BurnRomInfo nes_heisetenbakjRomDesc[] = {
	{ "Heisei Tensai Bakabon (Japan).nes",          262160, 0x141937d0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_heisetenbakj)
STD_ROM_FN(nes_heisetenbakj)

struct BurnDriver BurnDrvnes_heisetenbakj = {
	"nes_heisetenbakj", "nes_heisetenbak", NULL, NULL, "1991",
	"Heisei Tensai Bakabon (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_heisetenbakjRomInfo, nes_heisetenbakjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Heisei Tensai Bakabon (Hack, English)
static struct BurnRomInfo nes_heisetenbakRomDesc[] = {
	{ "Heisei Tensai Bakabon (T-Eng).nes",          393232, 0xc41628ef, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_heisetenbak)
STD_ROM_FN(nes_heisetenbak)

struct BurnDriver BurnDrvnes_heisetenbak = {
	"nes_heisetenbak", NULL, NULL, NULL, "2007",
	"Heisei Tensai Bakabon (Hack, English)\0", NULL, "KingMike", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_heisetenbakRomInfo, nes_heisetenbakRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hell Fighter (Asia) (Unl)
static struct BurnRomInfo nes_hellfighterRomDesc[] = {
	{ "Hell Fighter (Asia) (PAL) (Unl).nes",          327696, 0x61700c98, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hellfighter)
STD_ROM_FN(nes_hellfighter)

struct BurnDriver BurnDrvnes_hellfighter = {
	"nes_hellfighter", NULL, NULL, NULL, "1991",
	"Hell Fighter (Asia) (Unl)\0", NULL, "Sachen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_hellfighterRomInfo, nes_hellfighterRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hello Kitty no Ohanabatake (Japan)
static struct BurnRomInfo nes_hellokitnoohaRomDesc[] = {
	{ "Hello Kitty no Ohanabatake (Japan).nes",          65552, 0x69900690, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hellokitnooha)
STD_ROM_FN(nes_hellokitnooha)

struct BurnDriver BurnDrvnes_hellokitnooha = {
	"nes_hellokitnooha", NULL, NULL, NULL, "1992",
	"Hello Kitty no Ohanabatake (Japan)\0", NULL, "Character Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_hellokitnoohaRomInfo, nes_hellokitnoohaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hello Kitty World (Hack, English)
// https://www.romhacking.net/translations/1398/
static struct BurnRomInfo nes_hellokitworRomDesc[] = {
	{ "Hello Kitty World T-Eng (2009)(Flake).nes",          131088, 0xbd54af4d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hellokitwor)
STD_ROM_FN(nes_hellokitwor)

struct BurnDriver BurnDrvnes_hellokitwor = {
	"nes_hellokitwor", NULL, NULL, NULL, "2009",
	"Hello Kitty World (Hack, English)\0", NULL, "Flake", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_hellokitworRomInfo, nes_hellokitworRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hello Kitty World (Japan)
static struct BurnRomInfo nes_hellokitworjRomDesc[] = {
	{ "Hello Kitty World (Japan)(1992)(Character Soft).nes",          131088, 0x54dc10cd, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hellokitworj)
STD_ROM_FN(nes_hellokitworj)

struct BurnDriver BurnDrvnes_hellokitworj = {
	"nes_hellokitworj", "nes_hellokitwor", NULL, NULL, "1992",
	"Hello Kitty World (Japan)\0", NULL, "Character Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_hellokitworjRomInfo, nes_hellokitworjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Heracles no Eikou - Toujin Makyou Den (Japan)
static struct BurnRomInfo nes_heraclesjRomDesc[] = {
	{ "Heracles no Eikou - Toujin Makyou Den (J)(1987)(Data East).nes",          131088, 0x825f8089, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_heraclesj)
STD_ROM_FN(nes_heraclesj)

struct BurnDriver BurnDrvnes_heraclesj = {
	"nes_heraclesj", "nes_heracles", NULL, NULL, "1987",
	"Heracles no Eikou - Toujin Makyou Den (Japan)\0", NULL, "Data East", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_heraclesjRomInfo, nes_heraclesjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Glory of Heracles, The - Labors of the Divine Hero (Hack, English)
// https://www.romhacking.net/translations/1681/
static struct BurnRomInfo nes_heraclesRomDesc[] = {
	{ "Glory of Heracles, The - Labors of the Divine Hero T-Eng (2014)(DvD Translations).nes",          262160, 0x724489c8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_heracles)
STD_ROM_FN(nes_heracles)

struct BurnDriver BurnDrvnes_heracles = {
	"nes_heracles", NULL, NULL, NULL, "2014",
	"Glory of Heracles, The - Labors of the Divine Hero (Hack, English)\0", NULL, "DvD Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_heraclesRomInfo, nes_heraclesRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Heracles no Eikou II - Titan no Metsubou (Japan)
static struct BurnRomInfo nes_heracles2jRomDesc[] = {
	{ "Heracles no Eikou II - Titan no Metsubou (J)(1989)(Data East).nes",          262160, 0xdfd9a811, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_heracles2j)
STD_ROM_FN(nes_heracles2j)

struct BurnDriver BurnDrvnes_heracles2j = {
	"nes_heracles2j", "nes_heracles2", NULL, NULL, "1989",
	"Heracles no Eikou II - Titan no Metsubou (Japan)\0", NULL, "Data East", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_heracles2jRomInfo, nes_heracles2jRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Glory of Heracles II, The - Titans' Downfall (Hack, English v1.31)
// https://www.romhacking.net/translations/154/
static struct BurnRomInfo nes_heracles2RomDesc[] = {
	{ "Glory of Heracles II, The - Titans' Downfall T-Eng v1.31 (2016)(The Spoony Bard).nes",          262160, 0xce222646, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_heracles2)
STD_ROM_FN(nes_heracles2)

struct BurnDriver BurnDrvnes_heracles2 = {
	"nes_heracles2", NULL, NULL, NULL, "2016",
	"Glory of Heracles II, The - Titans' Downfall (Hack, English v1.31)\0", NULL, "The Spoony Bard", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_heracles2RomInfo, nes_heracles2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hero Quest (Euro) (Prototype)
static struct BurnRomInfo nes_heroquesteRomDesc[] = {
	{ "Hero Quest (Europe) (Prototype).nes",          131088, 0x3a0b6dd2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_heroqueste)
STD_ROM_FN(nes_heroqueste)

struct BurnDriver BurnDrvnes_heroqueste = {
	"nes_heroqueste", "nes_heroquest", NULL, NULL, "1991",
	"Hero Quest (Euro) (Prototype)\0", NULL, "Gremlin Graphics", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_PROTOTYPE, 2, HARDWARE_NES, GBF_RPG | GBF_BOARD, 0,
	NESGetZipName, nes_heroquesteRomInfo, nes_heroquesteRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL, SCREEN_WIDTH, SCREEN_HEIGHT_PAL
};

// Hero Quest (USA) (Prototype)
static struct BurnRomInfo nes_heroquestRomDesc[] = {
	{ "Hero Quest (USA) (Prototype).nes",          131088, 0x60484008, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_heroquest)
STD_ROM_FN(nes_heroquest)

struct BurnDriver BurnDrvnes_heroquest = {
	"nes_heroquest", NULL, NULL, NULL, "1991",
	"Hero Quest (USA) (Prototype)\0", NULL, "Gremlin Graphics", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_PROTOTYPE, 2, HARDWARE_NES, GBF_RPG | GBF_BOARD, 0,
	NESGetZipName, nes_heroquestRomInfo, nes_heroquestRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Higemaru - Makai-jima - Nanatsu no Shima Daibouken (Japan)
static struct BurnRomInfo nes_higemRomDesc[] = {
	{ "Higemaru - Makai-jima - Nanatsu no Shima Daibouken (Japan).nes",          131088, 0xc480eb6d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_higem)
STD_ROM_FN(nes_higem)

struct BurnDriver BurnDrvnes_higem = {
	"nes_higem", NULL, NULL, NULL, "1987",
	"Higemaru - Makai-jima - Nanatsu no Shima Daibouken (Japan)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ADV | GBF_ACTION, 0,
	NESGetZipName, nes_higemRomInfo, nes_higemRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// High Speed (USA)
static struct BurnRomInfo nes_highspeedRomDesc[] = {
	{ "High Speed (USA).nes",          196624, 0x8ca37960, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_highspeed)
STD_ROM_FN(nes_highspeed)

struct BurnDriver BurnDrvnes_highspeed = {
	"nes_highspeed", NULL, NULL, NULL, "1991",
	"High Speed (USA)\0", NULL, "Tradewest", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_PINBALL, 0,
	NESGetZipName, nes_highspeedRomInfo, nes_highspeedRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Highway Star (Japan)
static struct BurnRomInfo nes_highwaystarRomDesc[] = {
	{ "Highway Star (Japan).nes",          131088, 0xd0980131, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_highwaystar)
STD_ROM_FN(nes_highwaystar)

struct BurnDriver BurnDrvnes_highwaystar = {
	"nes_highwaystar", "nes_radracer", NULL, NULL, "1987",
	"Highway Star (Japan)\0", NULL, "Square", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_highwaystarRomInfo, nes_highwaystarRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hikari no Senshi Photon - The Ultimate Game on Planet Earth (Japan)
static struct BurnRomInfo nes_hikarnosenphoulgaonjleaRomDesc[] = {
	{ "Hikari no Senshi Photon - The Ultimate Game on Planet Earth (Japan).nes",          131088, 0x924ae9e4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hikarnosenphoulgaonjlea)
STD_ROM_FN(nes_hikarnosenphoulgaonjlea)

struct BurnDriver BurnDrvnes_hikarnosenphoulgaonjlea = {
	"nes_hikarnosenphoulgaonjlea", "nes_hikarnosenphoulgaon", NULL, NULL, "1987",
	"Hikari no Senshi Photon - The Ultimate Game on Planet Earth (Japan)\0", NULL, "Takara", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_SHOOT | GBF_ADV, 0,
	NESGetZipName, nes_hikarnosenphoulgaonjleaRomInfo, nes_hikarnosenphoulgaonjleaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hikari no Senshi Photon - The Ultimate Game on Planet Earth (Hack, English)
static struct BurnRomInfo nes_hikarnosenphoulgaonRomDesc[] = {
	{ "Hikari no Senshi Photon - The Ultimate Game on Planet Earth (T-Eng).nes",          131088, 0x351a3bf3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hikarnosenphoulgaon)
STD_ROM_FN(nes_hikarnosenphoulgaon)

struct BurnDriver BurnDrvnes_hikarnosenphoulgaon = {
	"nes_hikarnosenphoulgaon", NULL, NULL, NULL, "2003",
	"Hikari no Senshi Photon - The Ultimate Game on Planet Earth (Hack, English)\0", NULL, "KingMike", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_SHOOT | GBF_ADV, 0,
	NESGetZipName, nes_hikarnosenphoulgaonRomInfo, nes_hikarnosenphoulgaonRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hinotori Houou Hen - Gaou no Bouken (Japan)
static struct BurnRomInfo nes_hinothouhenjRomDesc[] = {
	{ "Hinotori Houou Hen - Gaou no Bouken (Japan).nes",          131088, 0x19ccf008, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hinothouhenj)
STD_ROM_FN(nes_hinothouhenj)

struct BurnDriver BurnDrvnes_hinothouhenj = {
	"nes_hinothouhenj", "nes_hinothouhen", NULL, NULL, "1987",
	"Hinotori Houou Hen - Gaou no Bouken (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_hinothouhenjRomInfo, nes_hinothouhenjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hinotori Houou Hen - Gaou no Bouken (Hack, English)
// https://www.romhacking.net/translations/1486/
static struct BurnRomInfo nes_hinothouhenRomDesc[] = {
	{ "Hinotori Houou Hen - Gaou no Bouken (T-Eng).nes",          262160, 0x5f228691, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hinothouhen)
STD_ROM_FN(nes_hinothouhen)

struct BurnDriver BurnDrvnes_hinothouhen = {
	"nes_hinothouhen", NULL, NULL, NULL, "2014",
	"Hinotori Houou Hen - Gaou no Bouken (Hack, English)\0", NULL, "Stardust Crusaders", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_hinothouhenRomInfo, nes_hinothouhenRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hiryuu no Ken - Ougi no Sho (Japan)
static struct BurnRomInfo nes_hiryunokenRomDesc[] = {
	{ "Hiryuu no Ken - Ougi no Sho (Japan).nes",          131088, 0x3887557d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hiryunoken)
STD_ROM_FN(nes_hiryunoken)

struct BurnDriver BurnDrvnes_hiryunoken = {
	"nes_hiryunoken", NULL, NULL, NULL, "1987",
	"Hiryuu no Ken - Ougi no Sho (Japan)\0", NULL, "Culture Brain", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_hiryunokenRomInfo, nes_hiryunokenRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hiryuu no Ken II - Dragon no Tsubasa (Japan)
static struct BurnRomInfo nes_hiryunokeniiRomDesc[] = {
	{ "Hiryuu no Ken II - Dragon no Tsubasa (Japan).nes",          262160, 0x19d51349, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hiryunokenii)
STD_ROM_FN(nes_hiryunokenii)

struct BurnDriver BurnDrvnes_hiryunokenii = {
	"nes_hiryunokenii", NULL, NULL, NULL, "1988",
	"Hiryuu no Ken II - Dragon no Tsubasa (Japan)\0", NULL, "Culture Brain", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_RPG, 0,
	NESGetZipName, nes_hiryunokeniiRomInfo, nes_hiryunokeniiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hiryuu no Ken III - 5 Nin no Ryuu Senshi (Japan)
static struct BurnRomInfo nes_hiryunokeniiiRomDesc[] = {
	{ "Hiryuu no Ken III - 5 Nin no Ryuu Senshi (Japan).nes",          262160, 0xa5f185c3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hiryunokeniii)
STD_ROM_FN(nes_hiryunokeniii)

struct BurnDriver BurnDrvnes_hiryunokeniii = {
	"nes_hiryunokeniii", NULL, NULL, NULL, "1990",
	"Hiryuu no Ken III - 5 Nin no Ryuu Senshi (Japan)\0", NULL, "Culture Brain", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_RPG, 0,
	NESGetZipName, nes_hiryunokeniiiRomInfo, nes_hiryunokeniiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hiryuu no Ken Special - Fighting Wars (Japan)
static struct BurnRomInfo nes_hiryunokenspeRomDesc[] = {
	{ "Hiryuu no Ken Special - Fighting Wars (Japan).nes",          262160, 0x6a2450a8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hiryunokenspe)
STD_ROM_FN(nes_hiryunokenspe)

struct BurnDriver BurnDrvnes_hiryunokenspe = {
	"nes_hiryunokenspe", NULL, NULL, NULL, "1991",
	"Hiryuu no Ken Special - Fighting Wars (Japan)\0", NULL, "Culture Brain", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_hiryunokenspeRomInfo, nes_hiryunokenspeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hitler no Fukkatsu - Top Secret (China)
static struct BurnRomInfo nes_hitlenofukcRomDesc[] = {
	{ "Hitler no Fukkatsu - Top Secret (China).nes",          294928, 0x1dd2194c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hitlenofukc)
STD_ROM_FN(nes_hitlenofukc)

struct BurnDriver BurnDrvnes_hitlenofukc = {
	"nes_hitlenofukc", "nes_bioniccommando", NULL, NULL, "1988",
	"Hitler no Fukkatsu - Top Secret (China)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_hitlenofukcRomInfo, nes_hitlenofukcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hitler no Fukkatsu - Top Secret (Japan)
static struct BurnRomInfo nes_hitlenofukRomDesc[] = {
	{ "Hitler no Fukkatsu - Top Secret (Japan).nes",          262160, 0x4749e48f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hitlenofuk)
STD_ROM_FN(nes_hitlenofuk)

struct BurnDriver BurnDrvnes_hitlenofuk = {
	"nes_hitlenofuk", "nes_bioniccommando", NULL, NULL, "1988",
	"Hitler no Fukkatsu - Top Secret (Japan)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_hitlenofukRomInfo, nes_hitlenofukRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hogan's Alley (USA)
static struct BurnRomInfo nes_hogansalleyRomDesc[] = {
	{ "Hogan's Alley (USA).nes",          24592, 0x9d39585b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hogansalley)
STD_ROM_FN(nes_hogansalley)

struct BurnDriver BurnDrvnes_hogansalley = {
	"nes_hogansalley", NULL, NULL, NULL, "1984",
	"Hogan's Alley (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_hogansalleyRomInfo, nes_hogansalleyRomName, NULL, NULL, NULL, NULL, NESZapperInputInfo, NESZapperDIPInfo,
	NESZapperInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hokuto no Ken (Japan)
static struct BurnRomInfo nes_hokutonokenRomDesc[] = {
	{ "Hokuto no Ken (Japan).nes",          65552, 0x2f88a21f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hokutonoken)
STD_ROM_FN(nes_hokutonoken)

struct BurnDriver BurnDrvnes_hokutonoken = {
	"nes_hokutonoken", NULL, NULL, NULL, "1986",
	"Hokuto no Ken (Japan)\0", NULL, "Toei Animation", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_hokutonokenRomInfo, nes_hokutonokenRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hokuto no Ken OVERHAUL Patch (Hack)
static struct BurnRomInfo nes_hokutonokenopRomDesc[] = {
	{ "Hokuto no Ken OVERHAUL Patch (2022)(Rani Baker).nes",          65552, 0xb02b18fa, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hokutonokenop)
STD_ROM_FN(nes_hokutonokenop)

struct BurnDriver BurnDrvnes_hokutonokenop = {
	"nes_hokutonokenop", "nes_hokutonoken", NULL, NULL, "2022",
	"Hokuto no Ken OVERHAUL Patch (Hack)\0", "Graphics improvement", "Rani Baker", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_hokutonokenopRomInfo, nes_hokutonokenopRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hokuto no Ken 2 (Japan)
static struct BurnRomInfo nes_hokutonoken2RomDesc[] = {
	{ "Hokuto no Ken 2 (Japan).nes",          131088, 0xe2fe0c0e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hokutonoken2)
STD_ROM_FN(nes_hokutonoken2)

struct BurnDriver BurnDrvnes_hokutonoken2 = {
	"nes_hokutonoken2", NULL, NULL, NULL, "1987",
	"Hokuto no Ken 2 (Japan)\0", NULL, "Toei Animation", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_hokutonoken2RomInfo, nes_hokutonoken2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hokuto no Ken 3 - Shin Seiki Souzou Seiken Restuden (Japan)
static struct BurnRomInfo nes_hokutonoken3jRomDesc[] = {
	{ "hokuto no ken 3 - shin seiki souzou seiken restuden (japan).nes",          262160, 0x12b32580, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hokutonoken3j)
STD_ROM_FN(nes_hokutonoken3j)

struct BurnDriver BurnDrvnes_hokutonoken3j = {
	"nes_hokutonoken3j", "nes_hokutonoken3", NULL, NULL, "1989",
	"Hokuto no Ken 3 - Shin Seiki Souzou Seiken Restuden (Japan)\0", NULL, "TOEI Animation", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_hokutonoken3jRomInfo, nes_hokutonoken3jRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hokuto no Ken 3 - Shin Seiki Souzou Seiken Restuden (Hack, English)
// https://www.romhacking.net/translations/7224/
static struct BurnRomInfo nes_hokutonoken3RomDesc[] = {
	{ "Hokuto no Ken 3 - Shin Seiki Souzou Seiken Retsuden T-Eng (2024)(BlackPaladin).nes",          524304, 0x8b1eb74a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hokutonoken3)
STD_ROM_FN(nes_hokutonoken3)

struct BurnDriver BurnDrvnes_hokutonoken3 = {
	"nes_hokutonoken3", NULL, NULL, NULL, "2024",
	"Hokuto no Ken 3 - Shin Seiki Souzou Seiken Restuden (Hack, English)\0", NULL, "BlackPaladin", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_hokutonoken3RomInfo, nes_hokutonoken3RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hokuto no Ken 4 - Shichisei Haken Den (Japan)
static struct BurnRomInfo nes_hokutonoken4RomDesc[] = {
	{ "Hokuto no Ken 4 - Shichisei Haken Den Jpn (1991)(Shouei System).nes",          262160, 0x06e95541, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hokutonoken4)
STD_ROM_FN(nes_hokutonoken4)

struct BurnDriver BurnDrvnes_hokutonoken4 = {
	"nes_hokutonoken4", NULL, NULL, NULL, "1991",
	"Hokuto no Ken 4 - Shichisei Haken Den (Japan)\0", NULL, "TOEI Animation", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_hokutonoken4RomInfo, nes_hokutonoken4RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Holy Diver (Japan)
static struct BurnRomInfo nes_holydiverjRomDesc[] = {
	{ "Holy Diver (Japan).nes",          262160, 0xc4cf0e8e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_holydiverj)
STD_ROM_FN(nes_holydiverj)

struct BurnDriver BurnDrvnes_holydiverj = {
	"nes_holydiverj", "nes_holydiver", NULL, NULL, "1989",
	"Holy Diver (Japan)\0", NULL, "Irem", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM | GBF_RUNGUN, 0,
	NESGetZipName, nes_holydiverjRomInfo, nes_holydiverjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Holy Diver (Hack, English)
static struct BurnRomInfo nes_holydiverRomDesc[] = {
	{ "Holy Diver (T-Eng).nes",          262160, 0x28d1d380, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_holydiver)
STD_ROM_FN(nes_holydiver)

struct BurnDriver BurnDrvnes_holydiver = {
	"nes_holydiver", NULL, NULL, NULL, "2007",
	"Holy Diver (Hack, English)\0", NULL, "Monaco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_RUNGUN, 0,
	NESGetZipName, nes_holydiverRomInfo, nes_holydiverRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Home Alone (USA) (Rev A)
static struct BurnRomInfo nes_homealoneRomDesc[] = {
	{ "Home Alone (USA) (Rev A).nes",          262160, 0xd98e3e31, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_homealone)
STD_ROM_FN(nes_homealone)

struct BurnDriver BurnDrvnes_homealone = {
	"nes_homealone", NULL, NULL, NULL, "1991",
	"Home Alone (USA) (Rev A)\0", NULL, "THQ", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_homealoneRomInfo, nes_homealoneRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Home Alone 2 - Lost in New York (USA)
static struct BurnRomInfo nes_homealo2RomDesc[] = {
	{ "Home Alone 2 - Lost in New York (USA).nes",          262160, 0x04944924, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_homealo2)
STD_ROM_FN(nes_homealo2)

struct BurnDriver BurnDrvnes_homealo2 = {
	"nes_homealo2", NULL, NULL, NULL, "1992",
	"Home Alone 2 - Lost in New York (USA)\0", NULL, "THQ", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_homealo2RomInfo, nes_homealo2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Honoo no Doukyuuji - Dodge Danpei (Japan)
static struct BurnRomInfo nes_ddballjRomDesc[] = {
	{ "Honoo no Doukyuuji - Dodge Danpei (J)(1992)(Sunsoft).nes",          393232, 0xaea2a320, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ddballj)
STD_ROM_FN(nes_ddballj)

struct BurnDriver BurnDrvnes_ddballj = {
	"nes_ddballj", "nes_ddball", NULL, NULL, "1992",
	"Honoo no Doukyuuji - Dan's Dodge Ball (Japan)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ADV | GBF_STRATEGY, 0,
	NESGetZipName, nes_ddballjRomInfo, nes_ddballjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Honoo no Doukyuuji - Dodge Danpei (Hack, English v1.0b)
// https://www.romhacking.net/translations/1255/
static struct BurnRomInfo nes_ddballRomDesc[] = {
	{ "Honoo no Doukyuuji - Dodge Danpei T-Eng v1.0.b (2017)(TransGen).nes",          393232, 0x47325872, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ddball)
STD_ROM_FN(nes_ddball)

struct BurnDriver BurnDrvnes_ddball = {
	"nes_ddball", NULL, NULL, NULL, "2017",
	"Honoo no Doukyuuji - Dan's Dodge Ball (Hack, English v1.0b)\0", NULL, "TransGen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_ADV | GBF_STRATEGY, 0,
	NESGetZipName, nes_ddballRomInfo, nes_ddballRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Honoo no Doukyuuji - Dodge Danpei 2 (Japan)
static struct BurnRomInfo nes_ddball2jRomDesc[] = {
	{ "Honoo no Doukyuuji - Dodge Danpei 2 (J)(1993)(Sunsoft).nes",          524304, 0x646666f2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ddball2j)
STD_ROM_FN(nes_ddball2j)

struct BurnDriver BurnDrvnes_ddball2j = {
	"nes_ddball2j", "nes_ddball2", NULL, NULL, "1993",
	"Honoo no Doukyuuji - Dan's Dodge Ball 2 (Japan)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ADV | GBF_STRATEGY, 0,
	NESGetZipName, nes_ddball2jRomInfo, nes_ddball2jRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Honoo no Doukyuuji - Dodge Danpei 2 (Hack, English v1.0a)
// https://www.romhacking.net/translations/1269/
static struct BurnRomInfo nes_ddball2RomDesc[] = {
	{ "Honoo no Doukyuuji - Dodge Danpei 2 T-Eng v1.0a (2017)(TransGen).nes",          524304, 0x95469699, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ddball2)
STD_ROM_FN(nes_ddball2)

struct BurnDriver BurnDrvnes_ddball2 = {
	"nes_ddball2", NULL, NULL, NULL, "2017",
	"Honoo no Doukyuuji - Dan's Dodge Ball 2 (Hack, English v1.0a)\0", NULL, "TransGen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_ADV | GBF_STRATEGY, 0,
	NESGetZipName, nes_ddball2RomInfo, nes_ddball2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hook (USA)
static struct BurnRomInfo nes_hookRomDesc[] = {
	{ "Hook (USA).nes",          262160, 0xb5902c20, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hook)
STD_ROM_FN(nes_hook)

struct BurnDriver BurnDrvnes_hook = {
	"nes_hook", NULL, NULL, NULL, "1992",
	"Hook (USA)\0", NULL, "Sony Imagesoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_hookRomInfo, nes_hookRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hoppin' Mad (Prototype)
static struct BurnRomInfo nes_hoppinmadRomDesc[] = {
	{ "Hoppin' Mad (Proto)(1989)(Nowhere Prod.).nes",          40976, 0xac45ada9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hoppinmad)
STD_ROM_FN(nes_hoppinmad)

struct BurnDriver BurnDrvnes_hoppinmad = {
	"nes_hoppinmad", NULL, NULL, NULL, "1989",
	"Hoppin' Mad (Prototype)\0", NULL, "Nowhere Productions", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_PROTOTYPE, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_hoppinmadRomInfo, nes_hoppinmadRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hostages - The Embassy Mission (Japan)
static struct BurnRomInfo nes_hostaRomDesc[] = {
	{ "Hostages - The Embassy Mission (Japan).nes",          262160, 0xe876b411, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hosta)
STD_ROM_FN(nes_hosta)

struct BurnDriver BurnDrvnes_hosta = {
	"nes_hosta", "nes_rescue", NULL, NULL, "1989",
	"Hostages - The Embassy Mission (Japan)\0", NULL, "Kemco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_SHOOT | GBF_ADV, 0,
	NESGetZipName, nes_hostaRomInfo, nes_hostaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hottaaman no Chitei Tanken (Japan)
static struct BurnRomInfo nes_hottanochitanRomDesc[] = {
	{ "Hottaaman no Chitei Tanken (Japan).nes",          65552, 0x7d5ee762, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hottanochitan)
STD_ROM_FN(nes_hottanochitan)

struct BurnDriver BurnDrvnes_hottanochitan = {
	"nes_hottanochitan", NULL, NULL, NULL, "1986",
	"Hottaaman no Chitei Tanken (Japan)\0", NULL, "Use", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_hottanochitanRomInfo, nes_hottanochitanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hudson Hawk (USA)
static struct BurnRomInfo nes_hudsonhawkRomDesc[] = {
	{ "Hudson Hawk (USA).nes",          262160, 0x37fc3443, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hudsonhawk)
STD_ROM_FN(nes_hudsonhawk)

struct BurnDriver BurnDrvnes_hudsonhawk = {
	"nes_hudsonhawk", NULL, NULL, NULL, "1992",
	"Hudson Hawk (USA)\0", NULL, "Sony Imagesoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_hudsonhawkRomInfo, nes_hudsonhawkRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hunt for Red October, The (USA)
static struct BurnRomInfo nes_huntredoctRomDesc[] = {
	{ "Hunt for Red October, The (USA).nes",          262160, 0x64e47ba8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_huntredoct)
STD_ROM_FN(nes_huntredoct)

struct BurnDriver BurnDrvnes_huntredoct = {
	"nes_huntredoct", NULL, NULL, NULL, "1991",
	"Hunt for Red October, The (USA)\0", NULL, "Hi Tech Expressions", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_huntredoctRomInfo, nes_huntredoctRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

//Hyaku no Sekai no Monogatari - The 100 World Story (Hack, English)
static struct BurnRomInfo nes_hyakuenRomDesc[] = {
	{ "Hyaku no Sekai no Monogatari - The 100 World Story (T-Eng)(2007)(AlanMidas).nes",	262160, 0x1385e8a5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hyakuen)
STD_ROM_FN(nes_hyakuen)

struct BurnDriver BurnDrvnes_hyakuen = {
	"nes_hyakuen", NULL, NULL, NULL, "2007",
	"Hyaku no Sekai no Monogatari - The 100 World Story (Hack, English)\0", NULL, "AlanMidas", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 4, HARDWARE_NES, GBF_ADV | GBF_BOARD, 0,
	NESGetZipName, nes_hyakuenRomInfo, nes_hyakuenRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

//Hyaku no Sekai no Monogatari ~ The 100 World Story (Hack, Italian)
static struct BurnRomInfo nes_hyakuitRomDesc[] = {
	{ "Hyaku no Sekai no Monogatari - The 100 World Story (T-Ita)(2021)(Mog).nes",	262160, 0x4d740153, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hyakuit)
STD_ROM_FN(nes_hyakuit)

struct BurnDriver BurnDrvnes_hyakuit = {
	"nes_hyakuit", "nes_hyakuen", NULL, NULL, "2021",
	"Hyaku no Sekai no Monogatari ~ The 100 World Story (Hack, Italian)\0", NULL, "Mog", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 4, HARDWARE_NES, GBF_ADV | GBF_BOARD, 0,
	NESGetZipName, nes_hyakuitRomInfo, nes_hyakuitRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

//Hyaku no Sekai no Monogatari ~ The 100 World Story (Japan)
static struct BurnRomInfo nes_hyakujpRomDesc[] = {
	{ "Hyaku no Sekai no Monogatari - The 100 World Story (J)(1991)(ASK).nes",	262160, 0x84ed70ce, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hyakujp)
STD_ROM_FN(nes_hyakujp)

struct BurnDriver BurnDrvnes_hyakujp = {
	"nes_hyakujp", "nes_hyakuen", NULL, NULL, "1991",
	"Hyaku no Sekai no Monogatari ~ The 100 World Story (Japan)\0", NULL, "ASK", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 4, HARDWARE_NES, GBF_ADV | GBF_BOARD, 0,
	NESGetZipName, nes_hyakujpRomInfo, nes_hyakujpRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hydlide (USA)
static struct BurnRomInfo nes_hydlideRomDesc[] = {
	{ "hydlide (usa).nes",          40976, 0x8962aebf, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hydlide)
STD_ROM_FN(nes_hydlide)

struct BurnDriver BurnDrvnes_hydlide = {
	"nes_hydlide", NULL, NULL, NULL, "1989",
	"Hydlide (USA)\0", NULL, "Pony Canyon", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_hydlideRomInfo, nes_hydlideRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hydlide Special (Japan)
static struct BurnRomInfo nes_hydlidejRomDesc[] = {
	{ "Hydlide Special (J) (1986)(T&E Soft).nes",          40976, 0x6207ba15, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hydlidej)
STD_ROM_FN(nes_hydlidej)

struct BurnDriver BurnDrvnes_hydlidej = {
	"nes_hydlidej", "nes_hydlide", NULL, NULL, "1986",
	"Hydlide Special (Japan)\0", NULL, "T&E Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_hydlidejRomInfo, nes_hydlidejRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ice Climber (USA, Europe)
static struct BurnRomInfo nes_iceclimberRomDesc[] = {
	{ "Ice Climber (USA, Europe).nes",          24592, 0x70044a74, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_iceclimber)
STD_ROM_FN(nes_iceclimber)

struct BurnDriver BurnDrvnes_iceclimber = {
	"nes_iceclimber", NULL, NULL, NULL, "1985",
	"Ice Climber (USA, Europe)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_iceclimberRomInfo, nes_iceclimberRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ice Hockey (USA)
static struct BurnRomInfo nes_icehockeyRomDesc[] = {
	{ "Ice Hockey (USA).nes",          40976, 0x4916d0a9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_icehockey)
STD_ROM_FN(nes_icehockey)

struct BurnDriver BurnDrvnes_icehockey = {
	"nes_icehockey", NULL, NULL, NULL, "1988",
	"Ice Hockey (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_icehockeyRomInfo, nes_icehockeyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ice Ice! Hockey Challenge (Hack, English)
static struct BurnRomInfo nes_iceicehocchaRomDesc[] = {
	{ "Ice Ice! Hockey Challenge (T-Eng).nes",          262160, 0xd61c628e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_iceicehoccha)
STD_ROM_FN(nes_iceicehoccha)

struct BurnDriver BurnDrvnes_iceicehoccha = {
	"nes_iceicehoccha", NULL, NULL, NULL, "2014",
	"Ice Ice! Hockey Challenge (Hack, English)\0", NULL, "TransBRC", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_iceicehocchaRomInfo, nes_iceicehocchaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ikari Warriors (USA) (Rev A)
static struct BurnRomInfo nes_ikariwarriorsRomDesc[] = {
	{ "Ikari Warriors (USA) (Rev A).nes",          131088, 0xeed05076, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ikariwarriors)
STD_ROM_FN(nes_ikariwarriors)

struct BurnDriver BurnDrvnes_ikariwarriors = {
	"nes_ikariwarriors", NULL, NULL, NULL, "1987",
	"Ikari Warriors (USA) (Rev A)\0", NULL, "SNK", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_ikariwarriorsRomInfo, nes_ikariwarriorsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ikari Warriors II - Victory Road (USA)
static struct BurnRomInfo nes_ikariwariiRomDesc[] = {
	{ "Ikari Warriors II - Victory Road (USA).nes",          262160, 0x1eaf333c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ikariwarii)
STD_ROM_FN(nes_ikariwarii)

struct BurnDriver BurnDrvnes_ikariwarii = {
	"nes_ikariwarii", NULL, NULL, NULL, "1988",
	"Ikari Warriors II - Victory Road (USA)\0", NULL, "SNK", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_ikariwariiRomInfo, nes_ikariwariiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ikari Warriors III - The Rescue (USA)
static struct BurnRomInfo nes_ikariwariiiRomDesc[] = {
	{ "Ikari Warriors III - The Rescue (USA).nes",          262160, 0x3bcd370e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ikariwariii)
STD_ROM_FN(nes_ikariwariii)

struct BurnDriver BurnDrvnes_ikariwariii = {
	"nes_ikariwariii", NULL, NULL, NULL, "1991",
	"Ikari Warriors III - The Rescue (USA)\0", NULL, "SNK", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_ikariwariiiRomInfo, nes_ikariwariiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ike Ike! Nekketsu Hockey-bu - Subette Koronde Dairantou (Japan)
static struct BurnRomInfo nes_ikeikenekhocbuRomDesc[] = {
	{ "Ike Ike! Nekketsu Hockey-bu - Subette Koronde Dairantou (Japan).nes",          262160, 0x920be27c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ikeikenekhocbu)
STD_ROM_FN(nes_ikeikenekhocbu)

struct BurnDriver BurnDrvnes_ikeikenekhocbu = {
	"nes_ikeikenekhocbu", "nes_iceicehoccha", NULL, NULL, "1992",
	"Ike Ike! Nekketsu Hockey-bu - Subette Koronde Dairantou (Japan)\0", NULL, "Technos", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_ikeikenekhocbuRomInfo, nes_ikeikenekhocbuRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NESHori4pInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ikki (Japan)
static struct BurnRomInfo nes_ikkiRomDesc[] = {
	{ "Ikki (Japan).nes",          24592, 0xe00264b5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ikki)
STD_ROM_FN(nes_ikki)

struct BurnDriver BurnDrvnes_ikki = {
	"nes_ikki", NULL, NULL, NULL, "1985",
	"Ikki (Japan)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_ikkiRomInfo, nes_ikkiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// I Love Softball (Hack, English v0.991)
// https://gbatemp.net/download/i-love-softball-english-translation.36647/updates
static struct BurnRomInfo nes_ilovesballRomDesc[] = {
	{ "I Love Softball T-Eng v0.991 (2023)(MrRichard999).nes",          262160, 0xcb41b78c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ilovesball)
STD_ROM_FN(nes_ilovesball)

struct BurnDriver BurnDrvnes_ilovesball = {
	"nes_ilovesball", NULL, NULL, NULL, "2023",
	"I Love Softball (Hack, English v0.991)\0", NULL, "MrRichard999", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_ilovesballRomInfo, nes_ilovesballRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// I Love Softball (Japan)
static struct BurnRomInfo nes_ilovesballjRomDesc[] = {
	{ "I Love Softball (J)(1989)(Coconuts Japan).nes",          262160, 0xc7f03980, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ilovesballj)
STD_ROM_FN(nes_ilovesballj)

struct BurnDriver BurnDrvnes_ilovesballj = {
	"nes_ilovesballj", "nes_ilovesball", NULL, NULL, "1989",
	"I Love Softball (Japan)\0", NULL, "Coconuts Japan", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_ilovesballjRomInfo, nes_ilovesballjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Image Fight (USA)
static struct BurnRomInfo nes_imagefightRomDesc[] = {
	{ "Image Fight (USA).nes",          262160, 0x2f1c2b30, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_imagefight)
STD_ROM_FN(nes_imagefight)

struct BurnDriver BurnDrvnes_imagefight = {
	"nes_imagefight", NULL, NULL, NULL, "1990",
	"Image Fight (USA)\0", NULL, "Irem", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_imagefightRomInfo, nes_imagefightRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Immortal, The (USA)
static struct BurnRomInfo nes_immortaltheRomDesc[] = {
	{ "Immortal, The (USA).nes",          393232, 0xaceb84c1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_immortalthe)
STD_ROM_FN(nes_immortalthe)

struct BurnDriver BurnDrvnes_immortalthe = {
	"nes_immortalthe", NULL, NULL, NULL, "1990",
	"Immortal, The (USA)\0", NULL, "Electronic Arts", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG | GBF_RUNGUN, 0,
	NESGetZipName, nes_immortaltheRomInfo, nes_immortaltheRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Impossible Mission II (USA)
static struct BurnRomInfo nes_imposmisiiRomDesc[] = {
	{ "Impossible Mission II (USA).nes",          131088, 0xf73d26d6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_imposmisii)
STD_ROM_FN(nes_imposmisii)

struct BurnDriver BurnDrvnes_imposmisii = {
	"nes_imposmisii", NULL, NULL, NULL, "1989",
	"Impossible Mission II (USA)\0", NULL, "American Video Entertainment", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_imposmisiiRomInfo, nes_imposmisiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Incredible Crash Dummies, The (USA)
static struct BurnRomInfo nes_increcradumRomDesc[] = {
	{ "Incredible Crash Dummies, The (USA).nes",          393232, 0x8c684ea4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_increcradum)
STD_ROM_FN(nes_increcradum)

struct BurnDriver BurnDrvnes_increcradum = {
	"nes_increcradum", NULL, NULL, NULL, "1994",
	"Incredible Crash Dummies, The (USA)\0", NULL, "Ljn", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_increcradumRomInfo, nes_increcradumRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Indiana Jones and the Last Crusade (USA) (Taito)
static struct BurnRomInfo nes_indiajonandlascrtRomDesc[] = {
	{ "Indiana Jones and the Last Crusade (USA) (Taito).nes",          262160, 0xda23166a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_indiajonandlascrt)
STD_ROM_FN(nes_indiajonandlascrt)

struct BurnDriver BurnDrvnes_indiajonandlascrt = {
	"nes_indiajonandlascrt", "nes_indiajonandlascr", NULL, NULL, "1991",
	"Indiana Jones and the Last Crusade (USA) (Taito)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_indiajonandlascrtRomInfo, nes_indiajonandlascrtRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Indiana Jones and the Last Crusade (USA) (UBI Soft)
static struct BurnRomInfo nes_indiajonandlascrRomDesc[] = {
	{ "Indiana Jones and the Last Crusade (USA) (UBI Soft).nes",          131088, 0xed5fa6c4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_indiajonandlascr)
STD_ROM_FN(nes_indiajonandlascr)

struct BurnDriver BurnDrvnes_indiajonandlascr = {
	"nes_indiajonandlascr", NULL, NULL, NULL, "1993",
	"Indiana Jones and the Last Crusade (USA) (UBI Soft)\0", NULL, "UBI Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_indiajonandlascrRomInfo, nes_indiajonandlascrRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Indiana Jones and the Temple of Doom (USA) (Rev A)
static struct BurnRomInfo nes_indiajonandtemdoRomDesc[] = {
	{ "Indiana Jones and the Temple of Doom (USA) (Rev A).nes",          196624, 0xf07d31b2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_indiajonandtemdo)
STD_ROM_FN(nes_indiajonandtemdo)

struct BurnDriver BurnDrvnes_indiajonandtemdo = {
	"nes_indiajonandtemdo", NULL, NULL, NULL, "1988",
	"Indiana Jones and the Temple of Doom (USA) (Rev A)\0", NULL, "Mindscape", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_indiajonandtemdoRomInfo, nes_indiajonandtemdoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Infiltrator (USA)
static struct BurnRomInfo nes_infiltratorRomDesc[] = {
	{ "Infiltrator (USA).nes",          262160, 0xf5f79ea9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_infiltrator)
STD_ROM_FN(nes_infiltrator)

struct BurnDriver BurnDrvnes_infiltrator = {
	"nes_infiltrator", NULL, NULL, NULL, "1990",
	"Infiltrator (USA)\0", NULL, "Mindscape", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SIM | GBF_ADV, 0,
	NESGetZipName, nes_infiltratorRomInfo, nes_infiltratorRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Insector X (Japan)
static struct BurnRomInfo nes_insectorxRomDesc[] = {
	{ "Insector X (Japan).nes",          262160, 0x7dab812d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_insectorx)
STD_ROM_FN(nes_insectorx)

struct BurnDriver BurnDrvnes_insectorx = {
	"nes_insectorx", NULL, NULL, NULL, "1990",
	"Insector X (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_insectorxRomInfo, nes_insectorxRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// International Cricket (Australia)
static struct BurnRomInfo nes_intercriRomDesc[] = {
	{ "International Cricket (Australia).nes",          262160, 0xcbde707e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_intercri)
STD_ROM_FN(nes_intercri)

struct BurnDriver BurnDrvnes_intercri = {
	"nes_intercri", NULL, NULL, NULL, "1992",
	"International Cricket (Australia)\0", NULL, "Beam Software", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_intercriRomInfo, nes_intercriRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Iron Tank - The Invasion of Normandy (USA)
static struct BurnRomInfo nes_irontanRomDesc[] = {
	{ "Iron Tank - The Invasion of Normandy (USA).nes",          262160, 0xdcfd85fc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_irontan)
STD_ROM_FN(nes_irontan)

struct BurnDriver BurnDrvnes_irontan = {
	"nes_irontan", NULL, NULL, NULL, "1988",
	"Iron Tank - The Invasion of Normandy (USA)\0", NULL, "SNK", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_irontanRomInfo, nes_irontanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ironsword - Wizards & Warriors II (USA)
static struct BurnRomInfo nes_ironsRomDesc[] = {
	{ "Ironsword - Wizards & Warriors II (USA).nes",          262160, 0xbe2e7055, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_irons)
STD_ROM_FN(nes_irons)

struct BurnDriver BurnDrvnes_irons = {
	"nes_irons", NULL, NULL, NULL, "1989",
	"Ironsword - Wizards & Warriors II (USA)\0", NULL, "Acclaim", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_ironsRomInfo, nes_ironsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Isolated Warrior (USA)
static struct BurnRomInfo nes_isolatedwarriorRomDesc[] = {
	{ "Isolated Warrior (USA).nes",          262160, 0x43d7a888, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_isolatedwarrior)
STD_ROM_FN(nes_isolatedwarrior)

struct BurnDriver BurnDrvnes_isolatedwarrior = {
	"nes_isolatedwarrior", NULL, NULL, NULL, "1991",
	"Isolated Warrior (USA)\0", NULL, "NTVIC", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_isolatedwarriorRomInfo, nes_isolatedwarriorRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ivan 'Ironman' Stewart's Super Off Road (USA)
static struct BurnRomInfo nes_ivanirostessuoffroRomDesc[] = {
	{ "Ivan 'Ironman' Stewart's Super Off Road (USA).nes",          131088, 0xbbab7334, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ivanirostessuoffro)
STD_ROM_FN(nes_ivanirostessuoffro)

struct BurnDriver BurnDrvnes_ivanirostessuoffro = {
	"nes_ivanirostessuoffro", NULL, NULL, NULL, "1990",
	"Ivan 'Ironman' Stewart's Super Off Road (USA)\0", NULL, "Tradewest", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_ivanirostessuoffroRomInfo, nes_ivanirostessuoffroRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// J.League Fighting Soccer - The King of Ace Strikers (Japan)
static struct BurnRomInfo nes_jleafigsocRomDesc[] = {
	{ "J.League Fighting Soccer - The King of Ace Strikers (Japan).nes",          262160, 0x6975d3cd, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jleafigsoc)
STD_ROM_FN(nes_jleafigsoc)

struct BurnDriver BurnDrvnes_jleafigsoc = {
	"nes_jleafigsoc", NULL, NULL, NULL, "1993",
	"J.League Fighting Soccer - The King of Ace Strikers (Japan)\0", NULL, "IGS", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSFOOTBALL, 0,
	NESGetZipName, nes_jleafigsocRomInfo, nes_jleafigsocRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_jleawingoaRomDesc[] = {
	{ "J.League Winning Goal (Japan).nes",          262160, 0xe043afbe, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jleawingoa)
STD_ROM_FN(nes_jleawingoa)

struct BurnDriver BurnDrvnes_jleawingoa = {
	"nes_jleawingoa", NULL, NULL, NULL, "1994",
	"J.League Winning Goal (Japan)\0", NULL, "Electronic Arts", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSFOOTBALL, 0,
	NESGetZipName, nes_jleawingoaRomInfo, nes_jleawingoaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_jacknicgre18homachgRomDesc[] = {
	{ "Jack Nicklaus' Greatest 18 Holes of Major Championship Golf (USA).nes",          131088, 0xf01a3c60, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jacknicgre18homachg)
STD_ROM_FN(nes_jacknicgre18homachg)

struct BurnDriver BurnDrvnes_jacknicgre18homachg = {
	"nes_jacknicgre18homachg", NULL, NULL, NULL, "1990",
	"Jack Nicklaus' Greatest 18 Holes of Major Championship Golf (USA)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_jacknicgre18homachgRomInfo, nes_jacknicgre18homachgRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_jackalRomDesc[] = {
	{ "Jackal (USA).nes",          131088, 0xd7dfa90f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jackal)
STD_ROM_FN(nes_jackal)

struct BurnDriver BurnDrvnes_jackal = {
	"nes_jackal", NULL, NULL, NULL, "1988",
	"Jackal (USA)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_jackalRomInfo, nes_jackalRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_jackiechanjRomDesc[] = {
	{ "Jackie Chan (Japan).nes",          262160, 0xc342a9dd, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jackiechanj)
STD_ROM_FN(nes_jackiechanj)

struct BurnDriver BurnDrvnes_jackiechanj = {
	"nes_jackiechanj", "nes_jackiechan", NULL, NULL, "1991",
	"Jackie Chan (Japan)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM | GBF_SCRFIGHT, 0,
	NESGetZipName, nes_jackiechanjRomInfo, nes_jackiechanjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_jackiechanRomDesc[] = {
	{ "Jackie Chan (USA).nes",          262160, 0x6f371f16, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jackiechan)
STD_ROM_FN(nes_jackiechan)

struct BurnDriver BurnDrvnes_jackiechan = {
	"nes_jackiechan", NULL, NULL, NULL, "1990",
	"Jackie Chan (USA)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM | GBF_SCRFIGHT, 0,
	NESGetZipName, nes_jackiechanRomInfo, nes_jackiechanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Jajamaru Gekimaden - Maboroshi no Kinmajou (Japan)
static struct BurnRomInfo nes_jajamgekjRomDesc[] = {
	{ "Jajamaru Gekimaden - Maboroshi no Kinmajou (Japan).nes",          262160, 0x44902c90, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jajamgekj)
STD_ROM_FN(nes_jajamgekj)

struct BurnDriver BurnDrvnes_jajamgekj = {
	"nes_jajamgekj", "nes_jajamgek", NULL, NULL, "1990",
	"Jajamaru Gekimaden - Maboroshi no Kinmajou (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_jajamgekjRomInfo, nes_jajamgekjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Jajamaru Gekimaden - Maboroshi no Kinmajou (Hack, English)
static struct BurnRomInfo nes_jajamgekeRomDesc[] = {
	{ "Jajamaru Gekimaden - Maboroshi no Kinmajou (T-Eng).nes",          262160, 0x367df135, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jajamgeke)
STD_ROM_FN(nes_jajamgeke)

struct BurnDriver BurnDrvnes_jajamgeke = {
	"nes_jajamgeke", "nes_jajamgek", NULL, NULL, "2009",
	"Jajamaru Gekimaden - Maboroshi no Kinmajou (Hack, English)\0", NULL, "Stardust Crusaders", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_jajamgekeRomInfo, nes_jajamgekeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ninja JaJaMaru - Legend of The Golden Castle (English)
static struct BurnRomInfo nes_jajamgekRomDesc[] = {
	{ "Ninja JaJaMaru - Legend of The Golden Castle T-Eng (1990-2023)(Jaleco).nes",          458240, 0xd243a931, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jajamgek)
STD_ROM_FN(nes_jajamgek)

struct BurnDriver BurnDrvnes_jajamgek = {
	"nes_jajamgek", NULL, NULL, NULL, "2023",
	"Ninja JaJaMaru - Legend of The Golden Castle (English)\0", "Official Translation", "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_jajamgekRomInfo, nes_jajamgekRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Jajamaru Ninpou Chou (Japan)
static struct BurnRomInfo nes_jajamninchojRomDesc[] = {
	{ "Jajamaru Ninpou Chou (Japan).nes",          262160, 0x0dcf07b3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jajamninchoj)
STD_ROM_FN(nes_jajamninchoj)

struct BurnDriver BurnDrvnes_jajamninchoj = {
	"nes_jajamninchoj", "nes_jajamnincho", NULL, NULL, "1989",
	"Jajamaru Ninpou Chou (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_jajamninchojRomInfo, nes_jajamninchojRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Jajamaru Ninpou Chou (Hack, English)
static struct BurnRomInfo nes_jajamninchoeRomDesc[] = {
	{ "Jajamaru Ninpou Chou (T-Eng).nes",          393232, 0x70fc8e57, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jajamninchoe)
STD_ROM_FN(nes_jajamninchoe)

struct BurnDriver BurnDrvnes_jajamninchoe = {
	"nes_jajamninchoe", "nes_jajamnincho", NULL, NULL, "2020",
	"Jajamaru Ninpou Chou (Hack, English)\0", NULL, "Stardust Crusaders", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_jajamninchoeRomInfo, nes_jajamninchoeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ninja JaJaMaru - The Ninja Skill Book (English)
static struct BurnRomInfo nes_jajamninchoRomDesc[] = {
	{ "Ninja JaJaMaru - The Ninja Skill Book T-Eng (1989-2023)(Jaleco).nes",          458752, 0x3fb34ddc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jajamnincho)
STD_ROM_FN(nes_jajamnincho)

struct BurnDriver BurnDrvnes_jajamnincho = {
	"nes_jajamnincho", NULL, NULL, NULL, "2023",
	"Ninja JaJaMaru - The Ninja Skill Book (English)\0", "Official Translation", "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_jajamninchoRomInfo, nes_jajamninchoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ninja Jajamaru no Daibouken (Japan)
static struct BurnRomInfo nes_jajamnodaijRomDesc[] = {
	{ "Jajamaru no Daibouken (Japan).nes",          65552, 0xd7c19e5f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jajamnodaij)
STD_ROM_FN(nes_jajamnodaij)

struct BurnDriver BurnDrvnes_jajamnodaij = {
	"nes_jajamnodaij", "nes_jajamnodai", NULL, NULL, "1986",
	"Ninja Jajamaru no Daibouken (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_jajamnodaijRomInfo, nes_jajamnodaijRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ninja JaJaMaru's Big Adventure (English)
static struct BurnRomInfo nes_jajamnodaiRomDesc[] = {
	{ "Ninja JaJaMaru's Big Adventure T-Eng (1986-2023)(Jaleco).nes",          65552, 0x0c78c264, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jajamnodai)
STD_ROM_FN(nes_jajamnodai)

struct BurnDriver BurnDrvnes_jajamnodai = {
	"nes_jajamnodai", NULL, NULL, NULL, "2023",
	"Ninja JaJaMaru's Big Adventure (English)\0", "Official Translation", "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_jajamnodaiRomInfo, nes_jajamnodaiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// James Bond Jr (USA)
static struct BurnRomInfo nes_jamesbondjrRomDesc[] = {
	{ "James Bond Jr (USA).nes",          262160, 0xdc1a82cb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jamesbondjr)
STD_ROM_FN(nes_jamesbondjr)

struct BurnDriver BurnDrvnes_jamesbondjr = {
	"nes_jamesbondjr", NULL, NULL, NULL, "1992",
	"James Bond Jr (USA)\0", NULL, "THQ", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_jamesbondjrRomInfo, nes_jamesbondjrRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Jaws (USA)
static struct BurnRomInfo nes_jawsRomDesc[] = {
	{ "Jaws (USA).nes",          65552, 0xfece3f05, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jaws)
STD_ROM_FN(nes_jaws)

struct BurnDriver BurnDrvnes_jaws = {
	"nes_jaws", NULL, NULL, NULL, "1987",
	"Jaws (USA)\0", NULL, "Ljn", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_jawsRomInfo, nes_jawsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Jesus - Kyoufu no Bio Monster (Japan)
static struct BurnRomInfo nes_jesusjRomDesc[] = {
	{ "Jesus - Kyoufu no Bio Monster (Japan).nes",          262160, 0x5c2c76a4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jesusj)
STD_ROM_FN(nes_jesusj)

struct BurnDriver BurnDrvnes_jesusj = {
	"nes_jesusj", "nes_jesus", NULL, NULL, "1989",
	"Jesus - Kyoufu no Bio Monster (Japan)\0", NULL, "King Records", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_jesusjRomInfo, nes_jesusjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Jesus - Kyoufu no Bio Monster (Hack, English)
static struct BurnRomInfo nes_jesusRomDesc[] = {
	{ "Jesus - Kyoufu no Bio Monster (T-eng).nes",          262160, 0x308c72f5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jesus)
STD_ROM_FN(nes_jesus)

struct BurnDriver BurnDrvnes_jesus = {
	"nes_jesus", NULL, NULL, NULL, "2016",
	"Jesus - Kyoufu no Bio Monster (Hack, English)\0", NULL, "Stardust Crusaders", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_jesusRomInfo, nes_jesusRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Jetsons, The - Cogswell's Caper! (Japan)
static struct BurnRomInfo nes_jetsonsjRomDesc[] = {
	{ "Jetsons, The - Cogswell's Caper! (Japan).nes",          393232, 0x4733c232, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jetsonsj)
STD_ROM_FN(nes_jetsonsj)

struct BurnDriver BurnDrvnes_jetsonsj = {
	"nes_jetsonsj", "nes_jetsons", NULL, NULL, "1993",
	"Jetsons, The - Cogswell's Caper! (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_jetsonsjRomInfo, nes_jetsonsjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Jetsons, The - Cogswell's Caper! (USA)
static struct BurnRomInfo nes_jetsonsRomDesc[] = {
	{ "Jetsons, The - Cogswell's Caper! (USA).nes",          393232, 0x0f945df6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jetsons)
STD_ROM_FN(nes_jetsons)

struct BurnDriver BurnDrvnes_jetsons = {
	"nes_jetsons", NULL, NULL, NULL, "1992",
	"Jetsons, The - Cogswell's Caper! (USA)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_jetsonsRomInfo, nes_jetsonsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Jigoku Gokuraku Maru (Japan)
static struct BurnRomInfo nes_jigokgokmarRomDesc[] = {
	{ "Jigoku Gokuraku Maru (Japan).nes",          262160, 0xd9564797, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jigokgokmar)
STD_ROM_FN(nes_jigokgokmar)

struct BurnDriver BurnDrvnes_jigokgokmar = {
	"nes_jigokgokmar", "nes_kabuki", NULL, NULL, "1990",
	"Jigoku Gokuraku Maru (Japan)\0", NULL, "Pack-In-Video", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_jigokgokmarRomInfo, nes_jigokgokmarRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Jikuu Yuuden - Debias (Japan)
static struct BurnRomInfo nes_jikuuyuuRomDesc[] = {
	{ "Jikuu Yuuden - Debias (Japan).nes",          196624, 0x0f40cdc2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jikuuyuu)
STD_ROM_FN(nes_jikuuyuu)

struct BurnDriver BurnDrvnes_jikuuyuu = {
	"nes_jikuuyuu", NULL, NULL, NULL, "1987",
	"Jikuu Yuuden - Debias (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_jikuuyuuRomInfo, nes_jikuuyuuRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Jimmy Connors Tennis (USA)
static struct BurnRomInfo nes_jimmycontenRomDesc[] = {
	{ "Jimmy Connors Tennis (USA).nes",          131088, 0xc31e3754, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jimmyconten)
STD_ROM_FN(nes_jimmyconten)

struct BurnDriver BurnDrvnes_jimmyconten = {
	"nes_jimmyconten", NULL, NULL, NULL, "1993",
	"Jimmy Connors Tennis (USA)\0", NULL, "UBI Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_jimmycontenRomInfo, nes_jimmycontenRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// JJ (Japan)
static struct BurnRomInfo nes_jjRomDesc[] = {
	{ "JJ (Japan).nes",          131088, 0x8093ec6f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jj)
STD_ROM_FN(nes_jj)

struct BurnDriver BurnDrvnes_jj = {
	"nes_jj", NULL, NULL, NULL, "1987",
	"JJ (Japan)\0", NULL, "Square", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_jjRomInfo, nes_jjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Joe & Mac (USA)
static struct BurnRomInfo nes_joemacRomDesc[] = {
	{ "Joe & Mac (USA).nes",          262160, 0x0c4000be, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_joemac)
STD_ROM_FN(nes_joemac)

struct BurnDriver BurnDrvnes_joemac = {
	"nes_joemac", NULL, NULL, NULL, "1992",
	"Joe & Mac (USA)\0", NULL, "Data East", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_joemacRomInfo, nes_joemacRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// John Elway's Quarterback (USA)
static struct BurnRomInfo nes_johnelwsquaRomDesc[] = {
	{ "John Elway's Quarterback (USA).nes",          65552, 0x801931af, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_johnelwsqua)
STD_ROM_FN(nes_johnelwsqua)

struct BurnDriver BurnDrvnes_johnelwsqua = {
	"nes_johnelwsqua", NULL, NULL, NULL, "1989",
	"John Elway's Quarterback (USA)\0", NULL, "Tradewest", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_johnelwsquaRomInfo, nes_johnelwsquaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Jongbou (Japan)
static struct BurnRomInfo nes_jongbouRomDesc[] = {
	{ "Jongbou (Japan).nes",          131088, 0x966bdb94, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jongbou)
STD_ROM_FN(nes_jongbou)

struct BurnDriver BurnDrvnes_jongbou = {
	"nes_jongbou", NULL, NULL, NULL, "1987",
	"Jongbou (Japan)\0", NULL, "KAC", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_MAHJONG | GBF_BREAKOUT, 0,
	NESGetZipName, nes_jongbouRomInfo, nes_jongbouRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Jordan vs Bird - One On One (USA)
static struct BurnRomInfo nes_jordavsbirRomDesc[] = {
	{ "Jordan vs Bird - One On One (USA).nes",          131088, 0x03349045, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jordavsbir)
STD_ROM_FN(nes_jordavsbir)

struct BurnDriver BurnDrvnes_jordavsbir = {
	"nes_jordavsbir", NULL, NULL, NULL, "1989",
	"Jordan vs Bird - One On One (USA)\0", NULL, "Milton Bradley", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_jordavsbirRomInfo, nes_jordavsbirRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Joshua & the Battle of Jericho (USA)
static struct BurnRomInfo nes_joshubatjerRomDesc[] = {
	{ "Joshua & the Battle of Jericho (USA).nes",          262160, 0x8d608ab1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_joshubatjer)
STD_ROM_FN(nes_joshubatjer)

struct BurnDriver BurnDrvnes_joshubatjer = {
	"nes_joshubatjer", NULL, NULL, NULL, "1992",
	"Joshua & the Battle of Jericho (USA)\0", NULL, "Wisdom Tree", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_joshubatjerRomInfo, nes_joshubatjerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Journey to Silius (USA)
static struct BurnRomInfo nes_journsilRomDesc[] = {
	{ "Journey to Silius (USA).nes",          262160, 0x8f77cce0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_journsil)
STD_ROM_FN(nes_journsil)

struct BurnDriver BurnDrvnes_journsil = {
	"nes_journsil", NULL, NULL, NULL, "1990",
	"Journey to Silius (USA)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_journsilRomInfo, nes_journsilRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Raf World (Japan)
static struct BurnRomInfo nes_rafworldRomDesc[] = {
	{ "Raf World (Japan).nes",          262160, 0xf34cb7fc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rafworld)
STD_ROM_FN(nes_rafworld)

struct BurnDriver BurnDrvnes_rafworld = {
	"nes_rafworld", "nes_journsil", NULL, NULL, "1990",
	"Raf World (Japan)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_rafworldRomInfo, nes_rafworldRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Joust (USA)
static struct BurnRomInfo nes_joustRomDesc[] = {
	{ "Joust (USA)(1988)(HAL Laboratory).nes",          32784, 0xcdd248a0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_joust)
STD_ROM_FN(nes_joust)

struct BurnDriver BurnDrvnes_joust = {
	"nes_joust", NULL, NULL, NULL, "1988",
	"Joust (USA)\0", NULL, "HAL Laboratory", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_joustRomInfo, nes_joustRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Jovial Race (Unl)
static struct BurnRomInfo nes_jovialraceRomDesc[] = {
	{ "Jovial Race (Unl)(1989)(Thin Chen).nes",          98320, 0x52c262b4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jovialrace)
STD_ROM_FN(nes_jovialrace)

struct BurnDriver BurnDrvnes_jovialrace = {
	"nes_jovialrace", NULL, NULL, NULL, "1989",
	"Jovial Race (Unl)\0", NULL, "Thin Chen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_MAZE | GBF_ACTION, 0,
	NESGetZipName, nes_jovialraceRomInfo, nes_jovialraceRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Joy Mech Fight (Japan)
static struct BurnRomInfo nes_joymechfightjRomDesc[] = {
	{ "Joy Mech Fight (Japan)(1993)(Nintendo).nes",          524304, 0xd6c81006, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_joymechfightj)
STD_ROM_FN(nes_joymechfightj)

struct BurnDriver BurnDrvnes_joymechfightj = {
	"nes_joymechfightj", "nes_joymechfight", NULL, NULL, "1993",
	"Joy Mech Fight (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_joymechfightjRomInfo, nes_joymechfightjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Joy Mech Fight (Hack, English)
// https://www.romhacking.net/translations/161/
static struct BurnRomInfo nes_joymechfightRomDesc[] = {
	{ "Joy Mech Fight T-Eng (2016)(AlanMidas).nes",          524304, 0x8bb8bc54, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_joymechfight)
STD_ROM_FN(nes_joymechfight)

struct BurnDriver BurnDrvnes_joymechfight = {
	"nes_joymechfight", NULL, NULL, NULL, "2016",
	"Joy Mech Fight (Hack, English)\0", NULL, "AlanMidas", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_joymechfightRomInfo, nes_joymechfightRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// JuJu Densetsu (Japan)
static struct BurnRomInfo nes_jujudensetsuRomDesc[] = {
	{ "JuJu Densetsu (Japan)(1991)(Taito).nes",          393232, 0x138d2e4b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jujudensetsu)
STD_ROM_FN(nes_jujudensetsu)

struct BurnDriver BurnDrvnes_jujudensetsu = {
	"nes_jujudensetsu", "nes_toki", NULL, NULL, "1991",
	"JuJu Densetsu (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_jujudensetsuRomInfo, nes_jujudensetsuRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Jumbo Ozaki no Hole in One Professional (Japan)
static struct BurnRomInfo nes_jumboozanoholinonepRomDesc[] = {
	{ "Jumbo Ozaki no Hole in One Professional (Japan).nes",          163856, 0x00f48ae5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jumboozanoholinonep)
STD_ROM_FN(nes_jumboozanoholinonep)

struct BurnDriver BurnDrvnes_jumboozanoholinonep = {
	"nes_jumboozanoholinonep", NULL, NULL, NULL, "1988",
	"Jumbo Ozaki no Hole in One Professional (Japan)\0", NULL, "HAL Laboratory", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_jumboozanoholinonepRomInfo, nes_jumboozanoholinonepRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Jumpin' Kid - Jack to Mame no Ki Monogatari (Japan)
static struct BurnRomInfo nes_jumpikidRomDesc[] = {
	{ "Jumpin' Kid - Jack to Mame no Ki Monogatari (Japan).nes",          262160, 0x93e52908, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jumpikid)
STD_ROM_FN(nes_jumpikid)

struct BurnDriver BurnDrvnes_jumpikid = {
	"nes_jumpikid", NULL, NULL, NULL, "1990",
	"Jumpin' Kid - Jack to Mame no Ki Monogatari (Japan)\0", NULL, "Asmik", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_jumpikidRomInfo, nes_jumpikidRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Jungle Book, The (USA)
static struct BurnRomInfo nes_junglebooktheRomDesc[] = {
	{ "Jungle Book, The (USA).nes",          262160, 0x4b849368, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_junglebookthe)
STD_ROM_FN(nes_junglebookthe)

struct BurnDriver BurnDrvnes_junglebookthe = {
	"nes_junglebookthe", NULL, NULL, NULL, "1994",
	"Jungle Book, The (USA)\0", NULL, "Virgin Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_junglebooktheRomInfo, nes_junglebooktheRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Jurassic Boy (Asia) (Unl)
static struct BurnRomInfo nes_jurassicboyRomDesc[] = {
	{ "Jurassic Boy (Asia) (Unl).nes",          393232, 0xdbce3424, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jurassicboy)
STD_ROM_FN(nes_jurassicboy)

struct BurnDriver BurnDrvnes_jurassicboy = {
	"nes_jurassicboy", NULL, NULL, NULL, "1990",
	"Jurassic Boy (Asia) (Unl)\0", NULL, "Sachen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_jurassicboyRomInfo, nes_jurassicboyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Jurassic Park (USA)
static struct BurnRomInfo nes_jurassicparkRomDesc[] = {
	{ "Jurassic Park (USA)(1993)(Ocean).nes",          262160, 0x11ec53a9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_jurassicpark)
STD_ROM_FN(nes_jurassicpark)

struct BurnDriver BurnDrvnes_jurassicpark = {
	"nes_jurassicpark", NULL, NULL, NULL, "1993",
	"Jurassic Park (USA)\0", NULL, "Ocean", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RUNGUN | GBF_ADV, 0,
	NESGetZipName, nes_jurassicparkRomInfo, nes_jurassicparkRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Just Breed (Japan)
static struct BurnRomInfo nes_justbreedjRomDesc[] = {
	{ "Just Breed (Japan)(1992)(Enix).nes",          786448, 0x4b69c694, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_justbreedj)
STD_ROM_FN(nes_justbreedj)

struct BurnDriver BurnDrvnes_justbreedj = {
	"nes_justbreedj", "nes_justbreed", NULL, NULL, "1992",
	"Just Breed (Japan)\0", NULL, "Enix", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG | GBF_STRATEGY, 0,
	NESGetZipName, nes_justbreedjRomInfo, nes_justbreedjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Just Breed (Hack, English)
// https://www.romhacking.net/translations/566/
static struct BurnRomInfo nes_justbreedRomDesc[] = {
	{ "Just Breed T-Eng (2004)(Stealth Translations).nes",          786448, 0xa4863269, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_justbreed)
STD_ROM_FN(nes_justbreed)

struct BurnDriver BurnDrvnes_justbreed = {
	"nes_justbreed", NULL, NULL, NULL, "2004",
	"Just Breed (Hack, English)\0", NULL, "Stealth Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG | GBF_STRATEGY, 0,
	NESGetZipName, nes_justbreedRomInfo, nes_justbreedRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Juuouki (Japan)
static struct BurnRomInfo nes_juuoukijRomDesc[] = {
	{ "Juuouki (Japan)(1990)(Asmik).nes",          262160, 0x4de1c214, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_juuoukij)
STD_ROM_FN(nes_juuoukij)

struct BurnDriver BurnDrvnes_juuoukij = {
	"nes_juuoukij", "nes_juuouki", NULL, NULL, "1990",
	"Juuouki (Japan)\0", NULL, "Asmik", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_juuoukijRomInfo, nes_juuoukijRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Juuouki ~ Altered Beast (Hack, English)
// https://www.romhacking.net/translations/886/
static struct BurnRomInfo nes_juuoukiRomDesc[] = {
	{ "Juuouki T-Eng (2005)(aka translations).nes",          262160, 0xb6cf6cbc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_juuouki)
STD_ROM_FN(nes_juuouki)

struct BurnDriver BurnDrvnes_juuouki = {
	"nes_juuouki", NULL, NULL, NULL, "2005",
	"Juuouki ~ Altered Beast (Hack, English)\0", NULL, "aka translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_juuoukiRomInfo, nes_juuoukiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Juuryoku Soukou Metal Storm (Japan)
static struct BurnRomInfo nes_juurysoumetstoRomDesc[] = {
	{ "Juuryoku Soukou Metal Storm (Japan)(1992)(Irem).nes",          393232, 0x984ef54b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_juurysoumetsto)
STD_ROM_FN(nes_juurysoumetsto)

struct BurnDriver BurnDrvnes_juurysoumetsto = {
	"nes_juurysoumetsto", NULL, NULL, NULL, "1992",
	"Juuryoku Soukou Metal Storm (Japan)\0", NULL, "Irem Corp.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_juurysoumetstoRomInfo, nes_juurysoumetstoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Juvei Quest (Japan)
static struct BurnRomInfo nes_juveiquestjRomDesc[] = {
	{ "Juvei Quest (Japan)(1991)(Namco).nes",          524304, 0x2e937d80, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_juveiquestj)
STD_ROM_FN(nes_juveiquestj)

struct BurnDriver BurnDrvnes_juveiquestj = {
	"nes_juveiquestj", "nes_juveiquest", NULL, NULL, "1991",
	"Juvei Quest (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_juveiquestjRomInfo, nes_juveiquestjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Juvei Quest (Hack, English)
// https://www.romhacking.net/translations/1826/
static struct BurnRomInfo nes_juveiquestRomDesc[] = {
	{ "Juvei Quest T-Eng (2013)(Stardust Crusaders).nes",          786448, 0x00a5b4f2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_juveiquest)
STD_ROM_FN(nes_juveiquest)

struct BurnDriver BurnDrvnes_juveiquest = {
	"nes_juveiquest", NULL, NULL, NULL, "2013",
	"Juvei Quest (Hack, English)\0", NULL, "Stardust Crusaders", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_juveiquestRomInfo, nes_juveiquestRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kabuki - Quantum Fighter (USA)
static struct BurnRomInfo nes_kabukiRomDesc[] = {
	{ "Kabuki - Quantum Fighter (USA)(1991)(HAL Laboratory).nes",          262160, 0x5ee7a400, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kabuki)
STD_ROM_FN(nes_kabuki)

struct BurnDriver BurnDrvnes_kabuki = {
	"nes_kabuki", NULL, NULL, NULL, "1991",
	"Kabuki - Quantum Fighter (USA)\0", NULL, "HAL Laboratory", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_kabukiRomInfo, nes_kabukiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kage (Japan)
static struct BurnRomInfo nes_kageRomDesc[] = {
	{ "Kage (Japan).nes",          262160, 0x459fbede, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kage)
STD_ROM_FN(nes_kage)

struct BurnDriver BurnDrvnes_kage = {
	"nes_kage", "nes_shadonin", NULL, NULL, "1990",
	"Kage (Japan)\0", NULL, "Natsume", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, nes_kageRomInfo, nes_kageRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kage no Densetsu (Japan)
static struct BurnRomInfo nes_kagenodensetsuRomDesc[] = {
	{ "Kage no Densetsu (Japan).nes",          49168, 0x6e55f630, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kagenodensetsu)
STD_ROM_FN(nes_kagenodensetsu)

struct BurnDriver BurnDrvnes_kagenodensetsu = {
	"nes_kagenodensetsu", "nes_legenkag", NULL, NULL, "1986",
	"Kage no Densetsu (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_kagenodensetsuRomInfo, nes_kagenodensetsuRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kagerou Densetsu (Japan)
static struct BurnRomInfo nes_kageroudensetsuRomDesc[] = {
	{ "Kagerou Densetsu (Japan).nes",          262160, 0x205631f7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kageroudensetsu)
STD_ROM_FN(nes_kageroudensetsu)

struct BurnDriver BurnDrvnes_kageroudensetsu = {
	"nes_kageroudensetsu", NULL, NULL, NULL, "1990",
	"Kagerou Densetsu (Japan)\0", NULL, "Pixel", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ADV | GBF_RUNGUN, 0,
	NESGetZipName, nes_kageroudensetsuRomInfo, nes_kageroudensetsuRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kaguya Hime Densetsu (Japan)
static struct BurnRomInfo nes_kaguyajRomDesc[] = {
	{ "Kaguya Hime Densetsu (J)(1988)(Victor).nes",          262160, 0x69565d0e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kaguyaj)
STD_ROM_FN(nes_kaguyaj)

struct BurnDriver BurnDrvnes_kaguyaj = {
	"nes_kaguyaj", "nes_kaguyae", NULL, NULL, "1988",
	"Kaguya Hime Densetsu (Japan)\0", NULL, "Victor", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_kaguyajRomInfo, nes_kaguyajRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kaguya Hime Densetsu (Hack, English)
// https://www.romhacking.net/translations/6614/
static struct BurnRomInfo nes_kaguyaeRomDesc[] = {
	{ "Kaguya Hime Densetsu (T-Eng)(2022)(FCandChill).nes",          524304, 0x80de5290, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kaguyae)
STD_ROM_FN(nes_kaguyae)

struct BurnDriver BurnDrvnes_kaguyae = {
	"nes_kaguyae", NULL, NULL, NULL, "2022",
	"Kaguya Hime Densetsu (Hack, English)\0", NULL, "FCandChill", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_kaguyaeRomInfo, nes_kaguyaeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kaiketsu Yancha Maru (Japan)
static struct BurnRomInfo nes_kaikeyanmarRomDesc[] = {
	{ "Kaiketsu Yancha Maru (Japan).nes",          262160, 0x6394bcd8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kaikeyanmar)
STD_ROM_FN(nes_kaikeyanmar)

struct BurnDriver BurnDrvnes_kaikeyanmar = {
	"nes_kaikeyanmar", "nes_kidnik", NULL, NULL, "1987",
	"Kaiketsu Yancha Maru (Japan)\0", NULL, "Irem", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_kaikeyanmarRomInfo, nes_kaikeyanmarRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kaiketsu Yancha Maru 2 - Karakuri Land (Japan)
static struct BurnRomInfo nes_kaikeyanmar2jRomDesc[] = {
	{ "Kaiketsu Yancha Maru 2 - Karakuri Land (Japan).nes",          262160, 0x459c9e31, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kaikeyanmar2j)
STD_ROM_FN(nes_kaikeyanmar2j)

struct BurnDriver BurnDrvnes_kaikeyanmar2j = {
	"nes_kaikeyanmar2j", "nes_kaikeyanmar2", NULL, NULL, "1991",
	"Kaiketsu Yancha Maru 2 - Karakuri Land (Japan)\0", NULL, "Irem", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_kaikeyanmar2jRomInfo, nes_kaikeyanmar2jRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kaiketsu Yancha Maru 2 - Karakuri Land (Hack, English)
static struct BurnRomInfo nes_kaikeyanmar2RomDesc[] = {
	{ "Kaiketsu Yancha Maru 2 - Karakuri Land (T-Eng).nes",          262160, 0x0f038e8f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kaikeyanmar2)
STD_ROM_FN(nes_kaikeyanmar2)

struct BurnDriver BurnDrvnes_kaikeyanmar2 = {
	"nes_kaikeyanmar2", NULL, NULL, NULL, "2020",
	"Kaiketsu Yancha Maru 2 - Karakuri Land (Hack, English)\0", NULL, "Zynk Oxhyde", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_kaikeyanmar2RomInfo, nes_kaikeyanmar2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_kaikeyanmar3RomDesc[] = {
	{ "Kaiketsu Yancha Maru 3 - Taiketsu! Zouringen (Japan).nes",          262160, 0xf86d5c4c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kaikeyanmar3)
STD_ROM_FN(nes_kaikeyanmar3)

struct BurnDriver BurnDrvnes_kaikeyanmar3 = {
	"nes_kaikeyanmar3", NULL, NULL, NULL, "1993",
	"Kaiketsu Yancha Maru 3 - Taiketsu! Zouringen (Japan)\0", NULL, "Irem", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_kaikeyanmar3RomInfo, nes_kaikeyanmar3RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_kakefkunnojumteRomDesc[] = {
	{ "Kakefu-kun no Jump Tengoku - Speed Jigoku (Japan).nes",          131088, 0xb02d7750, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kakefkunnojumte)
STD_ROM_FN(nes_kakefkunnojumte)

struct BurnDriver BurnDrvnes_kakefkunnojumte = {
	"nes_kakefkunnojumte", NULL, NULL, NULL, "1988",
	"Kakefu-kun no Jump Tengoku - Speed Jigoku (Japan)\0", NULL, "Vic Tokai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_kakefkunnojumteRomInfo, nes_kakefkunnojumteRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_kamenoongRomDesc[] = {
	{ "Kame no Ongaeshi - Urashima Densetsu (Japan).nes",          262160, 0x252e3885, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kamenoong)
STD_ROM_FN(nes_kamenoong)

struct BurnDriver BurnDrvnes_kamenoong = {
	"nes_kamenoong", NULL, NULL, NULL, "1988",
	"Kame no Ongaeshi - Urashima Densetsu (Japan)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_kamenoongRomInfo, nes_kamenoongRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_kamennoninakaRomDesc[] = {
	{ "Kamen no Ninja - Akakage (Japan).nes",          131088, 0x1bc800e1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kamennoninaka)
STD_ROM_FN(nes_kamennoninaka)

struct BurnDriver BurnDrvnes_kamennoninaka = {
	"nes_kamennoninaka", NULL, NULL, NULL, "1988",
	"Kamen no Ninja - Akakage (Japan)\0", NULL, "Toei Animation", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_kamennoninakaRomInfo, nes_kamennoninakaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_kamennoninhanRomDesc[] = {
	{ "Kamen no Ninja - Hanamaru (Japan).nes",          262160, 0x8b002a9d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kamennoninhan)
STD_ROM_FN(nes_kamennoninhan)

struct BurnDriver BurnDrvnes_kamennoninhan = {
	"nes_kamennoninhan", NULL, NULL, NULL, "1990",
	"Kamen no Ninja - Hanamaru (Japan)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_kamennoninhanRomInfo, nes_kamennoninhanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_kamenriderclubRomDesc[] = {
	{ "Kamen Rider Club (Japan).nes",          262160, 0xf95bf66d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kamenriderclub)
STD_ROM_FN(nes_kamenriderclub)

struct BurnDriver BurnDrvnes_kamenriderclub = {
	"nes_kamenriderclub", NULL, NULL, NULL, "1988",
	"Kamen Rider Club (Japan)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_kamenriderclubRomInfo, nes_kamenriderclubRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_kanshnagkannotogotsRomDesc[] = {
	{ "Kanshakudama Nage Kantarou no Toukaidou Gojuusan Tsugi (Japan).nes",          49168, 0xd2f6895a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kanshnagkannotogots)
STD_ROM_FN(nes_kanshnagkannotogots)

struct BurnDriver BurnDrvnes_kanshnagkannotogots = {
	"nes_kanshnagkannotogots", NULL, NULL, NULL, "1986",
	"Kanshakudama Nage Kantarou no Toukaidou Gojuusan Tsugi (Japan)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_kanshnagkannotogotsRomInfo, nes_kanshnagkannotogotsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_karakkendenmusloRomDesc[] = {
	{ "Karakuri Kengou Den Musashi Lord - Karakuribito Hashiru (Japan).nes",          262160, 0x834fc34f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_karakkendenmuslo)
STD_ROM_FN(nes_karakkendenmuslo)

struct BurnDriver BurnDrvnes_karakkendenmuslo = {
	"nes_karakkendenmuslo", NULL, NULL, NULL, "1991",
	"Karakuri Kengou Den Musashi Lord - Karakuribito Hashiru (Japan)\0", NULL, "Yutaka", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_karakkendenmusloRomInfo, nes_karakkendenmusloRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Karate Champ (USA) (Rev A)
static struct BurnRomInfo nes_karatechampRomDesc[] = {
	{ "Karate Champ (USA) (Rev A).nes",          65552, 0x774352a0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_karatechamp)
STD_ROM_FN(nes_karatechamp)

struct BurnDriver BurnDrvnes_karatechamp = {
	"nes_karatechamp", NULL, NULL, NULL, "1986",
	"Karate Champ (USA) (Rev A)\0", NULL, "Data East", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_karatechampRomInfo, nes_karatechampRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Karate Kid, The (USA)
static struct BurnRomInfo nes_karatekidtheRomDesc[] = {
	{ "Karate Kid, The (USA).nes",          65552, 0xd71252b9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_karatekidthe)
STD_ROM_FN(nes_karatekidthe)

struct BurnDriver BurnDrvnes_karatekidthe = {
	"nes_karatekidthe", NULL, NULL, NULL, "1987",
	"Karate Kid, The (USA)\0", NULL, "Ljn", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_karatekidtheRomInfo, nes_karatekidtheRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Karateka (Japan)
static struct BurnRomInfo nes_karatekaRomDesc[] = {
	{ "Karateka (Japan).nes",          24592, 0xe9bad787, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_karateka)
STD_ROM_FN(nes_karateka)

struct BurnDriver BurnDrvnes_karateka = {
	"nes_karateka", NULL, NULL, NULL, "1985",
	"Karateka (Japan)\0", NULL, "Soft Pro", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_karatekaRomInfo, nes_karatekaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Karnov (USA)
static struct BurnRomInfo nes_karnovRomDesc[] = {
	{ "Karnov (USA).nes",          196624, 0x103f0755, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_karnov)
STD_ROM_FN(nes_karnov)

struct BurnDriver BurnDrvnes_karnov = {
	"nes_karnov", NULL, NULL, NULL, "1988",
	"Karnov (USA)\0", NULL, "Data East", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_karnovRomInfo, nes_karnovRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kero Kero Keroppi no Daibouken (Japan)
static struct BurnRomInfo nes_kerokerkernodajRomDesc[] = {
	{ "Kero Kero Keroppi no Daibouken (Japan).nes",          65552, 0x32592407, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kerokerkernodaj)
STD_ROM_FN(nes_kerokerkernodaj)

struct BurnDriver BurnDrvnes_kerokerkernodaj = {
	"nes_kerokerkernodaj", "nes_kerokerkernoda", NULL, NULL, "1991",
	"Kero Kero Keroppi no Daibouken (Japan)\0", NULL, "Character Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_ACTION | GBF_PUZZLE, 0,
	NESGetZipName, nes_kerokerkernodajRomInfo, nes_kerokerkernodajRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kero Kero Keroppi no Daibouken (Hack, English)
static struct BurnRomInfo nes_kerokerkernodaRomDesc[] = {
	{ "Kero Kero Keroppi no Daibouken (T-eng).nes",          65552, 0x0dfbda9c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kerokerkernoda)
STD_ROM_FN(nes_kerokerkernoda)

struct BurnDriver BurnDrvnes_kerokerkernoda = {
	"nes_kerokerkernoda", NULL, NULL, NULL, "2016",
	"Kero Kero Keroppi no Daibouken (Hack, English)\0", NULL, "Gaijin Productions", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_NES, GBF_ACTION | GBF_PUZZLE, 0,
	NESGetZipName, nes_kerokerkernodaRomInfo, nes_kerokerkernodaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kero Kero Keroppi no Daibouken 2 - Donuts Ike wa Oosawagi! (Japan)
static struct BurnRomInfo nes_kerokerkernoda2jRomDesc[] = {
	{ "Kero Kero Keroppi no Daibouken 2 - Donuts Ike wa Oosawagi! (Japan).nes",          262160, 0x2c46f2a3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kerokerkernoda2j)
STD_ROM_FN(nes_kerokerkernoda2j)

struct BurnDriver BurnDrvnes_kerokerkernoda2j = {
	"nes_kerokerkernoda2j", "nes_kerokerkernoda2", NULL, NULL, "1993",
	"Kero Kero Keroppi no Daibouken 2 - Donuts Ike wa Oosawagi! (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_kerokerkernoda2jRomInfo, nes_kerokerkernoda2jRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kero Kero Keroppi no Daibouken 2 - Donuts Ike wa Oosawagi! (Hack, English)
static struct BurnRomInfo nes_kerokerkernoda2RomDesc[] = {
	{ "Kero Kero Keroppi no Daibouken 2 - Donuts Ike wa Oosawagi! (T-eng).nes",          262160, 0x8b3c7d79, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kerokerkernoda2)
STD_ROM_FN(nes_kerokerkernoda2)

struct BurnDriver BurnDrvnes_kerokerkernoda2 = {
	"nes_kerokerkernoda2", NULL, NULL, NULL, "2016",
	"Kero Kero Keroppi no Daibouken 2 - Donuts Ike wa Oosawagi! (Hack, English)\0", NULL, "The Spoony Bard", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_kerokerkernoda2RomInfo, nes_kerokerkernoda2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Keroppi to Keroriinu no Splash Bomb! (Japan)
static struct BurnRomInfo nes_keropkernosplbojRomDesc[] = {
	{ "Keroppi to Keroriinu no Splash Bomb! (Japan).nes",          163856, 0xcc6fbdae, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_keropkernosplboj)
STD_ROM_FN(nes_keropkernosplboj)

struct BurnDriver BurnDrvnes_keropkernosplboj = {
	"nes_keropkernosplboj", "nes_keropkernosplbo", NULL, NULL, "1993",
	"Keroppi to Keroriinu no Splash Bomb! (Japan)\0", NULL, "Character Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_MAZE | GBF_ACTION, 0,
	NESGetZipName, nes_keropkernosplbojRomInfo, nes_keropkernosplbojRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Keroppi to Keroriinu no Splash Bomb! (Hack, English)
static struct BurnRomInfo nes_keropkernosplboRomDesc[] = {
	{ "Keroppi to Keroriinu no Splash Bomb! T-Eng (2016)(Suicidal Translations).nes",          163856, 0xd7039620, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_keropkernosplbo)
STD_ROM_FN(nes_keropkernosplbo)

struct BurnDriver BurnDrvnes_keropkernosplbo = {
	"nes_keropkernosplbo", NULL, NULL, NULL, "2016",
	"Keroppi to Keroriinu no Splash Bomb! (Hack, English)\0", NULL, "Suicidal Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_NES, GBF_MAZE | GBF_ACTION, 0,
	NESGetZipName, nes_keropkernosplboRomInfo, nes_keropkernosplboRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kick Master (USA)
static struct BurnRomInfo nes_kickmasterRomDesc[] = {
	{ "Kick Master (USA).nes",          262160, 0x7b978bac, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kickmaster)
STD_ROM_FN(nes_kickmaster)

struct BurnDriver BurnDrvnes_kickmaster = {
	"nes_kickmaster", NULL, NULL, NULL, "1992",
	"Kick Master (USA)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_kickmasterRomInfo, nes_kickmasterRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kick Off (Euro)
static struct BurnRomInfo nes_kickoffRomDesc[] = {
	{ "Kick Off (Europe).nes",          131088, 0xe2685bbf, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kickoff)
STD_ROM_FN(nes_kickoff)

struct BurnDriver BurnDrvnes_kickoff = {
	"nes_kickoff", NULL, NULL, NULL, "1992",
	"Kick Off (Euro)\0", NULL, "Imagineer", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSFOOTBALL, 0,
	NESGetZipName, nes_kickoffRomInfo, nes_kickoffRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL, SCREEN_WIDTH, SCREEN_HEIGHT_PAL
};

// Kickle Cubicle (USA)
static struct BurnRomInfo nes_kicklecubicleRomDesc[] = {
	{ "Kickle Cubicle (USA).nes",          262160, 0xe783d470, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kicklecubicle)
STD_ROM_FN(nes_kicklecubicle)

struct BurnDriver BurnDrvnes_kicklecubicle = {
	"nes_kicklecubicle", NULL, NULL, NULL, "1990",
	"Kickle Cubicle (USA)\0", NULL, "Irem", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PUZZLE | GBF_ACTION, 0,
	NESGetZipName, nes_kicklecubicleRomInfo, nes_kicklecubicleRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kid Dracula (Hack, English)
static struct BurnRomInfo nes_kiddraculaRomDesc[] = {
	{ "Kid Dracula (English).nes",          393232, 0xe9c3dc89, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kiddracula)
STD_ROM_FN(nes_kiddracula)

struct BurnDriver BurnDrvnes_kiddracula = {
	"nes_kiddracula", NULL, NULL, NULL, "2019",
	"Kid Dracula (Hack, English)\0", NULL, "chronix", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_kiddraculaRomInfo, nes_kiddraculaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kid Icarus (USA, Europe)
static struct BurnRomInfo nes_kidicarusRomDesc[] = {
	{ "Kid Icarus (USA, Europe).nes",          131088, 0x0b30e036, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kidicarus)
STD_ROM_FN(nes_kidicarus)

struct BurnDriver BurnDrvnes_kidicarus = {
	"nes_kidicarus", NULL, NULL, NULL, "1987",
	"Kid Icarus (USA, Europe)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_kidicarusRomInfo, nes_kidicarusRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_kidkloinnigmawoRomDesc[] = {
	{ "Kid Klown in Night Mayor World (USA).nes",          262160, 0xa474ccac, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kidkloinnigmawo)
STD_ROM_FN(nes_kidkloinnigmawo)

struct BurnDriver BurnDrvnes_kidkloinnigmawo = {
	"nes_kidkloinnigmawo", NULL, NULL, NULL, "1993",
	"Kid Klown in Night Mayor World (USA)\0", NULL, "Kemco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_kidkloinnigmawoRomInfo, nes_kidkloinnigmawoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_kidkooandquesewoheRomDesc[] = {
	{ "Kid Kool and the Quest for the Seven Wonder Herbs (USA).nes",          131088, 0x99626ab1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kidkooandquesewohe)
STD_ROM_FN(nes_kidkooandquesewohe)

struct BurnDriver BurnDrvnes_kidkooandquesewohe = {
	"nes_kidkooandquesewohe", NULL, NULL, NULL, "1990",
	"Kid Kool and the Quest for the Seven Wonder Herbs (USA)\0", NULL, "Vic Tokai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_kidkooandquesewoheRomInfo, nes_kidkooandquesewoheRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_kidnikRomDesc[] = {
	{ "Kid Niki - Radical Ninja (USA) (Rev A).nes",          262160, 0x0f33d193, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kidnik)
STD_ROM_FN(nes_kidnik)

struct BurnDriver BurnDrvnes_kidnik = {
	"nes_kidnik", NULL, NULL, NULL, "1987",
	"Kid Niki - Radical Ninja (USA) (Rev A)\0", NULL, "Data East", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_kidnikRomInfo, nes_kidnikRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_kiddysuninfanRomDesc[] = {
	{ "Kiddy Sun in Fantasia (Taiwan).nes",          65552, 0x2d1b3ae7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kiddysuninfan)
STD_ROM_FN(nes_kiddysuninfan)

struct BurnDriver BurnDrvnes_kiddysuninfan = {
	"nes_kiddysuninfan", NULL, NULL, NULL, "1987",
	"Kiddy Sun in Fantasia (Taiwan)\0", NULL, "Eratech", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_kiddysuninfanRomInfo, nes_kiddysuninfanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_kidousenzgunjRomDesc[] = {
	{ "Kidou Senshi Z Gundam - Hot Scramble (Japan) (Final Version).nes",          40976, 0x47850afc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kidousenzgunj)
STD_ROM_FN(nes_kidousenzgunj)

struct BurnDriver BurnDrvnes_kidousenzgunj = {
	"nes_kidousenzgunj", "nes_kidousenzgun", NULL, NULL, "1986",
	"Kidou Senshi Z Gundam - Hot Scramble (Japan) (Final Version)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_kidousenzgunjRomInfo, nes_kidousenzgunjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_kidousenzgunRomDesc[] = {
	{ "Kidou Senshi Z Gundam - Hot Scramble (Japan).nes",          163856, 0x1d8c24ad, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kidousenzgun)
STD_ROM_FN(nes_kidousenzgun)

struct BurnDriver BurnDrvnes_kidousenzgun = {
	"nes_kidousenzgun", NULL, NULL, NULL, "1986",
	"Kidou Senshi Z Gundam - Hot Scramble (Japan)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_kidousenzgunRomInfo, nes_kidousenzgunRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// King Kong 2 - Ikari no Megaton Punch (Japan)
static struct BurnRomInfo nes_kingkon2jRomDesc[] = {
	{ "King Kong 2 - Ikari no Megaton Punch (Japan).nes",          262160, 0xaf534918, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kingkon2j)
STD_ROM_FN(nes_kingkon2j)

struct BurnDriver BurnDrvnes_kingkon2j = {
	"nes_kingkon2j", "nes_kingkon2", NULL, NULL, "1986",
	"King Kong 2 - Ikari no Megaton Punch (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_kingkon2jRomInfo, nes_kingkon2jRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// King Kong 2 - Ikari no Megaton Punch (Hack, English)
static struct BurnRomInfo nes_kingkon2RomDesc[] = {
	{ "King Kong 2 - Ikari no Megaton Punch (T-eng).nes",          262160, 0x9db6489a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kingkon2)
STD_ROM_FN(nes_kingkon2)

struct BurnDriver BurnDrvnes_kingkon2 = {
	"nes_kingkon2", NULL, NULL, NULL, "2016",
	"King Kong 2 - Ikari no Megaton Punch (Hack, English)\0", NULL, "DvD Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_kingkon2RomInfo, nes_kingkon2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// King of Kings (Japan)
static struct BurnRomInfo nes_kingofkingsRomDesc[] = {
	{ "King of Kings (Japan).nes",          262160, 0xf3c8e91e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kingofkings)
STD_ROM_FN(nes_kingofkings)

struct BurnDriver BurnDrvnes_kingofkings = {
	"nes_kingofkings", NULL, NULL, NULL, "1988",
	"King of Kings (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_kingofkingsRomInfo, nes_kingofkingsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// King of Kings, The (USA) (v5.0) (Unl)
static struct BurnRomInfo nes_kingkinRomDesc[] = {
	{ "King of Kings, The (USA) (v5.0) (Unl).nes",          262160, 0x6ac36bd7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kingkin)
STD_ROM_FN(nes_kingkin)

struct BurnDriver BurnDrvnes_kingkin = {
	"nes_kingkin", NULL, NULL, NULL, "1991",
	"King of Kings, The (USA) (v5.0) (Unl)\0", NULL, "Wisdom Tree", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_kingkinRomInfo, nes_kingkinRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// King's Knight (USA)
static struct BurnRomInfo nes_kingsknightRomDesc[] = {
	{ "King's Knight (USA).nes",          65552, 0xd8abbfd8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kingsknight)
STD_ROM_FN(nes_kingsknight)

struct BurnDriver BurnDrvnes_kingsknight = {
	"nes_kingsknight", NULL, NULL, NULL, "1986",
	"King's Knight (USA)\0", NULL, "Square", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_kingsknightRomInfo, nes_kingsknightRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// King's Quest V (USA)
static struct BurnRomInfo nes_kingsquestvRomDesc[] = {
	{ "King's Quest V (USA).nes",          524304, 0xa6c5cbd8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kingsquestv)
STD_ROM_FN(nes_kingsquestv)

struct BurnDriver BurnDrvnes_kingsquestv = {
	"nes_kingsquestv", NULL, NULL, NULL, "1992",
	"King's Quest V (USA)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_kingsquestvRomInfo, nes_kingsquestvRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kings of the Beach (USA)
static struct BurnRomInfo nes_kingsbeaRomDesc[] = {
	{ "Kings of the Beach (USA).nes",          65552, 0xba602ea1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kingsbea)
STD_ROM_FN(nes_kingsbea)

struct BurnDriver BurnDrvnes_kingsbea = {
	"nes_kingsbea", NULL, NULL, NULL, "1990",
	"Kings of the Beach (USA)\0", NULL, "Ultra Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_kingsbeaRomInfo, nes_kingsbeaRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kinnikuman - Muscle Tag Match (Japan)
static struct BurnRomInfo nes_kinniRomDesc[] = {
	{ "Kinnikuman - Muscle Tag Match (Japan).nes",          24592, 0xc261904e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kinni)
STD_ROM_FN(nes_kinni)

struct BurnDriver BurnDrvnes_kinni = {
	"nes_kinni", "nes_muscle", NULL, NULL, "1985",
	"Kinnikuman - Muscle Tag Match (Japan)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_kinniRomInfo, nes_kinniRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kirby's Adventure (USA) (Rev A)
static struct BurnRomInfo nes_kirbysadvRomDesc[] = {
	{ "Kirby's Adventure (USA) (Rev A).nes",          786448, 0x9efd5757, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kirbysadv)
STD_ROM_FN(nes_kirbysadv)

struct BurnDriver BurnDrvnes_kirbysadv = {
	"nes_kirbysadv", NULL, NULL, NULL, "1993",
	"Kirby's Adventure (USA) (Rev A)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_kirbysadvRomInfo, nes_kirbysadvRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kirby's Halloween Adventure (Hack, v1.4)
static struct BurnRomInfo nes_kirbyshlwRomDesc[] = {
	{ "Kirby's Halloween Adventure (2021)(Kirb-Star).nes",          786448, 0x9332bf75, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kirbyshlw)
STD_ROM_FN(nes_kirbyshlw)

struct BurnDriver BurnDrvnes_kirbyshlw = {
	"nes_kirbyshlw", "nes_kirbysadv", NULL, NULL, "2021",
	"Kirby's Halloween Adventure (Hack, v1.4)\0", NULL, "Kirb-Star", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_kirbyshlwRomInfo, nes_kirbyshlwRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kiteretsu Daihyakka (Japan)
static struct BurnRomInfo nes_kiterdaiRomDesc[] = {
	{ "Kiteretsu Daihyakka (Japan)(1990)(Epoch Co.).nes",          262160, 0xb6f4b759, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kiterdai)
STD_ROM_FN(nes_kiterdai)

struct BurnDriver BurnDrvnes_kiterdai = {
	"nes_kiterdai", NULL, NULL, NULL, "1990",
	"Kiteretsu Daihyakka (Japan)\0", NULL, "Epoch Co.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_kiterdaiRomInfo, nes_kiterdaiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kitty's Catch (USA)
static struct BurnRomInfo nes_kittyscatchRomDesc[] = {
	{ "Kitty's Catch (USA).nes",          40976, 0x60ca8d8c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kittyscatch)
STD_ROM_FN(nes_kittyscatch)

struct BurnDriver BurnDrvnes_kittyscatch = {
	"nes_kittyscatch", NULL, NULL, NULL, "1989",
	"Kitty's Catch (USA)\0", NULL, "David Wiebenson", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_kittyscatchRomInfo, nes_kittyscatchRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kiwi Kraze - A Bird-Brained Adventure! (USA)
static struct BurnRomInfo nes_kiwikraRomDesc[] = {
	{ "Kiwi Kraze - A Bird-Brained Adventure! (USA).nes",          262160, 0x2497e97f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kiwikra)
STD_ROM_FN(nes_kiwikra)

struct BurnDriver BurnDrvnes_kiwikra = {
	"nes_kiwikra", NULL, NULL, NULL, "1991",
	"Kiwi Kraze - A Bird-Brained Adventure! (USA)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_kiwikraRomInfo, nes_kiwikraRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// KlashBall (USA)
static struct BurnRomInfo nes_klashballRomDesc[] = {
	{ "KlashBall (USA).nes",          131088, 0x3728b1c6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_klashball)
STD_ROM_FN(nes_klashball)

struct BurnDriver BurnDrvnes_klashball = {
	"nes_klashball", NULL, NULL, NULL, "1991",
	"KlashBall (USA)\0", NULL, "Sofel", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_klashballRomInfo, nes_klashballRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Klax (USA) (Unl)
static struct BurnRomInfo nes_klaxRomDesc[] = {
	{ "Klax (USA) (Unl).nes",          131088, 0x755cf043, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_klax)
STD_ROM_FN(nes_klax)

struct BurnDriver BurnDrvnes_klax = {
	"nes_klax", NULL, NULL, NULL, "1990",
	"Klax (USA) (Unl)\0", NULL, "Tengen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_klaxRomInfo, nes_klaxRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Knight Rider (USA)
static struct BurnRomInfo nes_knightriderRomDesc[] = {
	{ "Knight Rider (USA).nes",          196624, 0x604fa3fc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_knightrider)
STD_ROM_FN(nes_knightrider)

struct BurnDriver BurnDrvnes_knightrider = {
	"nes_knightrider", NULL, NULL, NULL, "1989",
	"Knight Rider (USA)\0", NULL, "Acclaim", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_knightriderRomInfo, nes_knightriderRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Koko Adventure (Korea)
static struct BurnRomInfo nes_kokoadventureRomDesc[] = {
	{ "Koko Adventure (Korea).nes",          262160, 0xa86e4d73, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kokoadventure)
STD_ROM_FN(nes_kokoadventure)

struct BurnDriver BurnDrvnes_kokoadventure = {
	"nes_kokoadventure", "nes_buzzwaldog", NULL, NULL, "1993",
	"Koko Adventure (Korea)\0", NULL, "Open", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_kokoadventureRomInfo, nes_kokoadventureRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Konami Hyper Soccer (Euro)
static struct BurnRomInfo nes_konamhypsocRomDesc[] = {
	{ "Konami Hyper Soccer (Europe).nes",          131088, 0x144435af, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_konamhypsoc)
STD_ROM_FN(nes_konamhypsoc)

struct BurnDriver BurnDrvnes_konamhypsoc = {
	"nes_konamhypsoc", NULL, NULL, NULL, "1992",
	"Konami Hyper Soccer (Euro)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSFOOTBALL, 0,
	NESGetZipName, nes_konamhypsocRomInfo, nes_konamhypsocRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL, SCREEN_WIDTH, SCREEN_HEIGHT_PAL
};

// Konamic Sports in Seoul (Japan)
static struct BurnRomInfo nes_konamspoinseoRomDesc[] = {
	{ "Konamic Sports in Seoul (Japan).nes",          262160, 0xaad70549, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_konamspoinseo)
STD_ROM_FN(nes_konamspoinseo)

struct BurnDriver BurnDrvnes_konamspoinseo = {
	"nes_konamspoinseo", NULL, NULL, NULL, "1989",
	"Konamic Sports in Seoul (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_konamspoinseoRomInfo, nes_konamspoinseoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Krazy Kreatures (USA) (Unl)
static struct BurnRomInfo nes_krazykreaturesRomDesc[] = {
	{ "Krazy Kreatures (USA) (Unl).nes",          65552, 0xa17788de, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_krazykreatures)
STD_ROM_FN(nes_krazykreatures)

struct BurnDriver BurnDrvnes_krazykreatures = {
	"nes_krazykreatures", NULL, NULL, NULL, "1990",
	"Krazy Kreatures (USA) (Unl)\0", NULL, "American Video Entertainment", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_krazykreaturesRomInfo, nes_krazykreaturesRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Krion Conquest, The (USA)
static struct BurnRomInfo nes_krionconRomDesc[] = {
	{ "Krion Conquest, The (USA).nes",          262160, 0x29b42609, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_krioncon)
STD_ROM_FN(nes_krioncon)

struct BurnDriver BurnDrvnes_krioncon = {
	"nes_krioncon", NULL, NULL, NULL, "1991",
	"Krion Conquest, The (USA)\0", NULL, "Vic Tokai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_krionconRomInfo, nes_krionconRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Krusty's Fun House (USA)
static struct BurnRomInfo nes_krustsfunhouRomDesc[] = {
	{ "Krusty's Fun House (USA).nes",          393232, 0x85c86151, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_krustsfunhou)
STD_ROM_FN(nes_krustsfunhou)

struct BurnDriver BurnDrvnes_krustsfunhou = {
	"nes_krustsfunhou", NULL, NULL, NULL, "1992",
	"Krusty's Fun House (USA)\0", NULL, "Acclaim", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PUZZLE | GBF_PLATFORM, 0,
	NESGetZipName, nes_krustsfunhouRomInfo, nes_krustsfunhouRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kung Fu (Japan, USA)
static struct BurnRomInfo nes_kungfuRomDesc[] = {
	{ "Kung Fu (Japan, USA).nes",          40976, 0x32b45889, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kungfu)
STD_ROM_FN(nes_kungfu)

struct BurnDriver BurnDrvnes_kungfu = {
	"nes_kungfu", NULL, NULL, NULL, "1985",
	"Kung Fu (Japan, USA)\0", NULL, "Nintendo - Irem Corp.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_kungfuRomInfo, nes_kungfuRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kung-Fu Heroes (USA)
static struct BurnRomInfo nes_kungfuheroesRomDesc[] = {
	{ "Kung-Fu Heroes (USA).nes",          65552, 0x736bd189, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kungfuheroes)
STD_ROM_FN(nes_kungfuheroes)

struct BurnDriver BurnDrvnes_kungfuheroes = {
	"nes_kungfuheroes", NULL, NULL, NULL, "1989",
	"Kung-Fu Heroes (USA)\0", NULL, "Culture Brain", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_kungfuheroesRomInfo, nes_kungfuheroesRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kunio-kun no Nekketsu Soccer League (Japan)
static struct BurnRomInfo nes_kuniokunnoneksoleRomDesc[] = {
	{ "Kunio-kun no Nekketsu Soccer League (Japan).nes",          262160, 0x9659bca6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kuniokunnoneksole)
STD_ROM_FN(nes_kuniokunnoneksole)

struct BurnDriver BurnDrvnes_kuniokunnoneksole = {
	"nes_kuniokunnoneksole", NULL, NULL, NULL, "1993",
	"Kunio-kun no Nekketsu Soccer League (Japan)\0", NULL, "Technos", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSFOOTBALL, 0,
	NESGetZipName, nes_kuniokunnoneksoleRomInfo, nes_kuniokunnoneksoleRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NESHori4pInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kyouryuu Sentai Juuranger (Japan)
static struct BurnRomInfo nes_kyoursenjuujRomDesc[] = {
	{ "Kyouryuu Sentai Juuranger (Japan).nes",          262160, 0x7bf82c80, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kyoursenjuuj)
STD_ROM_FN(nes_kyoursenjuuj)

struct BurnDriver BurnDrvnes_kyoursenjuuj = {
	"nes_kyoursenjuuj", "nes_kyoursenjuu", NULL, NULL, "1992",
	"Kyouryuu Sentai Juuranger (Japan)\0", NULL, "Angel Studios", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_RUNGUN | GBF_MINIGAMES, 0,
	NESGetZipName, nes_kyoursenjuujRomInfo, nes_kyoursenjuujRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kyouryuu Sentai Juuranger (Hack, English)
static struct BurnRomInfo nes_kyoursenjuuRomDesc[] = {
	{ "Kyouryuu Sentai Juuranger (T-Eng).nes",          262160, 0x7a272f4c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kyoursenjuu)
STD_ROM_FN(nes_kyoursenjuu)

struct BurnDriver BurnDrvnes_kyoursenjuu = {
	"nes_kyoursenjuu", NULL, NULL, NULL, "2009",
	"Kyouryuu Sentai Juuranger (Hack, English)\0", NULL, "Grimm Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_NES, GBF_RUNGUN | GBF_MINIGAMES, 0,
	NESGetZipName, nes_kyoursenjuuRomInfo, nes_kyoursenjuuRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Kyuukyoku Tiger (Japan)
static struct BurnRomInfo nes_kyuukyokutigerRomDesc[] = {
	{ "Kyuukyoku Tiger (Japan).nes",          262160, 0xd4161ee6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_kyuukyokutiger)
STD_ROM_FN(nes_kyuukyokutiger)

struct BurnDriver BurnDrvnes_kyuukyokutiger = {
	"nes_kyuukyokutiger", "nes_twincobra", NULL, NULL, "1989",
	"Kyuukyoku Tiger (Japan)\0", NULL, "CBS / Sony Group", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_kyuukyokutigerRomInfo, nes_kyuukyokutigerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lagrange Point (Japan)
static struct BurnRomInfo nes_lagrangepointjRomDesc[] = {
	{ "Lagrange Point (Japan).nes",          524304, 0xead4dedc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lagrangepointj)
STD_ROM_FN(nes_lagrangepointj)

struct BurnDriver BurnDrvnes_lagrangepointj = {
	"nes_lagrangepointj", "nes_lagrangepoint", NULL, NULL, "1991",
	"Lagrange Point (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_lagrangepointjRomInfo, nes_lagrangepointjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lagrange Point (Hack, English)
static struct BurnRomInfo nes_lagrangepointRomDesc[] = {
	{ "Lagrange Point (T-eng).nes",          524304, 0x9e13caa2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lagrangepoint)
STD_ROM_FN(nes_lagrangepoint)

struct BurnDriver BurnDrvnes_lagrangepoint = {
	"nes_lagrangepoint", NULL, NULL, NULL, "2014",
	"Lagrange Point (Hack, English)\0", NULL, "Aeon Genesis", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_lagrangepointRomInfo, nes_lagrangepointRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Laser Invasion (USA)
static struct BurnRomInfo nes_laserinvasionRomDesc[] = {
	{ "Laser Invasion (USA).nes",          262160, 0xe39e0be2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_laserinvasion)
STD_ROM_FN(nes_laserinvasion)

struct BurnDriver BurnDrvnes_laserinvasion = {
	"nes_laserinvasion", NULL, NULL, NULL, "1991",
	"Laser Invasion (USA)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_laserinvasionRomInfo, nes_laserinvasionRomName, NULL, NULL, NULL, NULL, NESZapperInputInfo, NESZapperDIPInfo,
	NESZapperInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Last Action Hero (USA)
static struct BurnRomInfo nes_lastactionheroRomDesc[] = {
	{ "Last Action Hero (USA).nes",          262160, 0xcd498296, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lastactionhero)
STD_ROM_FN(nes_lastactionhero)

struct BurnDriver BurnDrvnes_lastactionhero = {
	"nes_lastactionhero", NULL, NULL, NULL, "1993",
	"Last Action Hero (USA)\0", NULL, "Sony Imagesoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_lastactionheroRomInfo, nes_lastactionheroRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Last Armageddon (Japan)
static struct BurnRomInfo nes_lastarmageddonjRomDesc[] = {
	{ "Last Armageddon (Japan).nes",          524304, 0xce0cc857, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lastarmageddonj)
STD_ROM_FN(nes_lastarmageddonj)

struct BurnDriver BurnDrvnes_lastarmageddonj = {
	"nes_lastarmageddonj", "nes_lastarmageddon", NULL, NULL, "1990",
	"Last Armageddon (Japan)\0", NULL, "Yutaka", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_lastarmageddonjRomInfo, nes_lastarmageddonjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Last Armageddon (Hack, English v1.02a)
// https://www.romhacking.net/translations/6725/
static struct BurnRomInfo nes_lastarmageddonRomDesc[] = {
	{ "Last Armageddon T-Eng v1.02a (2022)(BlackPaladin).nes",          524304, 0x11faecdb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lastarmageddon)
STD_ROM_FN(nes_lastarmageddon)

struct BurnDriver BurnDrvnes_lastarmageddon = {
	"nes_lastarmageddon", NULL, NULL, NULL, "2022",
	"Last Armageddon (Hack, English v1.02a)\0", NULL, "BlackPaladin", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_lastarmageddonRomInfo, nes_lastarmageddonRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Last Ninja, The (USA)
static struct BurnRomInfo nes_lastninjatheRomDesc[] = {
	{ "Last Ninja, The (USA).nes",          262160, 0xc9c09e0d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lastninjathe)
STD_ROM_FN(nes_lastninjathe)

struct BurnDriver BurnDrvnes_lastninjathe = {
	"nes_lastninjathe", NULL, NULL, NULL, "1991",
	"Last Ninja, The (USA)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_lastninjatheRomInfo, nes_lastninjatheRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Last Starfighter, The (USA)
static struct BurnRomInfo nes_laststaRomDesc[] = {
	{ "Last Starfighter, The (USA).nes",          65552, 0x26bceffd, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_laststa)
STD_ROM_FN(nes_laststa)

struct BurnDriver BurnDrvnes_laststa = {
	"nes_laststa", NULL, NULL, NULL, "1990",
	"Last Starfighter, The (USA)\0", NULL, "Mindscape", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_laststaRomInfo, nes_laststaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Law of the West (Hack, English)
// https://www.romhacking.net/translations/5669/
static struct BurnRomInfo nes_lawesteRomDesc[] = {
	{ "Law of the West T-Eng (2020)(GAFF Translations).nes",          262160, 0x34437445, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_laweste)
STD_ROM_FN(nes_laweste)

	struct BurnDriver BurnDrvnes_laweste = {
	"nes_laweste", NULL, NULL, NULL, "2020",
	"Law of the West (Hack, English)\0", NULL, "GAFF Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_SHOOT | GBF_ADV, 0,
	NESGetZipName, nes_lawesteRomInfo, nes_lawesteRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Law of the West (Japan)
static struct BurnRomInfo nes_lawestjRomDesc[] = {
	{ "Law of the West Jpn (1987)(Pony Canyon).nes",          131088, 0x9d1b5c98, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lawestj)
STD_ROM_FN(nes_lawestj)

	struct BurnDriver BurnDrvnes_lawestj = {
	"nes_lawestj", "nes_laweste", NULL, NULL, "1987",
	"Law of the West (Japan)\0", NULL, "Pony Canyon", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_SHOOT | GBF_ADV, 0,
	NESGetZipName, nes_lawestjRomInfo, nes_lawestjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Layla (Japan)
static struct BurnRomInfo nes_laylajRomDesc[] = {
	{ "Layla (Japan).nes",          131088, 0xd9381fe7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_laylaj)
STD_ROM_FN(nes_laylaj)

struct BurnDriver BurnDrvnes_laylaj = {
	"nes_laylaj", "nes_layla", NULL, NULL, "1986",
	"Layla (Japan)\0", NULL, "dB-SOFT", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_laylajRomInfo, nes_laylajRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Layla (Hack, English)
static struct BurnRomInfo nes_laylaRomDesc[] = {
	{ "Layla (T-Eng).nes",          262160, 0x3f4f9465, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_layla)
STD_ROM_FN(nes_layla)

struct BurnDriver BurnDrvnes_layla = {
	"nes_layla", NULL, NULL, NULL, "2017",
	"Layla (Hack, English)\0", NULL, "Supper", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_laylaRomInfo, nes_laylaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lee Trevino's Fighting Golf (USA)
static struct BurnRomInfo nes_leetresfiggoRomDesc[] = {
	{ "Lee Trevino's Fighting Golf (USA).nes",          262160, 0xe55284da, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_leetresfiggo)
STD_ROM_FN(nes_leetresfiggo)

struct BurnDriver BurnDrvnes_leetresfiggo = {
	"nes_leetresfiggo", NULL, NULL, NULL, "1988",
	"Lee Trevino's Fighting Golf (USA)\0", NULL, "SNK", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_leetresfiggoRomInfo, nes_leetresfiggoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Legacy of the Wizard (USA)
static struct BurnRomInfo nes_legacwizRomDesc[] = {
	{ "Legacy of the Wizard (USA).nes",          196624, 0xb534eb48, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_legacwiz)
STD_ROM_FN(nes_legacwiz)

struct BurnDriver BurnDrvnes_legacwiz = {
	"nes_legacwiz", NULL, NULL, NULL, "1989",
	"Legacy of the Wizard (USA)\0", NULL, "Broderbund", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ADV | GBF_PLATFORM, 0,
	NESGetZipName, nes_legacwizRomInfo, nes_legacwizRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Legend of Balubalouk (Japan)
static struct BurnRomInfo nes_legenbaljRomDesc[] = {
	{ "Legend of Balubalouk (Japan).nes",          131088, 0x04fc4764, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_legenbalj)
STD_ROM_FN(nes_legenbalj)

struct BurnDriver BurnDrvnes_legenbalj = {
	"nes_legenbalj", "nes_legenbal", NULL, NULL, "1986",
	"Legend of Balubalouk (Japan)\0", NULL, "Vic Tokai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_legenbaljRomInfo, nes_legenbaljRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Legend of Balubalouk (Hack, English)
static struct BurnRomInfo nes_legenbalRomDesc[] = {
	{ "Legend of Balubalouk (T-Eng).nes",          131088, 0x661c0a1b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_legenbal)
STD_ROM_FN(nes_legenbal)

struct BurnDriver BurnDrvnes_legenbal = {
	"nes_legenbal", NULL, NULL, NULL, "2017",
	"Legend of Balubalouk (Hack, English)\0", NULL, "Psyklax", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_legenbalRomInfo, nes_legenbalRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Legend of Kage, The (USA)
static struct BurnRomInfo nes_legenkagRomDesc[] = {
	{ "Legend of Kage, The (USA).nes",          49168, 0x6785c961, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_legenkag)
STD_ROM_FN(nes_legenkag)

struct BurnDriver BurnDrvnes_legenkag = {
	"nes_legenkag", NULL, NULL, NULL, "1987",
	"Legend of Kage, The (USA)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_legenkagRomInfo, nes_legenkagRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Legend of Zelda, The (USA) (Rev A)
static struct BurnRomInfo nes_legenzelRomDesc[] = {
	{ "Legend of Zelda, The (USA) (Rev A).nes",          131088, 0x02bb0c56, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_legenzel)
STD_ROM_FN(nes_legenzel)

struct BurnDriver BurnDrvnes_legenzel = {
	"nes_legenzel", NULL, NULL, NULL, "1987",
	"Legend of Zelda, The (USA) (Rev A)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_legenzelRomInfo, nes_legenzelRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Legend of Super Mario, The - Save Mushroom Kingdom (GlobalHack)
// https://www.romhacking.net/hacks/8050/
static struct BurnRomInfo nes_legendsmRomDesc[] = {
	{ "Legend of Super Mario, The - Save Mushroom Kingdom (2023)(NesDraug).nes",          262160, 0xb1d13af1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_legendsm)
STD_ROM_FN(nes_legendsm)

struct BurnDriver BurnDrvnes_legendsm = {
	"nes_legendsm", "nes_legenzel", NULL, NULL, "2023",
	"Legend of Super Mario, The - Save Mushroom Kingdom (GlobalHack)\0", NULL, "NesDraug", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_legendsmRomInfo, nes_legendsmRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Legendary Wings (USA)
static struct BurnRomInfo nes_legendarywingsRomDesc[] = {
	{ "Legendary Wings (USA).nes",          131088, 0x689de607, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_legendarywings)
STD_ROM_FN(nes_legendarywings)

struct BurnDriver BurnDrvnes_legendarywings = {
	"nes_legendarywings", NULL, NULL, NULL, "1988",
	"Legendary Wings (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_legendarywingsRomInfo, nes_legendarywingsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Legend of Fuma, The (Hack, English)
// https://www.romhacking.net/translations/3482/
static struct BurnRomInfo nes_legenfumRomDesc[] = {
	{ "The Legend of Fuma (T-Eng).nes",          393232, 0xdad72cc9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_legenfum)
STD_ROM_FN(nes_legenfum)

struct BurnDriver BurnDrvnes_legenfum = {
	"nes_legenfum", NULL, NULL, NULL, "2018",
	"Legend of Fuma, The (Hack, English)\0", NULL, "Nebulous Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_legenfumRomInfo, nes_legenfumRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lei Dian Huang Bi Ka Qiu Chuan Shuo (China)
static struct BurnRomInfo nes_leidiahuabikaqiuchsRomDesc[] = {
	{ "Lei Dian Huang Bi Ka Qiu Chuan Shuo (China).nes",          2097168, 0xf4ebe9b2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_leidiahuabikaqiuchs)
STD_ROM_FN(nes_leidiahuabikaqiuchs)

struct BurnDriver BurnDrvnes_leidiahuabikaqiuchs = {
	"nes_leidiahuabikaqiuchs", NULL, NULL, NULL, "1989?",
	"Lei Dian Huang Bi Ka Qiu Chuan Shuo (China)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_leidiahuabikaqiuchsRomInfo, nes_leidiahuabikaqiuchsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lemmings (USA)
static struct BurnRomInfo nes_lemmingsRomDesc[] = {
	{ "Lemmings (USA).nes",          262160, 0xcb2c08d4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lemmings)
STD_ROM_FN(nes_lemmings)

struct BurnDriver BurnDrvnes_lemmings = {
	"nes_lemmings", NULL, NULL, NULL, "1992",
	"Lemmings (USA)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_lemmingsRomInfo, nes_lemmingsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lemmings Improvement (Hack, v1.3)
// https://www.romhacking.net/hacks/7748/
static struct BurnRomInfo nes_lemmingsimpRomDesc[] = {
	{ "Lemmings Improvement v1.3 (2023)(Nintendo Lemmings Improvement Team).nes.nes",          262160, 0x97ccd458, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lemmingsimp)
STD_ROM_FN(nes_lemmingsimp)

struct BurnDriver BurnDrvnes_lemmingsimp = {
	"nes_lemmingsimp", "nes_lemmings", NULL, NULL, "2023",
	"Lemmings Improvement (Hack, v1.3)\0", NULL, "Nintendo Lemmings Improvement Team", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_lemmingsimpRomInfo, nes_lemmingsimpRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lethal Weapon (USA)
static struct BurnRomInfo nes_lethalweaponRomDesc[] = {
	{ "Lethal Weapon (USA).nes",          262160, 0x1dc4915b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lethalweapon)
STD_ROM_FN(nes_lethalweapon)

struct BurnDriver BurnDrvnes_lethalweapon = {
	"nes_lethalweapon", NULL, NULL, NULL, "1993",
	"Lethal Weapon (USA)\0", NULL, "Ocean", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_lethalweaponRomInfo, nes_lethalweaponRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Life Force (USA)
static struct BurnRomInfo nes_lifeforceRomDesc[] = {
	{ "Life Force (USA).nes",          131088, 0xf7b55696, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lifeforce)
STD_ROM_FN(nes_lifeforce)

struct BurnDriver BurnDrvnes_lifeforce = {
	"nes_lifeforce", NULL, NULL, NULL, "1988",
	"Life Force (USA)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_HORSHOOT | GBF_VERSHOOT, 0,
	NESGetZipName, nes_lifeforceRomInfo, nes_lifeforceRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Linus Spacehead's Cosmic Crusade (USA)
static struct BurnRomInfo nes_linusspascoscrRomDesc[] = {
	{ "Linus Spacehead's Cosmic Crusade (USA).nes",          262160, 0xfffddf99, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_linusspascoscr)
STD_ROM_FN(nes_linusspascoscr)

struct BurnDriver BurnDrvnes_linusspascoscr = {
	"nes_linusspascoscr", NULL, NULL, NULL, "1992",
	"Linus Spacehead's Cosmic Crusade (USA)\0", NULL, "Camerica", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_linusspascoscrRomInfo, nes_linusspascoscrRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lion King Legend, The (China) (Unl)
static struct BurnRomInfo nes_lionkinlegcRomDesc[] = {
	{ "Lion King Legend, The (China).nes",          524304, 0x1309fa69, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lionkinlegc)
STD_ROM_FN(nes_lionkinlegc)

struct BurnDriver BurnDrvnes_lionkinlegc = {
	"nes_lionkinlegc", "nes_lionkinleg", NULL, NULL, "1996",
	"Lion King Legend, The (China) (Unl)\0", NULL, "Waixing", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_lionkinlegcRomInfo, nes_lionkinlegcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lion King Legend, The (Hack, English) (Unl)
static struct BurnRomInfo nes_lionkinlegRomDesc[] = {
	{ "Lion King Legend, The (T-Eng).nes",          524304, 0x0f95fc73, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lionkinleg)
STD_ROM_FN(nes_lionkinleg)

struct BurnDriver BurnDrvnes_lionkinleg = {
	"nes_lionkinleg", NULL, NULL, NULL, "2015",
	"Lion King Legend, The (Hack, English) (Unl)\0", NULL, "pacnsacdave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_lionkinlegRomInfo, nes_lionkinlegRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lion King, The (Euro)
static struct BurnRomInfo nes_lionkingtheRomDesc[] = {
	{ "Lion King, The (Europe).nes",          262160, 0x149e367f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lionkingthe)
STD_ROM_FN(nes_lionkingthe)

struct BurnDriver BurnDrvnes_lionkingthe = {
	"nes_lionkingthe", NULL, NULL, NULL, "1994",
	"Lion King, The (Euro)\0", NULL, "Virgin Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_lionkingtheRomInfo, nes_lionkingtheRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL, SCREEN_WIDTH, SCREEN_HEIGHT_PAL
};

// Little Magic (Japan)
static struct BurnRomInfo nes_littlemagicRomDesc[] = {
	{ "Little Magic (Japan).nes",          262160, 0xfc3c18eb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_littlemagic)
STD_ROM_FN(nes_littlemagic)

struct BurnDriver BurnDrvnes_littlemagic = {
	"nes_littlemagic", NULL, NULL, NULL, "1990",
	"Little Magic (Japan)\0", NULL, "Data East", "Miscellaneous",
	L"Little Magic (Japan)\0\u30ea\u30c8\u30eb\u30de\u30b8\u30c3\u30af\0", NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_littlemagicRomInfo, nes_littlemagicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Little Mermaid, The (Japan)
static struct BurnRomInfo nes_littlmerjRomDesc[] = {
	{ "Little Mermaid, The (Japan).nes",          131088, 0x57c9290f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_littlmerj)
STD_ROM_FN(nes_littlmerj)

struct BurnDriver BurnDrvnes_littlmerj = {
	"nes_littlmerj", "nes_littlmer", NULL, NULL, "1991",
	"Little Mermaid, The (Japan)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_SHOOT | GBF_ADV, 0,
	NESGetZipName, nes_littlmerjRomInfo, nes_littlmerjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Little Mermaid, The (USA)
static struct BurnRomInfo nes_littlmerRomDesc[] = {
	{ "Little Mermaid, The (USA).nes",          131088, 0x08eb97db, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_littlmer)
STD_ROM_FN(nes_littlmer)

struct BurnDriver BurnDrvnes_littlmer = {
	"nes_littlmer", NULL, NULL, NULL, "1991",
	"Little Mermaid, The (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT | GBF_ADV, 0,
	NESGetZipName, nes_littlmerRomInfo, nes_littlmerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Little Nemo - The Dream Master (USA)
static struct BurnRomInfo nes_littlnemRomDesc[] = {
	{ "Little Nemo - The Dream Master (USA).nes",          262160, 0x71d868c4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_littlnem)
STD_ROM_FN(nes_littlnem)

struct BurnDriver BurnDrvnes_littlnem = {
	"nes_littlnem", NULL, NULL, NULL, "1990",
	"Little Nemo - The Dream Master (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_littlnemRomInfo, nes_littlnemRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Little Ninja Brothers (USA)
static struct BurnRomInfo nes_littlninbroRomDesc[] = {
	{ "Little Ninja Brothers (USA).nes",          262160, 0x96ece52b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_littlninbro)
STD_ROM_FN(nes_littlninbro)

struct BurnDriver BurnDrvnes_littlninbro = {
	"nes_littlninbro", NULL, NULL, NULL, "1990",
	"Little Ninja Brothers (USA)\0", NULL, "Culture Brain", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RUNGUN | GBF_RPG, 0,
	NESGetZipName, nes_littlninbroRomInfo, nes_littlninbroRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Little Samson (USA)
static struct BurnRomInfo nes_littlesamsonRomDesc[] = {
	{ "Little Samson (USA).nes",          393232, 0x6bb483e8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_littlesamson)
STD_ROM_FN(nes_littlesamson)

struct BurnDriver BurnDrvnes_littlesamson = {
	"nes_littlesamson", NULL, NULL, NULL, "1992",
	"Little Samson (USA)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_littlesamsonRomInfo, nes_littlesamsonRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lode Runner (USA)
static struct BurnRomInfo nes_loderunnerRomDesc[] = {
	{ "Lode Runner (USA).nes",          24592, 0xcd4bf911, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_loderunner)
STD_ROM_FN(nes_loderunner)

struct BurnDriver BurnDrvnes_loderunner = {
	"nes_loderunner", NULL, NULL, NULL, "1987",
	"Lode Runner (USA)\0", NULL, "Broderbund", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_loderunnerRomInfo, nes_loderunnerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lone Ranger, The (USA)
static struct BurnRomInfo nes_lonerangertheRomDesc[] = {
	{ "Lone Ranger, The (USA).nes",          393232, 0x06c65580, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lonerangerthe)
STD_ROM_FN(nes_lonerangerthe)

struct BurnDriver BurnDrvnes_lonerangerthe = {
	"nes_lonerangerthe", NULL, NULL, NULL, "1991",
	"Lone Ranger, The (USA)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT | GBF_ADV, 0,
	NESGetZipName, nes_lonerangertheRomInfo, nes_lonerangertheRomName, NULL, NULL, NULL, NULL, NESZapperInputInfo, NESZapperDIPInfo,
	NESZapperInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Loopz (USA)
static struct BurnRomInfo nes_loopzRomDesc[] = {
	{ "Loopz (USA).nes",          131088, 0x3e7a06a7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_loopz)
STD_ROM_FN(nes_loopz)

struct BurnDriver BurnDrvnes_loopz = {
	"nes_loopz", NULL, NULL, NULL, "1990",
	"Loopz (USA)\0", NULL, "Mindscape", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_loopzRomInfo, nes_loopzRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lot Lot (Japan)
static struct BurnRomInfo nes_lotlotRomDesc[] = {
	{ "Lot Lot (Japan).nes",          40976, 0x8b7ac605, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lotlot)
STD_ROM_FN(nes_lotlot)

struct BurnDriver BurnDrvnes_lotlot = {
	"nes_lotlot", NULL, NULL, NULL, "1985",
	"Lot Lot (Japan)\0", NULL, "Tokuma Shoten", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_lotlotRomInfo, nes_lotlotRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Low G Man - The Low Gravity Man (USA)
static struct BurnRomInfo nes_lowgmanRomDesc[] = {
	{ "Low G Man - The Low Gravity Man (USA).nes",          262160, 0xb90a1ca1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lowgman)
STD_ROM_FN(nes_lowgman)

struct BurnDriver BurnDrvnes_lowgman = {
	"nes_lowgman", NULL, NULL, NULL, "1990",
	"Low G Man - The Low Gravity Man (USA)\0", NULL, "Taxan", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_lowgmanRomInfo, nes_lowgmanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lunar Pool (USA)
static struct BurnRomInfo nes_lunarpoolRomDesc[] = {
	{ "Lunar Pool (USA).nes",          24592, 0xfa96cba2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lunarpool)
STD_ROM_FN(nes_lunarpool)

struct BurnDriver BurnDrvnes_lunarpool = {
	"nes_lunarpool", NULL, NULL, NULL, "1987",
	"Lunar Pool (USA)\0", NULL, "FCI", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_lunarpoolRomInfo, nes_lunarpoolRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lupin Sansei - Pandora no Isan (Japan)
static struct BurnRomInfo nes_lupinsanjRomDesc[] = {
	{ "Lupin Sansei - Pandora no Isan (Japan).nes",          196624, 0xbf2947ba, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lupinsanj)
STD_ROM_FN(nes_lupinsanj)

struct BurnDriver BurnDrvnes_lupinsanj = {
	"nes_lupinsanj", "nes_lupinsan", NULL, NULL, "1987",
	"Lupin Sansei - Pandora no Isan (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_lupinsanjRomInfo, nes_lupinsanjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lupin Sansei - Pandora no Isan (Hack, English)
// https://www.romhacking.net/translations/773/
static struct BurnRomInfo nes_lupinsanRomDesc[] = {
	{ "Lupin Sansei - Pandora no Isan (T-eng).nes",          196624, 0x6054ca94, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lupinsan)
STD_ROM_FN(nes_lupinsan)

struct BurnDriver BurnDrvnes_lupinsan = {
	"nes_lupinsan", NULL, NULL, NULL, "2017",
	"Lupin Sansei - Pandora no Isan (Hack, English)\0", NULL, "Vice Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_lupinsanRomInfo, nes_lupinsanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// M.C. Kids (USA)
static struct BurnRomInfo nes_mckidsRomDesc[] = {
	{ "M.C. Kids (USA).nes",          262160, 0x9a78fb49, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mckids)
STD_ROM_FN(nes_mckids)

struct BurnDriver BurnDrvnes_mckids = {
	"nes_mckids", NULL, NULL, NULL, "1992",
	"M.C. Kids (USA)\0", NULL, "Virgin Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_mckidsRomInfo, nes_mckidsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// M.U.L.E. (USA)
static struct BurnRomInfo nes_muleRomDesc[] = {
	{ "M.U.L.E. (USA).nes",          131088, 0xdbf91186, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mule)
STD_ROM_FN(nes_mule)

struct BurnDriver BurnDrvnes_mule = {
	"nes_mule", NULL, NULL, NULL, "1990",
	"M.U.L.E. (USA)\0", NULL, "Mindscape", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_muleRomInfo, nes_muleRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// M.U.S.C.L.E. (USA)
static struct BurnRomInfo nes_muscleRomDesc[] = {
	{ "M.U.S.C.L.E. (USA).nes",          24592, 0xedee9759, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_muscle)
STD_ROM_FN(nes_muscle)

struct BurnDriver BurnDrvnes_muscle = {
	"nes_muscle", NULL, NULL, NULL, "1986",
	"M.U.S.C.L.E. (USA)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_muscleRomInfo, nes_muscleRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mach Rider (USA)
static struct BurnRomInfo nes_machriderRomDesc[] = {
	{ "Mach Rider (USA).nes",          40976, 0xbee56098, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_machrider)
STD_ROM_FN(nes_machrider)

struct BurnDriver BurnDrvnes_machrider = {
	"nes_machrider", NULL, NULL, NULL, "1985",
	"Mach Rider (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_machriderRomInfo, nes_machriderRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mad City (Japan)
static struct BurnRomInfo nes_madcityjRomDesc[] = {
	{ "Mad City (Japan).nes",          262160, 0xb28d64fc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_madcityj)
STD_ROM_FN(nes_madcityj)

struct BurnDriver BurnDrvnes_madcityj = {
	"nes_madcityj", "nes_advenbaybil", NULL, NULL, "1988",
	"Mad City (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_SHOOT, 0,
	NESGetZipName, nes_madcityjRomInfo, nes_madcityjRomName, NULL, NULL, NULL, NULL, NESZapperInputInfo, NESZapperDIPInfo,
	NESZapperInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mad City (Hack, English)
static struct BurnRomInfo nes_madcityRomDesc[] = {
	{ "Mad City (T-Eng).nes",          262160, 0x52389803, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_madcity)
STD_ROM_FN(nes_madcity)

struct BurnDriver BurnDrvnes_madcity = {
	"nes_madcity", "nes_advenbaybil", NULL, NULL, "2010",
	"Mad City (Hack, English)\0", NULL, "Stardust Crusaders", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_SHOOT, 0,
	NESGetZipName, nes_madcityRomInfo, nes_madcityRomName, NULL, NULL, NULL, NULL, NESZapperInputInfo, NESZapperDIPInfo,
	NESZapperInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mad Max (USA)
static struct BurnRomInfo nes_madmaxRomDesc[] = {
	{ "Mad Max (USA).nes",          262160, 0x28fd4957, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_madmax)
STD_ROM_FN(nes_madmax)

struct BurnDriver BurnDrvnes_madmax = {
	"nes_madmax", NULL, NULL, NULL, "1990",
	"Mad Max (USA)\0", NULL, "Mindscape", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_madmaxRomInfo, nes_madmaxRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mafat Conspiracy - Golgo 13 (USA)
static struct BurnRomInfo nes_mafatconRomDesc[] = {
	{ "Mafat Conspiracy - Golgo 13 (USA).nes",          262160, 0xa0973444, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mafatcon)
STD_ROM_FN(nes_mafatcon)

struct BurnDriver BurnDrvnes_mafatcon = {
	"nes_mafatcon", NULL, NULL, NULL, "1990",
	"Mafat Conspiracy - Golgo 13 (USA)\0", NULL, "Vic Tokai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_SHOOT, 0,
	NESGetZipName, nes_mafatconRomInfo, nes_mafatconRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Magic Block (Unl)
static struct BurnRomInfo nes_magicblockRomDesc[] = {
	{ "Magic Block (Mega Soft).nes",          131088, 0x2eba03bd, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_magicblock)
STD_ROM_FN(nes_magicblock)

struct BurnDriver BurnDrvnes_magicblock = {
	"nes_magicblock", NULL, NULL, NULL, "1991",
	"Magic Block (Unl)\0", NULL, "Mega Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_magicblockRomInfo, nes_magicblockRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Magic Carpet 1001 (Unl)
static struct BurnRomInfo nes_magiccar100RomDesc[] = {
	{ "Magic Carpet 1001 (Unl).nes",          65552, 0x1ab5b8c5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_magiccar100)
STD_ROM_FN(nes_magiccar100)

struct BurnDriver BurnDrvnes_magiccar100 = {
	"nes_magiccar100", NULL, NULL, NULL, "1992",
	"Magic Carpet 1001 (Unl)\0", NULL, "Caltron", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_magiccar100RomInfo, nes_magiccar100RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Magic Darts (USA)
static struct BurnRomInfo nes_magicdartsRomDesc[] = {
	{ "Magic Darts (USA).nes",          262160, 0x330bc629, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_magicdarts)
STD_ROM_FN(nes_magicdarts)

struct BurnDriver BurnDrvnes_magicdarts = {
	"nes_magicdarts", NULL, NULL, NULL, "1991",
	"Magic Darts (USA)\0", NULL, "Romstar", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_magicdartsRomInfo, nes_magicdartsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Magic Dragon (Japan)
static struct BurnRomInfo nes_magicdragonRomDesc[] = {
	{ "Magic Dragon (J).nes",          196624, 0x1ad30965, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_magicdragon)
STD_ROM_FN(nes_magicdragon)

struct BurnDriver BurnDrvnes_magicdragon = {
	"nes_magicdragon", NULL, NULL, NULL, "199?",
	"Magic Dragon (Japan)\0", NULL, "Magic", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_magicdragonRomInfo, nes_magicdragonRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Magic Jewelry (Unl)
static struct BurnRomInfo nes_magicjewelryRomDesc[] = {
	{ "Magic Jewelry (Unl).nes",          40976, 0x26ad6047, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_magicjewelry)
STD_ROM_FN(nes_magicjewelry)

struct BurnDriver BurnDrvnes_magicjewelry = {
	"nes_magicjewelry", NULL, NULL, NULL, "1990",
	"Magic Jewelry (Unl)\0", NULL, "RCM", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_magicjewelryRomInfo, nes_magicjewelryRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Magic Jewelry 2 (Unl)
static struct BurnRomInfo nes_magicjewelry2RomDesc[] = {
	{ "Magic Jewelry 2 (Unl).nes",          65552, 0x9d4b8891, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_magicjewelry2)
STD_ROM_FN(nes_magicjewelry2)

struct BurnDriver BurnDrvnes_magicjewelry2 = {
	"nes_magicjewelry2", NULL, NULL, NULL, "1992",
	"Magic Jewelry 2 (Unl)\0", NULL, "RCM", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_magicjewelry2RomInfo, nes_magicjewelry2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Magic John (Japan)
static struct BurnRomInfo nes_magicjohnRomDesc[] = {
	{ "Magic John (Japan).nes",          262160, 0xa7b98886, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_magicjohn)
STD_ROM_FN(nes_magicjohn)

struct BurnDriver BurnDrvnes_magicjohn = {
	"nes_magicjohn", "nes_totallyrad", NULL, NULL, "1990",
	"Magic John (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_magicjohnRomInfo, nes_magicjohnRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Magic Johnson's Fast Break (USA)
static struct BurnRomInfo nes_magicjohsfasbrRomDesc[] = {
	{ "Magic Johnson's Fast Break (USA).nes",          196624, 0x4d42a98c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_magicjohsfasbr)
STD_ROM_FN(nes_magicjohsfasbr)

struct BurnDriver BurnDrvnes_magicjohsfasbr = {
	"nes_magicjohsfasbr", NULL, NULL, NULL, "1990",
	"Magic Johnson's Fast Break (USA)\0", NULL, "Tradewest", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_magicjohsfasbrRomInfo, nes_magicjohsfasbrRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_magickidgoogooRomDesc[] = {
	{ "Magic Kid GooGoo (Unl).nes",          393232, 0x12332a62, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_magickidgoogoo)
STD_ROM_FN(nes_magickidgoogoo)

struct BurnDriver BurnDrvnes_magickidgoogoo = {
	"nes_magickidgoogoo", NULL, NULL, NULL, "1992",
	"Magic Kid GooGoo (Unl)\0", NULL, "Zemina", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_magickidgoogooRomInfo, nes_magickidgoogooRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_magicschRomDesc[] = {
	{ "Magic of Scheherazade, The (USA).nes",          262160, 0xffaa505d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_magicsch)
STD_ROM_FN(nes_magicsch)

struct BurnDriver BurnDrvnes_magicsch = {
	"nes_magicsch", NULL, NULL, NULL, "1989",
	"Magic of Scheherazade, The (USA)\0", NULL, "Culture Brain", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_magicschRomInfo, nes_magicschRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_magickidsdorRomDesc[] = {
	{ "Magical Kid's Doropie (Japan).nes",          262160, 0x5455ffc9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_magickidsdor)
STD_ROM_FN(nes_magickidsdor)

struct BurnDriver BurnDrvnes_magickidsdor = {
	"nes_magickidsdor", "nes_krioncon", NULL, NULL, "1990",
	"Magical Kid's Doropie (Japan)\0", NULL, "Vic Tokai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_magickidsdorRomInfo, nes_magickidsdorRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_magictarkunRomDesc[] = {
	{ "Magical Taruruuto-kun - Fantastic World!! (Japan).nes",          262160, 0x65b8e68b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_magictarkun)
STD_ROM_FN(nes_magictarkun)

struct BurnDriver BurnDrvnes_magictarkun = {
	"nes_magictarkun", NULL, NULL, NULL, "1991",
	"Magical Taruruuto-kun - Fantastic World!! (Japan)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_magictarkunRomInfo, nes_magictarkunRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_magictarkun2RomDesc[] = {
	{ "Magical Taruruuto-kun 2 - Mahou Daibouken (Japan).nes",          262160, 0x0ef31d50, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_magictarkun2)
STD_ROM_FN(nes_magictarkun2)

struct BurnDriver BurnDrvnes_magictarkun2 = {
	"nes_magictarkun2", NULL, NULL, NULL, "1992",
	"Magical Taruruuto-kun 2 - Mahou Daibouken (Japan)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_magictarkun2RomInfo, nes_magictarkun2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_magicianRomDesc[] = {
	{ "Magician (USA).nes",          262160, 0x8f37610a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_magician)
STD_ROM_FN(nes_magician)

struct BurnDriver BurnDrvnes_magician = {
	"nes_magician", NULL, NULL, NULL, "1991",
	"Magician (USA)\0", NULL, "Taxan", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_magicianRomInfo, nes_magicianRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Magmax (USA)
static struct BurnRomInfo nes_magmaxRomDesc[] = {
	{ "Magmax (USA).nes",          40976, 0x7fe5b39b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_magmax)
STD_ROM_FN(nes_magmax)

struct BurnDriver BurnDrvnes_magmax = {
	"nes_magmax", NULL, NULL, NULL, "1988",
	"Magmax (USA)\0", NULL, "FCI", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_magmaxRomInfo, nes_magmaxRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Maharaja (Japan)
static struct BurnRomInfo nes_maharajajRomDesc[] = {
	{ "Maharaja (Japan).nes",          262160, 0xb9083fde, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_maharajaj)
STD_ROM_FN(nes_maharajaj)

struct BurnDriver BurnDrvnes_maharajaj = {
	"nes_maharajaj", "nes_maharaja", NULL, NULL, "1989",
	"Maharaja (Japan)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_maharajajRomInfo, nes_maharajajRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Maharaja (Hack, English)
static struct BurnRomInfo nes_maharajaRomDesc[] = {
	{ "Maharaja (T-eng).nes",          262160, 0xd6883037, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_maharaja)
STD_ROM_FN(nes_maharaja)

struct BurnDriver BurnDrvnes_maharaja = {
	"nes_maharaja", NULL, NULL, NULL, "2009",
	"Maharaja (Hack, English)\0", NULL, "snark", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_maharajaRomInfo, nes_maharajaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mahou no Princess Minky Momo - Remember Dream (Japan)
static struct BurnRomInfo nes_minkymomojRomDesc[] = {
	{ "Mahou no Princess Minky Momo - Remember Dream (J)(1992)(Yutaka).nes",          262160, 0xd1b65a3e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_minkymomoj)
STD_ROM_FN(nes_minkymomoj)

struct BurnDriver BurnDrvnes_minkymomoj = {
	"nes_minkymomoj", "nes_minkymomo", NULL, NULL, "2023",
	"Mahou no Princess Minky Momo - Remember Dream (Japan)\0", NULL, "Yutaka", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_minkymomojRomInfo, nes_minkymomojRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mahou no Princess Minky Momo - Remember Dream (Hack, English)
// https://www.romhacking.net/translations/7108/
static struct BurnRomInfo nes_minkymomoRomDesc[] = {
	{ "Mahou no Princess Minky Momo - Remember Dream T-Eng (2023)(karmic).nes",          262160, 0xa6eba573, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_minkymomo)
STD_ROM_FN(nes_minkymomo)

struct BurnDriver BurnDrvnes_minkymomo = {
	"nes_minkymomo", NULL, NULL, NULL, "2023",
	"Mahou no Princess Minky Momo - Remember Dream (Hack, English)\0", NULL, "karmic", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_ACTION | GBF_ADV, 0,
	NESGetZipName, nes_minkymomoRomInfo, nes_minkymomoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Major League (Japan)
static struct BurnRomInfo nes_majorleagueRomDesc[] = {
	{ "Major League (Japan).nes",          262160, 0xd8dfd3d1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_majorleague)
STD_ROM_FN(nes_majorleague)

struct BurnDriver BurnDrvnes_majorleague = {
	"nes_majorleague", NULL, NULL, NULL, "1989",
	"Major League (Japan)\0", NULL, "Irem", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_majorleagueRomInfo, nes_majorleagueRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Major League Baseball (USA) (Rev A)
static struct BurnRomInfo nes_majorleabasRomDesc[] = {
	{ "Major League Baseball (USA) (Rev A).nes",          65552, 0xd9cddbd2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_majorleabas)
STD_ROM_FN(nes_majorleabas)

struct BurnDriver BurnDrvnes_majorleabas = {
	"nes_majorleabas", NULL, NULL, NULL, "1988",
	"Major League Baseball (USA) (Rev A)\0", NULL, "Ljn", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_majorleabasRomInfo, nes_majorleabasRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Majou Densetsu II - Daimashikyou Galious (Japan)
static struct BurnRomInfo nes_majoudeniiRomDesc[] = {
	{ "Majou Densetsu II - Daimashikyou Galious (Japan).nes",          131088, 0x763f2d28, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_majoudenii)
STD_ROM_FN(nes_majoudenii)

struct BurnDriver BurnDrvnes_majoudenii = {
	"nes_majoudenii", NULL, NULL, NULL, "1987",
	"Majou Densetsu II - Daimashikyou Galious (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_majoudeniiRomInfo, nes_majoudeniiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Makaimura (Japan)
static struct BurnRomInfo nes_makaimuraRomDesc[] = {
	{ "Makaimura (Japan).nes",          131088, 0x8c3fe6fb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_makaimura)
STD_ROM_FN(nes_makaimura)

struct BurnDriver BurnDrvnes_makaimura = {
	"nes_makaimura", "nes_ghostsngoblins", NULL, NULL, "1986",
	"Makaimura (Japan)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_makaimuraRomInfo, nes_makaimuraRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Makaimura Arcade (Hack)
static struct BurnRomInfo nes_makaimuraarcadeRomDesc[] = {
	{ "Makaimura Arcade (Japan).nes",          131088, 0xb523b441, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_makaimuraarcade)
STD_ROM_FN(nes_makaimuraarcade)

struct BurnDriver BurnDrvnes_makaimuraarcade = {
	"nes_makaimuraarcade", "nes_ghostsngoblins", NULL, NULL, "2010",
	"Makaimura Arcade (Hack)\0", NULL, "2CH", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_makaimuraarcadeRomInfo, nes_makaimuraarcadeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Maniac Mansion (USA)
static struct BurnRomInfo nes_maniacmansionRomDesc[] = {
	{ "Maniac Mansion (USA).nes",          262160, 0x68309d06, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_maniacmansion)
STD_ROM_FN(nes_maniacmansion)

struct BurnDriver BurnDrvnes_maniacmansion = {
	"nes_maniacmansion", NULL, NULL, NULL, "1988",
	"Maniac Mansion (USA)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_maniacmansionRomInfo, nes_maniacmansionRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Maniac Mansion Uncensored (Hack, v2.0)
// https://www.romhacking.net/hacks/7784/
static struct BurnRomInfo nes_maniacmanuncRomDesc[] = {
	{ "Maniac Mansion Uncensored v2.0 (2023)(gzip).nes",          524304, 0x483e38f2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_maniacmanunc)
STD_ROM_FN(nes_maniacmanunc)

struct BurnDriver BurnDrvnes_maniacmanunc = {
	"nes_maniacmanunc", "nes_maniacmansion", NULL, NULL, "2023",
	"Maniac Mansion Uncensored (Hack, v2.0)\0", NULL, "gzip", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_maniacmanuncRomInfo, nes_maniacmanuncRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mappy (Japan)
static struct BurnRomInfo nes_mappyRomDesc[] = {
	{ "Mappy (Japan).nes",          24592, 0x3f0e8e0a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mappy)
STD_ROM_FN(nes_mappy)

struct BurnDriver BurnDrvnes_mappy = {
	"nes_mappy", NULL, NULL, NULL, "1984",
	"Mappy (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION | GBF_PLATFORM, 0,
	NESGetZipName, nes_mappyRomInfo, nes_mappyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mappy Kids (Japan)
static struct BurnRomInfo nes_mappykidsRomDesc[] = {
	{ "Mappy Kids (Japan).nes",          262160, 0x3350c674, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mappykids)
STD_ROM_FN(nes_mappykids)

struct BurnDriver BurnDrvnes_mappykids = {
	"nes_mappykids", NULL, NULL, NULL, "1989",
	"Mappy Kids (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_mappykidsRomInfo, nes_mappykidsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mappy-Land (USA)
static struct BurnRomInfo nes_mappylandRomDesc[] = {
	{ "Mappy-Land (USA).nes",          163856, 0x4e8ebcfe, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mappyland)
STD_ROM_FN(nes_mappyland)

struct BurnDriver BurnDrvnes_mappyland = {
	"nes_mappyland", NULL, NULL, NULL, "1989",
	"Mappy-Land (USA)\0", NULL, "Taxan", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_mappylandRomInfo, nes_mappylandRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Marble Madness (USA)
static struct BurnRomInfo nes_marblemadnessRomDesc[] = {
	{ "Marble Madness (USA).nes",          131088, 0xf9282f28, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_marblemadness)
STD_ROM_FN(nes_marblemadness)

struct BurnDriver BurnDrvnes_marblemadness = {
	"nes_marblemadness", NULL, NULL, NULL, "1989",
	"Marble Madness (USA)\0", NULL, "Milton Bradley", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_marblemadnessRomInfo, nes_marblemadnessRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mario Bros. (World)
static struct BurnRomInfo nes_mariobrosRomDesc[] = {
	{ "Mario Bros. (World).nes",          24592, 0xa6de1b55, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mariobros)
STD_ROM_FN(nes_mariobros)

struct BurnDriver BurnDrvnes_mariobros = {
	"nes_mariobros", NULL, NULL, NULL, "1983",
	"Mario Bros. (World)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_mariobrosRomInfo, nes_mariobrosRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mario Bros. (Euro, MC-0 Classic Series)
static struct BurnRomInfo nes_mariobrosmc0RomDesc[] = {
	{ "Mario Bros. (Euro)(MC-0, Classic Series)(1993)(Nintendo).nes",          40976, 0x643702d9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mariobrosmc0)
STD_ROM_FN(nes_mariobrosmc0)

struct BurnDriver BurnDrvnes_mariobrosmc0 = {
	"nes_mariobrosmc0", "nes_mariobros", NULL, NULL, "1993",
	"Mario Bros. (Euro, MC-0 Classic Series)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_mariobrosmc0RomInfo, nes_mariobrosmc0RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL, SCREEN_WIDTH, SCREEN_HEIGHT_PAL
};

// Mashin Eiyuu Den Wataru Gaiden (Japan)
static struct BurnRomInfo nes_mashieiydenwatgajRomDesc[] = {
	{ "Mashin Eiyuu Den Wataru Gaiden (Japan).nes",          262160, 0xb563981f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mashieiydenwatgaj)
STD_ROM_FN(nes_mashieiydenwatgaj)

struct BurnDriver BurnDrvnes_mashieiydenwatgaj = {
	"nes_mashieiydenwatgaj", "nes_mashieiydenwatga", NULL, NULL, "1990",
	"Mashin Eiyuu Den Wataru Gaiden (Japan)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_mashieiydenwatgajRomInfo, nes_mashieiydenwatgajRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mashin Eiyuu Den Wataru Gaiden (Hack, English)
static struct BurnRomInfo nes_mashieiydenwatgaRomDesc[] = {
	{ "Mashin Eiyuu Den Wataru Gaiden (T-eng).nes",          262160, 0x806af261, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mashieiydenwatga)
STD_ROM_FN(nes_mashieiydenwatga)

struct BurnDriver BurnDrvnes_mashieiydenwatga = {
	"nes_mashieiydenwatga", NULL, NULL, NULL, "2013",
	"Mashin Eiyuu Den Wataru Gaiden (Hack, English)\0", NULL, "Hubz", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_mashieiydenwatgaRomInfo, nes_mashieiydenwatgaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Master Chu and the Drunkard Hu (USA)
static struct BurnRomInfo nes_mastechuanddruhuRomDesc[] = {
	{ "Master Chu and the Drunkard Hu (USA) (Unl).nes",          65552, 0x062a680a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mastechuanddruhu)
STD_ROM_FN(nes_mastechuanddruhu)

struct BurnDriver BurnDrvnes_mastechuanddruhu = {
	"nes_mastechuanddruhu", NULL, NULL, NULL, "1989",
	"Master Chu and the Drunkard Hu (USA)\0", NULL, "Color Dreams", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_mastechuanddruhuRomInfo, nes_mastechuanddruhuRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_matendoujiRomDesc[] = {
	{ "Matendouji (Japan).nes",          262160, 0xd8ca4be6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_matendouji)
STD_ROM_FN(nes_matendouji)

struct BurnDriver BurnDrvnes_matendouji = {
	"nes_matendouji", NULL, NULL, NULL, "1990",
	"Matendouji (Japan)\0", NULL, "Bothtec (Quest)", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_matendoujiRomInfo, nes_matendoujiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_maxwarRomDesc[] = {
	{ "Max Warrior - Wakusei Kaigenrei (Japan).nes",          262160, 0xd4dddcb9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_maxwar)
STD_ROM_FN(nes_maxwar)

struct BurnDriver BurnDrvnes_maxwar = {
	"nes_maxwar", NULL, NULL, NULL, "1990",
	"Max Warrior - Wakusei Kaigenrei (Japan)\0", NULL, "Vap", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_maxwarRomInfo, nes_maxwarRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_mechaattRomDesc[] = {
	{ "Mechanized Attack (USA).nes",          196624, 0xd56644b7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mechaatt)
STD_ROM_FN(nes_mechaatt)

struct BurnDriver BurnDrvnes_mechaatt = {
	"nes_mechaatt", NULL, NULL, NULL, "1990",
	"Mechanized Attack (USA)\0", NULL, "SNK", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_mechaattRomInfo, nes_mechaattRomName, NULL, NULL, NULL, NULL, NESZapperInputInfo, NESZapperDIPInfo,
	NESZapperInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mega Man (USA)
static struct BurnRomInfo nes_megamanRomDesc[] = {
	{ "Mega Man (USA).nes",          131088, 0x5ded683e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_megaman)
STD_ROM_FN(nes_megaman)

struct BurnDriver BurnDrvnes_megaman = {
	"nes_megaman", NULL, NULL, NULL, "1987",
	"Mega Man (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_megamanRomInfo, nes_megamanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mega Man 2 (USA)
static struct BurnRomInfo nes_megaman2RomDesc[] = {
	{ "Mega Man 2 (USA).nes",          262160, 0x5e268761, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_megaman2)
STD_ROM_FN(nes_megaman2)

struct BurnDriver BurnDrvnes_megaman2 = {
	"nes_megaman2", NULL, NULL, NULL, "1989",
	"Mega Man 2 (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_megaman2RomInfo, nes_megaman2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mega Man 3 (USA)
static struct BurnRomInfo nes_megaman3RomDesc[] = {
	{ "Mega Man 3 (USA).nes",          393232, 0x452d8089, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_megaman3)
STD_ROM_FN(nes_megaman3)

struct BurnDriver BurnDrvnes_megaman3 = {
	"nes_megaman3", NULL, NULL, NULL, "1990",
	"Mega Man 3 (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_megaman3RomInfo, nes_megaman3RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mega Man 3 Improvement (Hack v2.31)
static struct BurnRomInfo nes_megaman3impRomDesc[] = {
	{ "Mega Man 3 Improvement v2.31 (2022)(kuja killer).nes",          786448, 0x5b579be6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_megaman3imp)
STD_ROM_FN(nes_megaman3imp)

struct BurnDriver BurnDrvnes_megaman3imp = {
	"nes_megaman3imp", "nes_megaman3", NULL, NULL, "2022",
	"Mega Man 3 Improvement (Hack v2.31)\0", NULL, "kuja killer", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_megaman3impRomInfo, nes_megaman3impRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mega Man 3 Revamped (Hack v1.1)
static struct BurnRomInfo nes_megaman3revRomDesc[] = {
	{ "Mega Man 3 Revamped (Hack v1.1).nes",          786448, 0xa0858e49, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_megaman3rev)
STD_ROM_FN(nes_megaman3rev)

struct BurnDriver BurnDrvnes_megaman3rev = {
	"nes_megaman3rev", "nes_megaman3", NULL, NULL, "2019",
	"Mega Man 3 Revamped (Hack v1.1)\0", NULL, "TheSkipper1995", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_megaman3revRomInfo, nes_megaman3revRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mega Man 4 (USA) (Rev A)
static struct BurnRomInfo nes_megaman4RomDesc[] = {
	{ "Mega Man 4 (USA) (Rev A).nes",          524304, 0x9ed9d3af, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_megaman4)
STD_ROM_FN(nes_megaman4)

struct BurnDriver BurnDrvnes_megaman4 = {
	"nes_megaman4", NULL, NULL, NULL, "1992",
	"Mega Man 4 (USA) (Rev A)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_megaman4RomInfo, nes_megaman4RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mega Man 5 (USA)
static struct BurnRomInfo nes_megaman5RomDesc[] = {
	{ "Mega Man 5 (USA).nes",          524304, 0x5e023291, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_megaman5)
STD_ROM_FN(nes_megaman5)

struct BurnDriver BurnDrvnes_megaman5 = {
	"nes_megaman5", NULL, NULL, NULL, "1992",
	"Mega Man 5 (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_megaman5RomInfo, nes_megaman5RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mega Man 6 (USA)
static struct BurnRomInfo nes_megaman6RomDesc[] = {
	{ "Mega Man 6 (USA).nes",          524304, 0x1efcac48, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_megaman6)
STD_ROM_FN(nes_megaman6)

struct BurnDriver BurnDrvnes_megaman6 = {
	"nes_megaman6", NULL, NULL, NULL, "1994",
	"Mega Man 6 (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_megaman6RomInfo, nes_megaman6RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mega Man CX (USA)
static struct BurnRomInfo nes_megamancxRomDesc[] = {
	{ "Mega Man CX (USA).nes",          524304, 0x454a1ed4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_megamancx)
STD_ROM_FN(nes_megamancx)

struct BurnDriver BurnDrvnes_megamancx = {
	"nes_megamancx", NULL, NULL, NULL, "2016",
	"Mega Man CX (USA)\0", NULL, "Zenkaku Himajin", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_megamancxRomInfo, nes_megamancxRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_meikyuujimaRomDesc[] = {
	{ "Meikyuu-jima (Japan).nes",          262160, 0x93b8cfce, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_meikyuujima)
STD_ROM_FN(nes_meikyuujima)

struct BurnDriver BurnDrvnes_meikyuujima = {
	"nes_meikyuujima", NULL, NULL, NULL, "1990",
	"Meikyuu-jima (Japan)\0", NULL, "Irem", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PUZZLE | GBF_ACTION, 0,
	NESGetZipName, nes_meikyuujimaRomInfo, nes_meikyuujimaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_menacebeachRomDesc[] = {
	{ "Menace Beach (USA) (Unl).nes",          131088, 0x14985531, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_menacebeach)
STD_ROM_FN(nes_menacebeach)

struct BurnDriver BurnDrvnes_menacebeach = {
	"nes_menacebeach", NULL, NULL, NULL, "1990",
	"Menace Beach (USA) (Unl)\0", NULL, "Color Dreams", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_menacebeachRomInfo, nes_menacebeachRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_mendelpalaceRomDesc[] = {
	{ "Mendel Palace (USA).nes",          262160, 0x3894826f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mendelpalace)
STD_ROM_FN(nes_mendelpalace)

struct BurnDriver BurnDrvnes_mendelpalace = {
	"nes_mendelpalace", NULL, NULL, NULL, "1990",
	"Mendel Palace (USA)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_mendelpalaceRomInfo, nes_mendelpalaceRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_metalfighterRomDesc[] = {
	{ "Metal Fighter (Asia) (Sachen) (Unl).nes",          65552, 0x6595575e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_metalfighter)
STD_ROM_FN(nes_metalfighter)

struct BurnDriver BurnDrvnes_metalfighter = {
	"nes_metalfighter", NULL, NULL, NULL, "1989",
	"Metal Fighter (Asia) (Sachen) (Unl)\0", NULL, "Sachen - Color Dreams", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_metalfighterRomInfo, nes_metalfighterRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_metalforceRomDesc[] = {
	{ "Metal Force (Korea) (Unl).nes",          524304, 0x7e3ba9fd, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_metalforce)
STD_ROM_FN(nes_metalforce)

struct BurnDriver BurnDrvnes_metalforce = {
	"nes_metalforce", NULL, NULL, NULL, "1993",
	"Metal Force (Korea) (Unl)\0", NULL, "Open", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_metalforceRomInfo, nes_metalforceRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_metalgearRomDesc[] = {
	{ "Metal Gear (USA).nes",          131088, 0xb27de2d8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_metalgear)
STD_ROM_FN(nes_metalgear)

struct BurnDriver BurnDrvnes_metalgear = {
	"nes_metalgear", NULL, NULL, NULL, "1988",
	"Metal Gear (USA)\0", NULL, "Ultra Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_ADV, 0,
	NESGetZipName, nes_metalgearRomInfo, nes_metalgearRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Metal Max (Japan)
static struct BurnRomInfo nes_metalmaxjRomDesc[] = {
	{ "Metal Max (Japan).nes",          524304, 0x334f45bb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_metalmaxj)
STD_ROM_FN(nes_metalmaxj)

struct BurnDriver BurnDrvnes_metalmaxj = {
	"nes_metalmaxj", "nes_metalmax", NULL, NULL, "1991",
	"Metal Max (Japan)\0", NULL, "Data East", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_metalmaxjRomInfo, nes_metalmaxjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Metal Max (Hack, English)
static struct BurnRomInfo nes_metalmaxRomDesc[] = {
	{ "Metal Max (T-Eng).nes",          786448, 0x74a85272, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_metalmax)
STD_ROM_FN(nes_metalmax)

struct BurnDriver BurnDrvnes_metalmax = {
	"nes_metalmax", NULL, NULL, NULL, "2000",
	"Metal Max (Hack, English)\0", NULL, "Aeon Genesis", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_metalmaxRomInfo, nes_metalmaxRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Metal Mech - Man & Machine (USA)
static struct BurnRomInfo nes_metalmecRomDesc[] = {
	{ "Metal Mech - Man & Machine (USA).nes",          262160, 0x6884a729, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_metalmec)
STD_ROM_FN(nes_metalmec)

struct BurnDriver BurnDrvnes_metalmec = {
	"nes_metalmec", NULL, NULL, NULL, "1991",
	"Metal Mech - Man & Machine (USA)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_metalmecRomInfo, nes_metalmecRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Metal Slader Glory (Japan)
static struct BurnRomInfo nes_metalslaglojRomDesc[] = {
	{ "Metal Slader Glory (Japan).nes",          1048592, 0xc032f38f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_metalslagloj)
STD_ROM_FN(nes_metalslagloj)

struct BurnDriver BurnDrvnes_metalslagloj = {
	"nes_metalslagloj", "nes_metalslaglo", NULL, NULL, "1991",
	"Metal Slader Glory (Japan)\0", NULL, "HAL Laboratory", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_metalslaglojRomInfo, nes_metalslaglojRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Metal Slader Glory (Hack, English)
// https://www.romhacking.net/translations/3755/
static struct BurnRomInfo nes_metalslagloRomDesc[] = {
	{ "Metal Slader Glory (T-Eng).nes",          1572880, 0x13981241, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_metalslaglo)
STD_ROM_FN(nes_metalslaglo)

struct BurnDriver BurnDrvnes_metalslaglo = {
	"nes_metalslaglo", NULL, NULL, NULL, "2018",
	"Metal Slader Glory (Hack, English)\0", NULL, "Stardust Crusaders", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_metalslagloRomInfo, nes_metalslagloRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Metal Storm (USA)
static struct BurnRomInfo nes_metalstormRomDesc[] = {
	{ "Metal Storm (USA).nes",          393232, 0x98cefa51, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_metalstorm)
STD_ROM_FN(nes_metalstorm)

struct BurnDriver BurnDrvnes_metalstorm = {
	"nes_metalstorm", NULL, NULL, NULL, "1991",
	"Metal Storm (USA)\0", NULL, "Irem", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_metalstormRomInfo, nes_metalstormRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Metro-Cross (Japan)
static struct BurnRomInfo nes_metrocrossRomDesc[] = {
	{ "Metro-Cross (Japan).nes",          65552, 0x7bb329f5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_metrocross)
STD_ROM_FN(nes_metrocross)

struct BurnDriver BurnDrvnes_metrocross = {
	"nes_metrocross", NULL, NULL, NULL, "1986",
	"Metro-Cross (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_metrocrossRomInfo, nes_metrocrossRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Metroid (USA)
static struct BurnRomInfo nes_metroidRomDesc[] = {
	{ "Metroid (USA).nes",          131088, 0xa2c89cb9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_metroid)
STD_ROM_FN(nes_metroid)

struct BurnDriver BurnDrvnes_metroid = {
	"nes_metroid", NULL, NULL, NULL, "1987",
	"Metroid (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM | GBF_RUNGUN, 0,
	NESGetZipName, nes_metroidRomInfo, nes_metroidRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Michael Andretti's World Grand Prix (USA)
static struct BurnRomInfo nes_michaandsworgrprRomDesc[] = {
	{ "Michael Andretti's World Grand Prix (USA).nes",          262160, 0xbeb81a82, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_michaandsworgrpr)
STD_ROM_FN(nes_michaandsworgrpr)

struct BurnDriver BurnDrvnes_michaandsworgrpr = {
	"nes_michaandsworgrpr", NULL, NULL, NULL, "1990",
	"Michael Andretti's World Grand Prix (USA)\0", NULL, "Sammy", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_michaandsworgrprRomInfo, nes_michaandsworgrprRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mickey Mania 7 (Unl)
static struct BurnRomInfo nes_mickeymania7RomDesc[] = {
	{ "Mickey Mania 7 (Unl).nes",          524304, 0xa1460ad3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mickeymania7)
STD_ROM_FN(nes_mickeymania7)

struct BurnDriver BurnDrvnes_mickeymania7 = {
	"nes_mickeymania7", "nes_chinarabbab", NULL, NULL, "1996",
	"Mickey Mania 7 (Unl)\0", NULL, "J.Y. Company", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_mickeymania7RomInfo, nes_mickeymania7RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mickey Mouse III - Yume Fuusen (Japan)
static struct BurnRomInfo nes_mickemouiiijRomDesc[] = {
	{ "Mickey Mouse III - Yume Fuusen (Japan).nes",          262160, 0x8ad9a9be, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mickemouiiij)
STD_ROM_FN(nes_mickemouiiij)

struct BurnDriver BurnDrvnes_mickemouiiij = {
	"nes_mickemouiiij", "nes_mickemouiii", NULL, NULL, "1992",
	"Mickey Mouse III - Yume Fuusen (Japan)\0", NULL, "Kemco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_mickemouiiijRomInfo, nes_mickemouiiijRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mickey Mouse III - Yume Fuusen (Hack, English)
static struct BurnRomInfo nes_mickemouiiiRomDesc[] = {
	{ "Mickey Mouse III - Yume Fuusen (T-Eng).nes",          262160, 0x5cb55b23, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mickemouiii)
STD_ROM_FN(nes_mickemouiii)

struct BurnDriver BurnDrvnes_mickemouiii = {
	"nes_mickemouiii", NULL, NULL, NULL, "2013",
	"Mickey Mouse III - Yume Fuusen (Hack, English)\0", NULL, "NikcDC", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_mickemouiiiRomInfo, nes_mickemouiiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mickey Mousecapade (USA)
static struct BurnRomInfo nes_mickemouRomDesc[] = {
	{ "Mickey Mousecapade (USA).nes",          65552, 0x3341274d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mickemou)
STD_ROM_FN(nes_mickemou)

struct BurnDriver BurnDrvnes_mickemou = {
	"nes_mickemou", NULL, NULL, NULL, "1988",
	"Mickey Mousecapade (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_mickemouRomInfo, nes_mickemouRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Micro Machines (USA) (Unl)
static struct BurnRomInfo nes_micromachinesRomDesc[] = {
	{ "Micro Machines (USA) (Unl).nes",          262160, 0xf3fffc7a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_micromachines)
STD_ROM_FN(nes_micromachines)

struct BurnDriver BurnDrvnes_micromachines = {
	"nes_micromachines", NULL, NULL, NULL, "1992",
	"Micro Machines (USA) (Unl)\0", NULL, "Camerica", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_micromachinesRomInfo, nes_micromachinesRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// MiG 29 - Soviet Fighter (USA) (Unl)
static struct BurnRomInfo nes_mig29RomDesc[] = {
	{ "MiG 29 - Soviet Fighter (USA) (Unl).nes",          131088, 0xaf33971f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mig29)
STD_ROM_FN(nes_mig29)

struct BurnDriver BurnDrvnes_mig29 = {
	"nes_mig29", NULL, NULL, NULL, "1992",
	"MiG 29 - Soviet Fighter (USA) (Unl)\0", NULL, "Camerica", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_mig29RomInfo, nes_mig29RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mighty Bomb Jack (USA)
static struct BurnRomInfo nes_mightybombjackRomDesc[] = {
	{ "Mighty Bomb Jack (USA).nes",          65552, 0x73dd920f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mightybombjack)
STD_ROM_FN(nes_mightybombjack)

struct BurnDriver BurnDrvnes_mightybombjack = {
	"nes_mightybombjack", NULL, NULL, NULL, "1987",
	"Mighty Bomb Jack (USA)\0", NULL, "Tecmo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_mightybombjackRomInfo, nes_mightybombjackRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mighty Final Fight (USA)
static struct BurnRomInfo nes_mightfinfigRomDesc[] = {
	{ "Mighty Final Fight (USA).nes",          262160, 0x15eb0bee, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mightfinfig)
STD_ROM_FN(nes_mightfinfig)

struct BurnDriver BurnDrvnes_mightfinfig = {
	"nes_mightfinfig", NULL, NULL, NULL, "1993",
	"Mighty Final Fight (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_mightfinfigRomInfo, nes_mightfinfigRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mike Tyson's Punch-Out!! (Japan, USA) (Rev A)
static struct BurnRomInfo nes_miketysspunoutRomDesc[] = {
	{ "Mike Tyson's Punch-Out!! (Japan, USA) (Rev A).nes",          262160, 0x3df8e170, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_miketysspunout)
STD_ROM_FN(nes_miketysspunout)

struct BurnDriver BurnDrvnes_miketysspunout = {
	"nes_miketysspunout", NULL, NULL, NULL, "1987",
	"Mike Tyson's Punch-Out!! (Japan, USA) (Rev A)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_miketysspunoutRomInfo, nes_miketysspunoutRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Millipede (USA)
static struct BurnRomInfo nes_millipedeRomDesc[] = {
	{ "Millipede (USA).nes",          24592, 0xcc4f5101, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_millipede)
STD_ROM_FN(nes_millipede)

struct BurnDriver BurnDrvnes_millipede = {
	"nes_millipede", NULL, NULL, NULL, "1988",
	"Millipede (USA)\0", NULL, "HAL Laboratory", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_millipedeRomInfo, nes_millipedeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Millipede - Kyodai Konchuu no Gyakushuu (Japan)
static struct BurnRomInfo nes_milliRomDesc[] = {
	{ "Millipede - Kyodai Konchuu no Gyakushuu (Japan).nes",          24592, 0x154cac47, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_milli)
STD_ROM_FN(nes_milli)

struct BurnDriver BurnDrvnes_milli = {
	"nes_milli", "nes_millipede", NULL, NULL, "1989?",
	"Millipede - Kyodai Konchuu no Gyakushuu (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_milliRomInfo, nes_milliRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Milon's Secret Castle (USA)
static struct BurnRomInfo nes_milonsscRomDesc[] = {
	{ "Milon's Secret Castle (USA)(1987)(Hudson Soft).nes",           65552, 0x1741286b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_milonssc)
STD_ROM_FN(nes_milonssc)

struct BurnDriver BurnDrvnes_milonssc = {
	"nes_milonssc", NULL, NULL, NULL, "1987",
	"Milon's Secret Castle (USA)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_milonsscRomInfo, nes_milonsscRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Minelvaton Saga - Ragon no Fukkatsu (Japan)
static struct BurnRomInfo nes_minelsagjRomDesc[] = {
	{ "Minelvaton Saga - Ragon no Fukkatsu (Japan).nes",          262160, 0xcb2ff607, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_minelsagj)
STD_ROM_FN(nes_minelsagj)

struct BurnDriver BurnDrvnes_minelsagj = {
	"nes_minelsagj", "nes_minelsag", NULL, NULL, "1987",
	"Minelvaton Saga - Ragon no Fukkatsu (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_minelsagjRomInfo, nes_minelsagjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Minelvaton Saga - Ragon no Fukkatsu (Hack, English)
static struct BurnRomInfo nes_minelsagRomDesc[] = {
	{ "Minelvaton Saga - Ragon no Fukkatsu (T-Eng).nes",          393232, 0xa0da91d6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_minelsag)
STD_ROM_FN(nes_minelsag)

struct BurnDriver BurnDrvnes_minelsag = {
	"nes_minelsag", NULL, NULL, NULL, "2020",
	"Minelvaton Saga - Ragon no Fukkatsu (Hack, English)\0", NULL, "aishsha", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_minelsagRomInfo, nes_minelsagRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mini Putt (Japan)
static struct BurnRomInfo nes_miniputtRomDesc[] = {
	{ "Mini Putt (Japan).nes",          262160, 0x098ad414, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_miniputt)
STD_ROM_FN(nes_miniputt)

struct BurnDriver BurnDrvnes_miniputt = {
	"nes_miniputt", NULL, NULL, NULL, "1991",
	"Mini Putt (Japan)\0", NULL, "A Wave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_miniputtRomInfo, nes_miniputtRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Minna no Taabou no Nakayoshi Daisakusen (Japan)
static struct BurnRomInfo nes_minnanotaaboujRomDesc[] = {
	{ "Minna no Taabou no Nakayoshi Daisakusen (Japan).nes",          65552, 0x8c4f37e2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_minnanotaabouj)
STD_ROM_FN(nes_minnanotaabouj)

struct BurnDriver BurnDrvnes_minnanotaabouj = {
	"nes_minnanotaabouj", "nes_minnanotaabou", NULL, NULL, "1991",
	"Minna no Taabou no Nakayoshi Daisakusen (Japan)\0", NULL, "Character Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_ACTION | GBF_PUZZLE, 0,
	NESGetZipName, nes_minnanotaaboujRomInfo, nes_minnanotaaboujRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Minna no Taabou no Nakayoshi Daisakusen (Hack, English v1.01)
static struct BurnRomInfo nes_minnanotaabouRomDesc[] = {
	{ "Minna no Taabou no Nakayoshi Daisakusen (T-Eng).nes",          65552, 0x17336a80, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_minnanotaabou)
STD_ROM_FN(nes_minnanotaabou)

struct BurnDriver BurnDrvnes_minnanotaabou = {
	"nes_minnanotaabou", NULL, NULL, NULL, "2017",
	"Minna no Taabou no Nakayoshi Daisakusen (Hack, English v1.01)\0", NULL, "Suicidal Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_NES, GBF_ACTION | GBF_PUZZLE, 0,
	NESGetZipName, nes_minnanotaabouRomInfo, nes_minnanotaabouRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Miracle Ropit's - 2100 Nen no Daibouken (Japan)
static struct BurnRomInfo nes_miracropsRomDesc[] = {
	{ "Miracle Ropit's - 2100 Nen no Daibouken (Japan).nes",          131088, 0xac8ae5ef, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_miracrops)
STD_ROM_FN(nes_miracrops)

struct BurnDriver BurnDrvnes_miracrops = {
	"nes_miracrops", NULL, NULL, NULL, "1987",
	"Miracle Ropit's - 2100 Nen no Daibouken (Japan)\0", NULL, "King Records", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_miracropsRomInfo, nes_miracropsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mirai Senshi - Lios (Japan)
static struct BurnRomInfo nes_miraisenjRomDesc[] = {
	{ "Mirai Senshi - Lios (Japan).nes",          262160, 0x8ce29756, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_miraisenj)
STD_ROM_FN(nes_miraisenj)

struct BurnDriver BurnDrvnes_miraisenj = {
	"nes_miraisenj", "nes_miraisen", NULL, NULL, "1989",
	"Mirai Senshi - Lios (Japan)\0", NULL, "Pack-In-Video", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_miraisenjRomInfo, nes_miraisenjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mirai Senshi - Lios (Hack, English)
static struct BurnRomInfo nes_miraisenRomDesc[] = {
	{ "Mirai Senshi - Lios (T-Eng).nes",          262160, 0x932c263b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_miraisen)
STD_ROM_FN(nes_miraisen)

struct BurnDriver BurnDrvnes_miraisen = {
	"nes_miraisen", NULL, NULL, NULL, "2000",
	"Mirai Senshi - Lios (Hack, English)\0", NULL, "Aeon Genesis", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_miraisenRomInfo, nes_miraisenRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Miron no Daibouken (Japan)
static struct BurnRomInfo nes_milonsscjRomDesc[] = {
	{ "Miron no Daibouken (Japan)(1986)(Hudson Soft).nes",           65552, 0x712bb96f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_milonsscj)
STD_ROM_FN(nes_milonsscj)

struct BurnDriver BurnDrvnes_milonsscj = {
	"nes_milonsscj", "nes_milonssc", NULL, NULL, "1986",
	"Miron no Daibouken (Japan)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_milonsscjRomInfo, nes_milonsscjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mission Cobra (USA) (Unl)
static struct BurnRomInfo nes_missioncobraRomDesc[] = {
	{ "Mission Cobra (USA) (Unl).nes",          49168, 0x66683e28, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_missioncobra)
STD_ROM_FN(nes_missioncobra)

struct BurnDriver BurnDrvnes_missioncobra = {
	"nes_missioncobra", NULL, NULL, NULL, "1990",
	"Mission Cobra (USA) (Unl)\0", NULL, "Bunch Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_missioncobraRomInfo, nes_missioncobraRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mission Impossible (USA)
static struct BurnRomInfo nes_missiimpRomDesc[] = {
	{ "Mission Impossible (USA).nes",          262160, 0xc956b3af, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_missiimp)
STD_ROM_FN(nes_missiimp)

struct BurnDriver BurnDrvnes_missiimp = {
	"nes_missiimp", NULL, NULL, NULL, "1990",
	"Mission Impossible (USA)\0", NULL, "Ultra Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_ADV, 0,
	NESGetZipName, nes_missiimpRomInfo, nes_missiimpRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mississippi Satsujin Jiken (Japan)
static struct BurnRomInfo nes_missisatjikjRomDesc[] = {
	{ "Mississippi Satsujin Jiken (Japan).nes",          163856, 0x5d003ead, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_missisatjikj)
STD_ROM_FN(nes_missisatjikj)

struct BurnDriver BurnDrvnes_missisatjikj = {
	"nes_missisatjikj", "nes_missisatjik", NULL, NULL, "1986",
	"Mississippi Satsujin Jiken (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_missisatjikjRomInfo, nes_missisatjikjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mississippi Satsujin Jiken (Hack, English)
static struct BurnRomInfo nes_missisatjikRomDesc[] = {
	{ "Mississippi Satsujin Jiken (T-Eng).nes",          163856, 0xf698e872, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_missisatjik)
STD_ROM_FN(nes_missisatjik)

struct BurnDriver BurnDrvnes_missisatjik = {
	"nes_missisatjik", NULL, NULL, NULL, "2017",
	"Mississippi Satsujin Jiken (Hack, English)\0", NULL, "GAFF Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_missisatjikRomInfo, nes_missisatjikRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mito Koumon - Sekai Manyuu Ki (Japan)
static struct BurnRomInfo nes_mitokouRomDesc[] = {
	{ "Mito Koumon - Sekai Manyuu Ki (Japan).nes",          262160, 0x5e4a6d59, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mitokou)
STD_ROM_FN(nes_mitokou)

struct BurnDriver BurnDrvnes_mitokou = {
	"nes_mitokou", NULL, NULL, NULL, "1988",
	"Mito Koumon - Sekai Manyuu Ki (Japan)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_mitokouRomInfo, nes_mitokouRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mitsume ga Tooru (Japan)
static struct BurnRomInfo nes_mitsumegatoorujRomDesc[] = {
	{ "Mitsume ga Tooru (Japan).nes",          262160, 0xe27ec1ec, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mitsumegatooruj)
STD_ROM_FN(nes_mitsumegatooruj)

struct BurnDriver BurnDrvnes_mitsumegatooruj = {
	"nes_mitsumegatooruj", "nes_mitsumegatooru", NULL, NULL, "1989?",
	"Mitsume ga Tooru (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_mitsumegatoorujRomInfo, nes_mitsumegatoorujRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mitsume ga Tooru (Hack, English)
static struct BurnRomInfo nes_mitsumegatooruRomDesc[] = {
	{ "Mitsume ga Tooru (T-Eng).nes",          262160, 0xc5f60062, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mitsumegatooru)
STD_ROM_FN(nes_mitsumegatooru)

struct BurnDriver BurnDrvnes_mitsumegatooru = {
	"nes_mitsumegatooru", NULL, NULL, NULL, "2019",
	"Mitsume ga Tooru (Hack, English)\0", NULL, "Stardust Crusaders", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_mitsumegatooruRomInfo, nes_mitsumegatooruRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Moai-kun (Japan)
static struct BurnRomInfo nes_moaikunjRomDesc[] = {
	{ "Moai-kun (Japan).nes",          65552, 0xa3a19253, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_moaikunj)
STD_ROM_FN(nes_moaikunj)

struct BurnDriver BurnDrvnes_moaikunj = {
	"nes_moaikunj", "nes_moaikun", NULL, NULL, "1990",
	"Moai-kun (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_moaikunjRomInfo, nes_moaikunjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Moai-kun (Hack, English)
static struct BurnRomInfo nes_moaikunRomDesc[] = {
	{ "Moai-kun T-Eng (2014)(Stardust Crusaders).nes",          65552, 0x95f8b436, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_moaikun)
STD_ROM_FN(nes_moaikun)

struct BurnDriver BurnDrvnes_moaikun = {
	"nes_moaikun", NULL, NULL, NULL, "2014",
	"Moai-kun (Hack, English)\0", NULL, "Stardust Crusaders", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_moaikunRomInfo, nes_moaikunRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Moero TwinBee - Cinnamon Hakase o Sukue! (Japan)
static struct BurnRomInfo nes_moerotwiRomDesc[] = {
	{ "Moero TwinBee - Cinnamon Hakase o Sukue! (Japan).nes",          131088, 0xac0a622b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_moerotwi)
STD_ROM_FN(nes_moerotwi)

struct BurnDriver BurnDrvnes_moerotwi = {
	"nes_moerotwi", NULL, NULL, NULL, "1986",
	"Moero TwinBee - Cinnamon Hakase o Sukue! (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_moerotwiRomInfo, nes_moerotwiRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NESHori4pInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Moero!! Pro Tennis (Japan)
static struct BurnRomInfo nes_moeroprotenRomDesc[] = {
	{ "Moero!! Pro Tennis (Japan).nes",          262160, 0xf891e3e5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_moeroproten)
STD_ROM_FN(nes_moeroproten)

struct BurnDriver BurnDrvnes_moeroproten = {
	"nes_moeroproten", "nes_racketattack", NULL, NULL, "1988",
	"Moero!! Pro Tennis (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_moeroprotenRomInfo, nes_moeroprotenRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Momotarou Densetsu ~ The Peach Boy Legend (Japan)
static struct BurnRomInfo nes_mdensetsujRomDesc[] = {
	{ "Momotarou Densetsu ~ The Peach Boy Legend (J)(1987)(Hudson Soft).nes",          262160, 0xe4be2f0c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mdensetsuj)
STD_ROM_FN(nes_mdensetsuj)

struct BurnDriver BurnDrvnes_mdensetsuj = {
	"nes_mdensetsuj", "nes_mdensetsu", NULL, NULL, "1987",
	"Momotarou Densetsu ~ The Peach Boy Legend (Japan)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ACTION | GBF_RPG, 0,
	NESGetZipName, nes_mdensetsujRomInfo, nes_mdensetsujRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Momotarou Densetsu ~ The Peach Boy Legend (Hack, English)
// https://www.romhacking.net/translations/1779/
static struct BurnRomInfo nes_mdensetsuRomDesc[] = {
	{ "Momotarou Densetsu ~ The Peach Boy Legend T-Eng (2012)(KingMike).nes",          524304, 0x9d3fa8a5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mdensetsu)
STD_ROM_FN(nes_mdensetsu)

struct BurnDriver BurnDrvnes_mdensetsu = {
	"nes_mdensetsu", NULL, NULL, NULL, "2012",
	"Momotarou Densetsu ~ The Peach Boy Legend (Hack, English)\0", NULL, "KingMike's Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_ACTION | GBF_RPG, 0,
	NESGetZipName, nes_mdensetsuRomInfo, nes_mdensetsuRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Monopoly (USA)
static struct BurnRomInfo nes_monopolyRomDesc[] = {
	{ "Monopoly (USA).nes",          262160, 0xfaf48d27, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_monopoly)
STD_ROM_FN(nes_monopoly)

struct BurnDriver BurnDrvnes_monopoly = {
	"nes_monopoly", NULL, NULL, NULL, "1991",
	"Monopoly (USA)\0", NULL, "Parker Brothers", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 8, HARDWARE_NES, GBF_BOARD, 0,
	NESGetZipName, nes_monopolyRomInfo, nes_monopolyRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Monster in My Pocket (USA)
static struct BurnRomInfo nes_monstinmypocRomDesc[] = {
	{ "Monster in My Pocket (USA).nes",          262160, 0xcfd1eb5d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_monstinmypoc)
STD_ROM_FN(nes_monstinmypoc)

struct BurnDriver BurnDrvnes_monstinmypoc = {
	"nes_monstinmypoc", NULL, NULL, NULL, "1992",
	"Monster in My Pocket (USA)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM | GBF_SCRFIGHT, 0,
	NESGetZipName, nes_monstinmypocRomInfo, nes_monstinmypocRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Monster Party (USA)
static struct BurnRomInfo nes_monsterpartyRomDesc[] = {
	{ "Monster Party (USA).nes",          262160, 0x6f0ac6ec, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_monsterparty)
STD_ROM_FN(nes_monsterparty)

struct BurnDriver BurnDrvnes_monsterparty = {
	"nes_monsterparty", NULL, NULL, NULL, "1989",
	"Monster Party (USA)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_monsterpartyRomInfo, nes_monsterpartyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Monster Truck Rally (USA)
static struct BurnRomInfo nes_monsttruralRomDesc[] = {
	{ "Monster Truck Rally (USA).nes",          65552, 0x60429651, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_monsttrural)
STD_ROM_FN(nes_monsttrural)

struct BurnDriver BurnDrvnes_monsttrural = {
	"nes_monsttrural", NULL, NULL, NULL, "1991",
	"Monster Truck Rally (USA)\0", NULL, "INTV", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_monsttruralRomInfo, nes_monsttruralRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Moon Crystal (Japan)
static struct BurnRomInfo nes_mooncrystaljRomDesc[] = {
	{ "Moon Crystal (Japan).nes",          524304, 0x463d5c4c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mooncrystalj)
STD_ROM_FN(nes_mooncrystalj)

struct BurnDriver BurnDrvnes_mooncrystalj = {
	"nes_mooncrystalj", "nes_mooncrystal", NULL, NULL, "1992",
	"Moon Crystal (Japan)\0", NULL, "Hector", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_mooncrystaljRomInfo, nes_mooncrystaljRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Moon Crystal (Hack, English)
static struct BurnRomInfo nes_mooncrystalRomDesc[] = {
	{ "Moon Crystal (T-eng).nes",          524304, 0xe05b0f24, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mooncrystal)
STD_ROM_FN(nes_mooncrystal)

struct BurnDriver BurnDrvnes_mooncrystal = {
	"nes_mooncrystal", NULL, NULL, NULL, "2000",
	"Moon Crystal (Hack, English)\0", NULL, "Alex W. Jackson", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_mooncrystalRomInfo, nes_mooncrystalRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Moon Ranger (USA) (Unl)
static struct BurnRomInfo nes_moonrangerRomDesc[] = {
	{ "Moon Ranger (USA) (Unl).nes",          131088, 0x22172117, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_moonranger)
STD_ROM_FN(nes_moonranger)

struct BurnDriver BurnDrvnes_moonranger = {
	"nes_moonranger", NULL, NULL, NULL, "1990",
	"Moon Ranger (USA) (Unl)\0", NULL, "Bunch Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_moonrangerRomInfo, nes_moonrangerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mortal Kombat 3 - Special 56 Peoples (Unl)
static struct BurnRomInfo nes_mortakom3RomDesc[] = {
	{ "Mortal Kombat 3 - Special 56 Peoples (Unl).nes",          655376, 0x0ba8e82e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mortakom3)
STD_ROM_FN(nes_mortakom3)

struct BurnDriver BurnDrvnes_mortakom3 = {
	"nes_mortakom3", "nes_mortakomiispe", NULL, NULL, "1995",
	"Mortal Kombat 3 - Special 56 Peoples (Unl)\0", NULL, "J.Y. Company", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_mortakom3RomInfo, nes_mortakom3RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mortal Kombat 4 (Hack, UMK3)
static struct BurnRomInfo nes_mortalkombat4hRomDesc[] = {
	{ "Mortal Kombat 4 (Hack, UMK3).nes",          2097168, 0xeecfb699, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mortalkombat4h)
STD_ROM_FN(nes_mortalkombat4h)

struct BurnDriver BurnDrvnes_mortalkombat4h = {
	"nes_mortalkombat4h", "nes_mortalkombat4", NULL, NULL, "200?",
	"Mortal Kombat 4 (Hack, UMK3)\0", NULL, "Ka Sheng", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_mortalkombat4hRomInfo, nes_mortalkombat4hRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mortal Kombat 4 (Unl)
static struct BurnRomInfo nes_mortalkombat4RomDesc[] = {
	{ "Mortal Kombat 4 (Unl).nes",          262160, 0x89001958, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mortalkombat4)
STD_ROM_FN(nes_mortalkombat4)

struct BurnDriver BurnDrvnes_mortalkombat4 = {
	"nes_mortalkombat4", NULL, NULL, NULL, "200?",
	"Mortal Kombat 4 (Unl)\0", NULL, "ABAB Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_mortalkombat4RomInfo, nes_mortalkombat4RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mortal Kombat II Special (Unl)
static struct BurnRomInfo nes_mortakomiispeRomDesc[] = {
	{ "Mortal Kombat II Special (Unl).nes",          655376, 0x99d81100, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mortakomiispe)
STD_ROM_FN(nes_mortakomiispe)

struct BurnDriver BurnDrvnes_mortakomiispe = {
	"nes_mortakomiispe", NULL, NULL, NULL, "1995",
	"Mortal Kombat II Special (Unl)\0", NULL, "J.Y. Company", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_mortakomiispeRomInfo, nes_mortakomiispeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mortal Kombat III Special (Unl)
static struct BurnRomInfo nes_mortakomiiispeRomDesc[] = {
	{ "Mortal Kombat III Special (Unl).nes",          655376, 0x17937518, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mortakomiiispe)
STD_ROM_FN(nes_mortakomiiispe)

struct BurnDriver BurnDrvnes_mortakomiiispe = {
	"nes_mortakomiiispe", "nes_mortakomiispe", NULL, NULL, "1995",
	"Mortal Kombat III Special (Unl)\0", NULL, "J.Y. Company", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_mortakomiiispeRomInfo, nes_mortakomiiispeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mother (Japan)
static struct BurnRomInfo nes_motherRomDesc[] = {
	{ "Mother (Japan).nes",          393232, 0x282a5caa, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mother)
STD_ROM_FN(nes_mother)

struct BurnDriver BurnDrvnes_mother = {
	"nes_mother", "nes_earthbound", NULL, NULL, "1989",
	"Mother (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_motherRomInfo, nes_motherRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mother - 25th Anniversay Edition (Hack, v1.11)
static struct BurnRomInfo nes_mothe25tannediRomDesc[] = {
	{ "Mother - 25th Anniversay Edition (Hack).nes",          524304, 0x6e24f190, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mothe25tannedi)
STD_ROM_FN(nes_mothe25tannedi)

struct BurnDriver BurnDrvnes_mothe25tannedi = {
	"nes_mothe25tannedi", "nes_earthbound", NULL, NULL, "2014",
	"Mother - 25th Anniversay Edition (Hack, v1.11)\0", NULL, "DragonDePlatino", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_mothe25tannediRomInfo, nes_mothe25tannediRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Motocross Champion (Japan)
static struct BurnRomInfo nes_motocchajRomDesc[] = {
	{ "Motocross Champion (Japan).nes",          262160, 0x8b7a23b0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_motocchaj)
STD_ROM_FN(nes_motocchaj)

struct BurnDriver BurnDrvnes_motocchaj = {
	"nes_motocchaj", "nes_motoccha", NULL, NULL, "1989",
	"Motocross Champion (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_motocchajRomInfo, nes_motocchajRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Motocross Champion (Hack, English)
static struct BurnRomInfo nes_motocchaRomDesc[] = {
	{ "Motocross Champion (T-eng).nes",          262160, 0xc252e03a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_motoccha)
STD_ROM_FN(nes_motoccha)

struct BurnDriver BurnDrvnes_motoccha = {
	"nes_motoccha", NULL, NULL, NULL, "2001",
	"Motocross Champion (Hack, English)\0", NULL, "Suicidal Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_motocchaRomInfo, nes_motocchaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Motor City Patrol (USA)
static struct BurnRomInfo nes_motorcitpatRomDesc[] = {
	{ "Motor City Patrol (USA).nes",          262160, 0x67ba0793, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_motorcitpat)
STD_ROM_FN(nes_motorcitpat)

struct BurnDriver BurnDrvnes_motorcitpat = {
	"nes_motorcitpat", NULL, NULL, NULL, "1992",
	"Motor City Patrol (USA)\0", NULL, "Matchbox", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RACING | GBF_ADV, 0,
	NESGetZipName, nes_motorcitpatRomInfo, nes_motorcitpatRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mottomo Abunai Deka (Japan)
static struct BurnRomInfo nes_mottoabudekRomDesc[] = {
	{ "Mottomo Abunai Deka (Japan).nes",          131088, 0x3b646a29, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mottoabudek)
STD_ROM_FN(nes_mottoabudek)

struct BurnDriver BurnDrvnes_mottoabudek = {
	"nes_mottoabudek", NULL, NULL, NULL, "1990",
	"Mottomo Abunai Deka (Japan)\0", NULL, "Toei Animation", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_mottoabudekRomInfo, nes_mottoabudekRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mouryou Senki Madara (Japan)
static struct BurnRomInfo nes_mourysenmadjRomDesc[] = {
	{ "Mouryou Senki Madara (Japan).nes",          524304, 0x4a6dd7c7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mourysenmadj)
STD_ROM_FN(nes_mourysenmadj)

struct BurnDriver BurnDrvnes_mourysenmadj = {
	"nes_mourysenmadj", "nes_mourysenmad", NULL, NULL, "1990",
	"Mouryou Senki Madara (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_mourysenmadjRomInfo, nes_mourysenmadjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mouryou Senki Madara (Hack, English)
static struct BurnRomInfo nes_mourysenmadRomDesc[] = {
	{ "Mouryou Senki Madara (T-eng).nes",          524304, 0xd9dcee07, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mourysenmad)
STD_ROM_FN(nes_mourysenmad)

struct BurnDriver BurnDrvnes_mourysenmad = {
	"nes_mourysenmad", NULL, NULL, NULL, "2016",
	"Mouryou Senki Madara (Hack, English)\0", NULL, "Aeon Genesis", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_mourysenmadRomInfo, nes_mourysenmadRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mr. Gimmick (Euro)
static struct BurnRomInfo nes_mrgimmickRomDesc[] = {
	{ "Mr. Gimmick (Europe).nes",          393232, 0xbf80b241, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mrgimmick)
STD_ROM_FN(nes_mrgimmick)

struct BurnDriver BurnDrvnes_mrgimmick = {
	"nes_mrgimmick", "nes_gimmick", NULL, NULL, "1993",
	"Mr. Gimmick (Euro)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_mrgimmickRomInfo, nes_mrgimmickRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL, SCREEN_WIDTH, SCREEN_HEIGHT_PAL
};

// Ms. Pac-Man (USA) (Namco)
static struct BurnRomInfo nes_mspacmanuRomDesc[] = {
	{ "Ms. Pac-Man (USA)(1993)(Namco).nes",          40976, 0x51a0c9de, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mspacmanu)
STD_ROM_FN(nes_mspacmanu)

struct BurnDriver BurnDrvnes_mspacmanu = {
	"nes_mspacmanu", "nes_mspacman", NULL, NULL, "1993",
	"Ms. Pac-Man (USA) (Namco)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_ACTION | GBF_MAZE, 0,
	NESGetZipName, nes_mspacmanuRomInfo, nes_mspacmanuRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ms. Pac-Man (USA) (Tengen)
static struct BurnRomInfo nes_mspacmanRomDesc[] = {
	{ "Ms. Pac-Man (USA)(1990)(Tengen).nes",          40976, 0xbd0e29b3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mspacman)
STD_ROM_FN(nes_mspacman)

struct BurnDriver BurnDrvnes_mspacman = {
	"nes_mspacman", NULL, NULL, NULL, "1990",
	"Ms. Pac-Man (USA) (Tengen)\0", NULL, "Tengen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION | GBF_MAZE, 0,
	NESGetZipName, nes_mspacmanRomInfo, nes_mspacmanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Muppet Adventure - Chaos at the Carnival (USA)
static struct BurnRomInfo nes_muppeadvRomDesc[] = {
	{ "Muppet Adventure - Chaos at the Carnival (USA).nes",          131088, 0xa3965fe4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_muppeadv)
STD_ROM_FN(nes_muppeadv)

struct BurnDriver BurnDrvnes_muppeadv = {
	"nes_muppeadv", NULL, NULL, NULL, "1990",
	"Muppet Adventure - Chaos at the Carnival (USA)\0", NULL, "Hi Tech Expressions", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_MINIGAMES, 0,
	NESGetZipName, nes_muppeadvRomInfo, nes_muppeadvRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Musashi no Ken - Tadaima Shugyou Chuu (Japan)
static struct BurnRomInfo nes_musasnokenjRomDesc[] = {
	{ "Musashi no Ken - Tadaima Shugyou Chuu (Japan).nes",          65552, 0xd21ff7d9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_musasnokenj)
STD_ROM_FN(nes_musasnokenj)

struct BurnDriver BurnDrvnes_musasnokenj = {
	"nes_musasnokenj", "nes_musasnoken", NULL, NULL, "1986",
	"Musashi no Ken - Tadaima Shugyou Chuu (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_PLATFORM | GBF_SCRFIGHT, 0,
	NESGetZipName, nes_musasnokenjRomInfo, nes_musasnokenjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Musashi no Ken - Tadaima Shugyou Chuu (Hack, English)
// https://www.romhacking.net/translations/2492/
static struct BurnRomInfo nes_musasnokenRomDesc[] = {
	{ "Musashi no Ken - Tadaima Shugyou Chuu T-Eng (2015)(GAFF Translations).nes",          65552, 0xf1f07c0e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_musasnoken)
STD_ROM_FN(nes_musasnoken)

struct BurnDriver BurnDrvnes_musasnoken = {
	"nes_musasnoken", NULL, NULL, NULL, "2015",
	"Musashi no Ken - Tadaima Shugyou Chuu (Hack, English)\0", NULL, "GAFF Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM | GBF_SCRFIGHT, 0,
	NESGetZipName, nes_musasnokenRomInfo, nes_musasnokenRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mutant Virus, The (USA)
static struct BurnRomInfo nes_mutanvirRomDesc[] = {
	{ "Mutant Virus, The (USA).nes",          262160, 0x10786d36, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mutanvir)
STD_ROM_FN(nes_mutanvir)

struct BurnDriver BurnDrvnes_mutanvir = {
	"nes_mutanvir", NULL, NULL, NULL, "1992",
	"Mutant Virus, The (USA)\0", NULL, "American Softworks", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_mutanvirRomInfo, nes_mutanvirRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mystery Quest (USA)
static struct BurnRomInfo nes_mysteryquestRomDesc[] = {
	{ "Mystery Quest (USA).nes",          65552, 0xfaf994be, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mysteryquest)
STD_ROM_FN(nes_mysteryquest)

struct BurnDriver BurnDrvnes_mysteryquest = {
	"nes_mysteryquest", NULL, NULL, NULL, "1989",
	"Mystery Quest (USA)\0", NULL, "Taxan", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_mysteryquestRomInfo, nes_mysteryquestRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Namco Classic (Japan)
static struct BurnRomInfo nes_namcoclassicRomDesc[] = {
	{ "Namco Classic (Japan).nes",          524304, 0x6b7015f3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_namcoclassic)
STD_ROM_FN(nes_namcoclassic)

struct BurnDriver BurnDrvnes_namcoclassic = {
	"nes_namcoclassic", NULL, NULL, NULL, "1988",
	"Namco Classic (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_namcoclassicRomInfo, nes_namcoclassicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Namco Classic II (Japan)
static struct BurnRomInfo nes_namcoclassiciiRomDesc[] = {
	{ "Namco Classic II (Japan).nes",          524304, 0x4f630a61, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_namcoclassicii)
STD_ROM_FN(nes_namcoclassicii)

struct BurnDriver BurnDrvnes_namcoclassicii = {
	"nes_namcoclassicii", NULL, NULL, NULL, "1992",
	"Namco Classic II (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_namcoclassiciiRomInfo, nes_namcoclassiciiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Nantettatte!! Baseball (Japan)
static struct BurnRomInfo nes_nantebasjRomDesc[] = {
	{ "Nantettatte!! Baseball (Japan).nes",          262160, 0xb7e04c4f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_nantebasj)
STD_ROM_FN(nes_nantebasj)

struct BurnDriver BurnDrvnes_nantebasj = {
	"nes_nantebasj", "nes_nantebas", NULL, NULL, "1990",
	"Nantettatte!! Baseball (Japan)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_nantebasjRomInfo, nes_nantebasjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Nantettatte!! Baseball (Hack, English)
static struct BurnRomInfo nes_nantebasRomDesc[] = {
	{ "Nantettatte!! Baseball (T-eng).nes",          262160, 0x294713b4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_nantebas)
STD_ROM_FN(nes_nantebas)

struct BurnDriver BurnDrvnes_nantebas = {
	"nes_nantebas", NULL, NULL, NULL, "2019",
	"Nantettatte!! Baseball (Hack, English)\0", NULL, "pacnsacdave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_nantebasRomInfo, nes_nantebasRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Napoleon Senki (Japan)
static struct BurnRomInfo nes_napoleonsenkiRomDesc[] = {
	{ "Napoleon Senki (Japan).nes",          163856, 0x9fea33c2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_napoleonsenki)
STD_ROM_FN(nes_napoleonsenki)

struct BurnDriver BurnDrvnes_napoleonsenki = {
	"nes_napoleonsenki", NULL, NULL, NULL, "1988",
	"Napoleon Senki (Japan)\0", NULL, "Irem", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_napoleonsenkiRomInfo, nes_napoleonsenkiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// NARC (USA)
static struct BurnRomInfo nes_narcRomDesc[] = {
	{ "NARC (USA).nes",          131088, 0xf5985a75, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_narc)
STD_ROM_FN(nes_narc)

struct BurnDriver BurnDrvnes_narc = {
	"nes_narc", NULL, NULL, NULL, "1990",
	"NARC (USA)\0", NULL, "Acclaim", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_narcRomInfo, nes_narcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Nekketsu Kakutou Densetsu (Japan)
static struct BurnRomInfo nes_nekkekakdenjRomDesc[] = {
	{ "Nekketsu Kakutou Densetsu (Japan).nes",          262160, 0x10859c6b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_nekkekakdenj)
STD_ROM_FN(nes_nekkekakdenj)

struct BurnDriver BurnDrvnes_nekkekakdenj = {
	"nes_nekkekakdenj", "nes_nekkekakden", NULL, NULL, "1992",
	"Nekketsu Kakutou Densetsu (Japan)\0", NULL, "Technos", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 4, HARDWARE_NES, GBF_VSFIGHT | GBF_ADV, 0,
	NESGetZipName, nes_nekkekakdenjRomInfo, nes_nekkekakdenjRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NESHori4pInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Nekketsu Kakutou Densetsu (Hack, English)
static struct BurnRomInfo nes_nekkekakdenRomDesc[] = {
	{ "Nekketsu Kakutou Densetsu (T-eng).nes",          262160, 0x23d650f2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_nekkekakden)
STD_ROM_FN(nes_nekkekakden)

struct BurnDriver BurnDrvnes_nekkekakden = {
	"nes_nekkekakden", NULL, NULL, NULL, "1998",
	"Nekketsu Kakutou Densetsu (Hack, English)\0", NULL, "oRdErEDchaos", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 4, HARDWARE_NES, GBF_VSFIGHT | GBF_ADV, 0,
	NESGetZipName, nes_nekkekakdenRomInfo, nes_nekkekakdenRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NESHori4pInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Nekketsu Kouha Kunio-kun (Japan)
static struct BurnRomInfo nes_nekkekoukunkunRomDesc[] = {
	{ "Nekketsu Kouha Kunio-kun (Japan).nes",          131088, 0x94dab06a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_nekkekoukunkun)
STD_ROM_FN(nes_nekkekoukunkun)

struct BurnDriver BurnDrvnes_nekkekoukunkun = {
	"nes_nekkekoukunkun", NULL, NULL, NULL, "1987",
	"Nekketsu Kouha Kunio-kun (Japan)\0", NULL, "Technos", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_nekkekoukunkunRomInfo, nes_nekkekoukunkunRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Nekketsu! Street Basket - Ganbare Dunk Heroes (Japan)
static struct BurnRomInfo nes_nekkestrbasRomDesc[] = {
	{ "Nekketsu! Street Basket - Ganbare Dunk Heroes (Japan).nes",          262160, 0xa2952508, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_nekkestrbas)
STD_ROM_FN(nes_nekkestrbas)

struct BurnDriver BurnDrvnes_nekkestrbas = {
	"nes_nekkestrbas", NULL, NULL, NULL, "1993",
	"Nekketsu! Street Basket - Ganbare Dunk Heroes (Japan)\0", NULL, "Technos", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_nekkestrbasRomInfo, nes_nekkestrbasRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// NES Open Tournament Golf (USA)
static struct BurnRomInfo nes_nesopetougolRomDesc[] = {
	{ "NES Open Tournament Golf (USA).nes",          262160, 0x9316bf4b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_nesopetougol)
STD_ROM_FN(nes_nesopetougol)

struct BurnDriver BurnDrvnes_nesopetougol = {
	"nes_nesopetougol", NULL, NULL, NULL, "1991",
	"NES Open Tournament Golf (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_nesopetougolRomInfo, nes_nesopetougolRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// New Ghostbusters II (Japan)
static struct BurnRomInfo nes_newghoiiRomDesc[] = {
	{ "New Ghostbusters II (Japan).nes",          262160, 0x34829f2f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_newghoii)
STD_ROM_FN(nes_newghoii)

struct BurnDriver BurnDrvnes_newghoii = {
	"nes_newghoii", NULL, NULL, NULL, "1990",
	"New Ghostbusters II (Japan)\0", NULL, "HAL Laboratory", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_newghoiiRomInfo, nes_newghoiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// New York Nyankies (Japan)
static struct BurnRomInfo nes_newyornyaRomDesc[] = {
	{ "New York Nyankies (Japan).nes",          262160, 0x07503930, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_newyornya)
STD_ROM_FN(nes_newyornya)

struct BurnDriver BurnDrvnes_newyornya = {
	"nes_newyornya", "nes_rockinkats", NULL, NULL, "1991",
	"New York Nyankies (Japan)\0", NULL, "Atlus", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_newyornyaRomInfo, nes_newyornyaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// New Zealand Story, The (Euro)
static struct BurnRomInfo nes_newzeastoRomDesc[] = {
	{ "New Zealand Story, The (Europe).nes",          262160, 0x4cf8ed7e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_newzeasto)
STD_ROM_FN(nes_newzeasto)

struct BurnDriver BurnDrvnes_newzeasto = {
	"nes_newzeasto", "nes_kiwikra", NULL, NULL, "1991",
	"New Zealand Story, The (Euro)\0", NULL, "Ocean", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_newzeastoRomInfo, nes_newzeastoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL, SCREEN_WIDTH, SCREEN_HEIGHT_PAL
};

// Nigel Mansell's World Championship Challenge (USA)
static struct BurnRomInfo nes_nigelmansworchchRomDesc[] = {
	{ "Nigel Mansell's World Championship Challenge (USA).nes",          262160, 0x2ae2867f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_nigelmansworchch)
STD_ROM_FN(nes_nigelmansworchch)

struct BurnDriver BurnDrvnes_nigelmansworchch = {
	"nes_nigelmansworchch", NULL, NULL, NULL, "1993",
	"Nigel Mansell's World Championship Challenge (USA)\0", NULL, "GameTek", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_nigelmansworchchRomInfo, nes_nigelmansworchchRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Nightmare on Elm Street, A (USA)
static struct BurnRomInfo nes_nightonelmstraRomDesc[] = {
	{ "Nightmare on Elm Street, A (USA).nes",          131088, 0x2a83ddc5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_nightonelmstra)
STD_ROM_FN(nes_nightonelmstra)

struct BurnDriver BurnDrvnes_nightonelmstra = {
	"nes_nightonelmstra", NULL, NULL, NULL, "1990",
	"Nightmare on Elm Street, A (USA)\0", NULL, "Ljn", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_nightonelmstraRomInfo, nes_nightonelmstraRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Nightshade (USA)
static struct BurnRomInfo nes_nightshadeRomDesc[] = {
	{ "Nightshade (USA).nes",          524304, 0xc6d266af, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_nightshade)
STD_ROM_FN(nes_nightshade)

struct BurnDriver BurnDrvnes_nightshade = {
	"nes_nightshade", NULL, NULL, NULL, "1992",
	"Nightshade (USA)\0", NULL, "Ultra Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_nightshadeRomInfo, nes_nightshadeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_ninjacopsaizouRomDesc[] = {
	{ "Ninja Cop Saizou (Japan).nes",          262160, 0xf3c45f8b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ninjacopsaizou)
STD_ROM_FN(nes_ninjacopsaizou)

struct BurnDriver BurnDrvnes_ninjacopsaizou = {
	"nes_ninjacopsaizou", NULL, NULL, NULL, "1989",
	"Ninja Cop Saizou (Japan)\0", NULL, "Kyugo Boueki", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_ninjacopsaizouRomInfo, nes_ninjacopsaizouRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_ninjacrusadersRomDesc[] = {
	{ "Ninja Crusaders (USA).nes",          131088, 0xdc84deb0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ninjacrusaders)
STD_ROM_FN(nes_ninjacrusaders)

struct BurnDriver BurnDrvnes_ninjacrusaders = {
	"nes_ninjacrusaders", NULL, NULL, NULL, "1990",
	"Ninja Crusaders (USA)\0", NULL, "Sammy", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_ninjacrusadersRomInfo, nes_ninjacrusadersRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_ninjagaidenRomDesc[] = {
	{ "Ninja Gaiden (USA).nes",          262160, 0x11f953f6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ninjagaiden)
STD_ROM_FN(nes_ninjagaiden)

struct BurnDriver BurnDrvnes_ninjagaiden = {
	"nes_ninjagaiden", NULL, NULL, NULL, "1989",
	"Ninja Gaiden (USA)\0", NULL, "Tecmo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, nes_ninjagaidenRomInfo, nes_ninjagaidenRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_ninjagaiiiRomDesc[] = {
	{ "Ninja Gaiden II - The Dark Sword of Chaos (USA).nes",          262160, 0x9d135a8e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ninjagaiii)
STD_ROM_FN(nes_ninjagaiii)

struct BurnDriver BurnDrvnes_ninjagaiii = {
	"nes_ninjagaiii", NULL, NULL, NULL, "1990",
	"Ninja Gaiden II - The Dark Sword of Chaos (USA)\0", NULL, "Tecmo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, nes_ninjagaiiiRomInfo, nes_ninjagaiiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_ninjagaiiiiRomDesc[] = {
	{ "Ninja Gaiden III - The Ancient Ship of Doom (USA).nes",          262160, 0xbabd39fa, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ninjagaiiii)
STD_ROM_FN(nes_ninjagaiiii)

struct BurnDriver BurnDrvnes_ninjagaiiii = {
	"nes_ninjagaiiii", NULL, NULL, NULL, "1991",
	"Ninja Gaiden III - The Ancient Ship of Doom (USA)\0", NULL, "Tecmo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, nes_ninjagaiiiiRomInfo, nes_ninjagaiiiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_ninjahatkunRomDesc[] = {
	{ "Ninja Hattori-kun - Ninja wa Syugyou de Gozaru (Japan).nes",          40976, 0x7083154c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ninjahatkun)
STD_ROM_FN(nes_ninjahatkun)

struct BurnDriver BurnDrvnes_ninjahatkun = {
	"nes_ninjahatkun", NULL, NULL, NULL, "1986",
	"Ninja Hattori-kun - Ninja wa Syugyou de Gozaru (Japan)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_ninjahatkunRomInfo, nes_ninjahatkunRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ninja Jajamaru - Ginga Daisakusen (Japan)
static struct BurnRomInfo nes_ninjajajjRomDesc[] = {
	{ "Ninja Jajamaru - Ginga Daisakusen (Japan).nes",          262160, 0x7934c198, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ninjajajj)
STD_ROM_FN(nes_ninjajajj)

struct BurnDriver BurnDrvnes_ninjajajj = {
	"nes_ninjajajj", "nes_ninjajaj", NULL, NULL, "1991",
	"Ninja Jajamaru - Ginga Daisakusen (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_ninjajajjRomInfo, nes_ninjajajjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ninja Jajamaru - Ginga Daisakusen (Hack, English)
static struct BurnRomInfo nes_ninjajajeRomDesc[] = {
	{ "Ninja Jajamaru - Ginga Daisakusen (T-eng).nes",          262160, 0x89ee0ed9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ninjajaje)
STD_ROM_FN(nes_ninjajaje)

struct BurnDriver BurnDrvnes_ninjajaje = {
	"nes_ninjajaje", "nes_ninjajaj", NULL, NULL, "2002",
	"Ninja Jajamaru - Ginga Daisakusen (Hack, English)\0", NULL, "HTI", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_ninjajajeRomInfo, nes_ninjajajeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ninja JaJaMaru - Operation Milky Way (English)
static struct BurnRomInfo nes_ninjajajRomDesc[] = {
	{ "Ninja JaJaMaru - Operation Milky Way T-Eng (1991-2023)(Jaleco).nes",          262160, 0xf438e54a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ninjajaj)
STD_ROM_FN(nes_ninjajaj)

struct BurnDriver BurnDrvnes_ninjajaj = {
	"nes_ninjajaj", NULL, NULL, NULL, "2023",
	"Ninja JaJaMaru - Operation Milky Way (English)\0", "Official Translation", "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_ninjajajRomInfo, nes_ninjajajRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ninja Jajamaru-kun (Japan)
static struct BurnRomInfo nes_ninjajajkunjRomDesc[] = {
	{ "Ninja Jajamaru-kun (Japan).nes",          32784, 0x95e02519, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ninjajajkunj)
STD_ROM_FN(nes_ninjajajkunj)

struct BurnDriver BurnDrvnes_ninjajajkunj = {
	"nes_ninjajajkunj", "nes_ninjajajkun", NULL, NULL, "1985",
	"Ninja Jajamaru-kun (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_ninjajajkunjRomInfo, nes_ninjajajkunjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ninja Jajamaru-kun (English)
static struct BurnRomInfo nes_ninjajajkunRomDesc[] = {
	{ "Ninja JaJaMaru-Kun T-Eng (1985-2023)(Jaleco).nes",          32784, 0x5f595395, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ninjajajkun)
STD_ROM_FN(nes_ninjajajkun)

struct BurnDriver BurnDrvnes_ninjajajkun = {
	"nes_ninjajajkun", NULL, NULL, NULL, "2023",
	"Ninja Jajamaru-kun (English)\0", "Official Translation", "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_ninjajajkunRomInfo, nes_ninjajajkunRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ninja Kid (USA)
static struct BurnRomInfo nes_ninjakidRomDesc[] = {
	{ "Ninja Kid (USA).nes",          65552, 0x4de7236f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ninjakid)
STD_ROM_FN(nes_ninjakid)

struct BurnDriver BurnDrvnes_ninjakid = {
	"nes_ninjakid", NULL, NULL, NULL, "1986",
	"Ninja Kid (USA)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_ninjakidRomInfo, nes_ninjakidRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ninja Ryuuken Den (Japan)
static struct BurnRomInfo nes_ninjaryudenRomDesc[] = {
	{ "Ninja Ryuuken Den (Japan).nes",          262160, 0xba7818a1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ninjaryuden)
STD_ROM_FN(nes_ninjaryuden)

struct BurnDriver BurnDrvnes_ninjaryuden = {
	"nes_ninjaryuden", "nes_ninjagaiden", NULL, NULL, "1988",
	"Ninja Ryuuken Den (Japan)\0", NULL, "Tecmo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_ninjaryudenRomInfo, nes_ninjaryudenRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ninja Ryuuken Den II - Ankoku no Jashin Ken (Japan)
static struct BurnRomInfo nes_ninjaryudeniiRomDesc[] = {
	{ "Ninja Ryuuken Den II - Ankoku no Jashin Ken (Japan).nes",          262160, 0x92b6e224, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ninjaryudenii)
STD_ROM_FN(nes_ninjaryudenii)

struct BurnDriver BurnDrvnes_ninjaryudenii = {
	"nes_ninjaryudenii", "nes_ninjagaiii", NULL, NULL, "1990",
	"Ninja Ryuuken Den II - Ankoku no Jashin Ken (Japan)\0", NULL, "Tecmo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_ninjaryudeniiRomInfo, nes_ninjaryudeniiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ninja Ryuuken Den III - Yomi no Hakobune (Japan)
static struct BurnRomInfo nes_ninjaryudeniiiRomDesc[] = {
	{ "Ninja Ryuuken Den III - Yomi no Hakobune (Japan).nes",          262160, 0x05bd3865, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ninjaryudeniii)
STD_ROM_FN(nes_ninjaryudeniii)

struct BurnDriver BurnDrvnes_ninjaryudeniii = {
	"nes_ninjaryudeniii", "nes_ninjagaiiii", NULL, NULL, "1991",
	"Ninja Ryuuken Den III - Yomi no Hakobune (Japan)\0", NULL, "Tecmo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, nes_ninjaryudeniiiRomInfo, nes_ninjaryudeniiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ninja-kun - Ashura no Shou (Japan)
static struct BurnRomInfo nes_ninjakunashnoshRomDesc[] = {
	{ "Ninja-kun - Ashura no Shou (Japan).nes",          131088, 0xeb195015, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ninjakunashnosh)
STD_ROM_FN(nes_ninjakunashnosh)

struct BurnDriver BurnDrvnes_ninjakunashnosh = {
	"nes_ninjakunashnosh", NULL, NULL, NULL, "1988",
	"Ninja-kun - Ashura no Shou (Japan)\0", NULL, "UPL", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_ninjakunashnoshRomInfo, nes_ninjakunashnoshRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ninja-kun - Majou no Bouken (Japan) (Rev 1)
static struct BurnRomInfo nes_ninjakunmajnoboRomDesc[] = {
	{ "Ninja-kun - Majou no Bouken (Japan) (Rev 1).nes",          24592, 0x5ab65ca5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ninjakunmajnobo)
STD_ROM_FN(nes_ninjakunmajnobo)

struct BurnDriver BurnDrvnes_ninjakunmajnobo = {
	"nes_ninjakunmajnobo", NULL, NULL, NULL, "1985",
	"Ninja-kun - Majou no Bouken (Japan) (Rev 1)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_ninjakunmajnoboRomInfo, nes_ninjakunmajnoboRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ninjara Hoi! (Japan)
static struct BurnRomInfo nes_ninjarahoijRomDesc[] = {
	{ "Ninjara Hoi! (Japan).nes",          524304, 0xaea19f21, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ninjarahoij)
STD_ROM_FN(nes_ninjarahoij)

struct BurnDriver BurnDrvnes_ninjarahoij = {
	"nes_ninjarahoij", "nes_ninjarahoi", NULL, NULL, "1990",
	"Ninjara Hoi! (Japan)\0", NULL, "ASCII Corp.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_ninjarahoijRomInfo, nes_ninjarahoijRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ninja Rahoi! (Hack English)
static struct BurnRomInfo nes_ninjarahoiRomDesc[] = {
	{ "Ninjara Hoi! (T-eng).nes",          524304, 0x23dbc962, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ninjarahoi)
STD_ROM_FN(nes_ninjarahoi)

struct BurnDriver BurnDrvnes_ninjarahoi = {
	"nes_ninjarahoi", NULL, NULL, NULL, "2014",
	"Ninja Rahoi! (Hack English)\0", NULL, "Stardust Crusaders", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_ninjarahoiRomInfo, nes_ninjarahoiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Nintendo World Cup (USA)
static struct BurnRomInfo nes_ninteworcupRomDesc[] = {
	{ "Nintendo World Cup (USA).nes",          262160, 0x88b55f68, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ninteworcup)
STD_ROM_FN(nes_ninteworcup)

struct BurnDriver BurnDrvnes_ninteworcup = {
	"nes_ninteworcup", NULL, NULL, NULL, "1990",
	"Nintendo World Cup (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSFOOTBALL, 0,
	NESGetZipName, nes_ninteworcupRomInfo, nes_ninteworcupRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Noah's Ark (Euro)
static struct BurnRomInfo nes_noahsarkRomDesc[] = {
	{ "Noah's Ark (Europe).nes",          262160, 0xab21ab5f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_noahsark)
STD_ROM_FN(nes_noahsark)

struct BurnDriver BurnDrvnes_noahsark = {
	"nes_noahsark", NULL, NULL, NULL, "1992",
	"Noah's Ark (Euro)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_noahsarkRomInfo, nes_noahsarkRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL, SCREEN_WIDTH, SCREEN_HEIGHT_PAL
};

// North & South (USA)
static struct BurnRomInfo nes_northsouthRomDesc[] = {
	{ "North & South (USA).nes",          262160, 0x840c3b42, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_northsouth)
STD_ROM_FN(nes_northsouth)

struct BurnDriver BurnDrvnes_northsouth = {
	"nes_northsouth", NULL, NULL, NULL, "1990",
	"North & South (USA)\0", NULL, "Kemco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_STRATEGY | GBF_ACTION, 0,
	NESGetZipName, nes_northsouthRomInfo, nes_northsouthRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Nuts & Milk (Japan)
static struct BurnRomInfo nes_nutsmilkRomDesc[] = {
	{ "Nuts & Milk (Japan).nes",          24592, 0x11879fe8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_nutsmilk)
STD_ROM_FN(nes_nutsmilk)

struct BurnDriver BurnDrvnes_nutsmilk = {
	"nes_nutsmilk", NULL, NULL, NULL, "1984",
	"Nuts & Milk (Japan)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_nutsmilkRomInfo, nes_nutsmilkRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Obake no Q Tarou - Wanwan Panic (Japan)
static struct BurnRomInfo nes_obakenoqtarRomDesc[] = {
	{ "Obake no Q Tarou - Wanwan Panic (Japan).nes",          40976, 0x16f8e815, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_obakenoqtar)
STD_ROM_FN(nes_obakenoqtar)

struct BurnDriver BurnDrvnes_obakenoqtar = {
	"nes_obakenoqtar", NULL, NULL, NULL, "1985",
	"Obake no Q Tarou - Wanwan Panic (Japan)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_obakenoqtarRomInfo, nes_obakenoqtarRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Onyanko Town (Japan)
static struct BurnRomInfo nes_onyankotownRomDesc[] = {
	{ "Onyanko Town (Japan).nes",          40976, 0xc07cb40b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_onyankotown)
STD_ROM_FN(nes_onyankotown)

struct BurnDriver BurnDrvnes_onyankotown = {
	"nes_onyankotown", NULL, NULL, NULL, "1985",
	"Onyanko Town (Japan)\0", NULL, "Pony Canyon", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_MAZE | GBF_ACTION, 0,
	NESGetZipName, nes_onyankotownRomInfo, nes_onyankotownRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Operation Wolf (USA)
static struct BurnRomInfo nes_operationwolfRomDesc[] = {
	{ "Operation Wolf (USA).nes",          262160, 0x80704705, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_operationwolf)
STD_ROM_FN(nes_operationwolf)

struct BurnDriver BurnDrvnes_operationwolf = {
	"nes_operationwolf", NULL, NULL, NULL, "1989",
	"Operation Wolf (USA)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_operationwolfRomInfo, nes_operationwolfRomName, NULL, NULL, NULL, NULL, NESZapperInputInfo, NESZapperDIPInfo,
	NESZapperInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Othello (HES)
static struct BurnRomInfo nes_othellohRomDesc[] = {
	{ "Othello (HES)(1988)(HES Interactive).nes",          24592, 0xfe58062c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_othelloh)
STD_ROM_FN(nes_othelloh)

struct BurnDriver BurnDrvnes_othelloh = {
	"nes_othelloh", NULL, NULL, NULL, "1988",
	"Othello (HES)\0", NULL, "HES Interactive", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_BOARD, 0,
	NESGetZipName, nes_othellohRomInfo, nes_othellohRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Othello (USA)
static struct BurnRomInfo nes_othelloRomDesc[] = {
	{ "Othello (U)(1988)(Acclaim).nes",          40976, 0x97428519, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_othello)
STD_ROM_FN(nes_othello)

struct BurnDriver BurnDrvnes_othello = {
	"nes_othello", NULL, NULL, NULL, "1988",
	"Othello (USA)\0", NULL, "Acclaim", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_BOARD, 0,
	NESGetZipName, nes_othelloRomInfo, nes_othelloRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Family Computer - Othello (Japan)
static struct BurnRomInfo nes_othellojRomDesc[] = {
	{ "Family Computer - Othello (J)(1986)(HAL Lab.).nes",          40976, 0xe68398a4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_othelloj)
STD_ROM_FN(nes_othelloj)

struct BurnDriver BurnDrvnes_othelloj = {
	"nes_othelloj", "nes_othello", NULL, NULL, "1986",
	"Family Computer - Othello (Japan)\0", NULL, "HAL Laboratory", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_BOARD, 0,
	NESGetZipName, nes_othellojRomInfo, nes_othellojRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Outlanders (Japan)
static struct BurnRomInfo nes_outlandersjRomDesc[] = {
	{ "Outlanders (Japan)(1987)(Victor).nes",          131088, 0x49a9f043, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_outlandersj)
STD_ROM_FN(nes_outlandersj)

struct BurnDriver BurnDrvnes_outlandersj = {
	"nes_outlandersj", "nes_outlanders", NULL, NULL, "1987",
	"Outlanders (Japan)\0", NULL, "Victor", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_outlandersjRomInfo, nes_outlandersjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Outlanders (Hack, English v1.01)
// https://www.romhacking.net/translations/3862/
static struct BurnRomInfo nes_outlandersRomDesc[] = {
	{ "Outlanders T-Eng (2019)(GAFF Translations).nes",          262160, 0xf0b0c8fe, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_outlanders)
STD_ROM_FN(nes_outlanders)

struct BurnDriver BurnDrvnes_outlanders = {
	"nes_outlanders", NULL, NULL, NULL, "2019",
	"Outlanders (Hack, English v1.01)\0", NULL, "GAFF Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_outlandersRomInfo, nes_outlandersRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Over Horizon (Japan)
static struct BurnRomInfo nes_overhorizonRomDesc[] = {
	{ "Over Horizon (Japan)(1992)(Takara).nes",          262160, 0x130e399b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_overhorizon)
STD_ROM_FN(nes_overhorizon)

struct BurnDriver BurnDrvnes_overhorizon = {
	"nes_overhorizon", NULL, NULL, NULL, "1992",
	"Over Horizon (Japan)\0", NULL, "Takara", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_overhorizonRomInfo, nes_overhorizonRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Overlord (USA)
static struct BurnRomInfo nes_overlordRomDesc[] = {
	{ "Overlord (USA)(1993)(Virgin Games).nes",          262160, 0x4df9d7c8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_overlord)
STD_ROM_FN(nes_overlord)

struct BurnDriver BurnDrvnes_overlord = {
	"nes_overlord", NULL, NULL, NULL, "1993",
	"Overlord (USA)\0", NULL, "Virgin Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_overlordRomInfo, nes_overlordRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// P.O.W. - Prisoners of War (USA)
static struct BurnRomInfo nes_powRomDesc[] = {
	{ "P.O.W. - Prisoners of War (USA)(1989)(SNK).nes",          262160, 0xd282464b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pow)
STD_ROM_FN(nes_pow)

struct BurnDriver BurnDrvnes_pow = {
	"nes_pow", NULL, NULL, NULL, "1989",
	"P.O.W. - Prisoners of War (USA)\0", NULL, "SNK", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_powRomInfo, nes_powRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Pac-Land (Japan)
static struct BurnRomInfo nes_paclandRomDesc[] = {
	{ "Pac-Land (Japan)(1985)(Namco).nes",          40976, 0x6ea63a46, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pacland)
STD_ROM_FN(nes_pacland)

struct BurnDriver BurnDrvnes_pacland = {
	"nes_pacland", NULL, NULL, NULL, "1985",
	"Pac-Land (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_paclandRomInfo, nes_paclandRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Pac-Man (USA) (Tengen)
static struct BurnRomInfo nes_pacmanRomDesc[] = {
	{ "Pac-Man (USA)(1988)(Tengen).nes",          24592, 0x6e7d8503, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pacman)
STD_ROM_FN(nes_pacman)

struct BurnDriver BurnDrvnes_pacman = {
	"nes_pacman", NULL, NULL, NULL, "1988",
	"Pac-Man (USA) (Tengen)\0", NULL, "Tengen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_MAZE | GBF_ACTION, 0,
	NESGetZipName, nes_pacmanRomInfo, nes_pacmanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Pac-Man (USA) (Namco)
static struct BurnRomInfo nes_pacmanuRomDesc[] = {
	{ "Pac-Man (USA)(1993)(Namco).nes",          24592, 0x5988ed8e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pacmanu)
STD_ROM_FN(nes_pacmanu)

struct BurnDriver BurnDrvnes_pacmanu = {
	"nes_pacmanu", "nes_pacman", NULL, NULL, "1993",
	"Pac-Man (USA) (Namco)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_MAZE | GBF_ACTION, 0,
	NESGetZipName, nes_pacmanuRomInfo, nes_pacmanuRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Pac-Mania (USA)
static struct BurnRomInfo nes_pacmaniaRomDesc[] = {
	{ "Pac-Mania (USA)(1990)(Tengen).nes",          98320, 0xe2428b3c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pacmania)
STD_ROM_FN(nes_pacmania)

struct BurnDriver BurnDrvnes_pacmania = {
	"nes_pacmania", NULL, NULL, NULL, "1990",
	"Pac-Mania (USA)\0", NULL, "Tengen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_MAZE | GBF_ACTION, 0,
	NESGetZipName, nes_pacmaniaRomInfo, nes_pacmaniaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Palamedes (USA)
static struct BurnRomInfo nes_palamedesRomDesc[] = {
	{ "Palamedes (USA)(1990)(HOT-B).nes",          65552, 0xc3cd6c66, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_palamedes)
STD_ROM_FN(nes_palamedes)

struct BurnDriver BurnDrvnes_palamedes = {
	"nes_palamedes", NULL, NULL, NULL, "1990",
	"Palamedes (USA)\0", NULL, "HOT-B", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_palamedesRomInfo, nes_palamedesRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Palamedes II - Star Twinkle, Hoshi no Mabataki (Japan)
static struct BurnRomInfo nes_palamiiRomDesc[] = {
	{ "Palamedes II - Star Twinkle, Hoshi no Mabataki (Japan)(1991)(HOT-B).nes",          65552, 0x0fdad901, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_palamii)
STD_ROM_FN(nes_palamii)

struct BurnDriver BurnDrvnes_palamii = {
	"nes_palamii", NULL, NULL, NULL, "1991",
	"Palamedes II - Star Twinkle, Hoshi no Mabataki (Japan)\0", NULL, "HOT-B", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_palamiiRomInfo, nes_palamiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Panic Restaurant (USA)
static struct BurnRomInfo nes_panicrestaurantRomDesc[] = {
	{ "Panic Restaurant (USA)(1992)(Taito).nes",          262160, 0x69c9e654, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_panicrestaurant)
STD_ROM_FN(nes_panicrestaurant)

struct BurnDriver BurnDrvnes_panicrestaurant = {
	"nes_panicrestaurant", NULL, NULL, NULL, "1992",
	"Panic Restaurant (USA)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_panicrestaurantRomInfo, nes_panicrestaurantRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wanpaku Kokkun no Gourmet World (Japan)
static struct BurnRomInfo nes_gourmetworldRomDesc[] = {
	{ "Wanpaku Kokkun no Gourmet World (Japan)(1992)(Taito Corp.).nes",          262160, 0xfffb5ead, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_gourmetworld)
STD_ROM_FN(nes_gourmetworld)

struct BurnDriver BurnDrvnes_gourmetworld = {
	"nes_gourmetworld", "nes_panicrestaurant", NULL, NULL, "1992",
	"Wanpaku Kokkun no Gourmet World (Japan)\0", NULL, "Taito Corp.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_gourmetworldRomInfo, nes_gourmetworldRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Paperboy (USA)
static struct BurnRomInfo nes_paperboyRomDesc[] = {
	{ "Paperboy (USA)(1988)(Mindscape).nes",          65552, 0xeb171d77, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_paperboy)
STD_ROM_FN(nes_paperboy)

struct BurnDriver BurnDrvnes_paperboy = {
	"nes_paperboy", NULL, NULL, NULL, "1988",
	"Paperboy (USA)\0", NULL, "Mindscape", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_paperboyRomInfo, nes_paperboyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Paperboy 2 (USA)
static struct BurnRomInfo nes_paperboy2RomDesc[] = {
	{ "Paperboy 2 (USA)(1992)(Mindscape).nes",          262160, 0xe02f3836, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_paperboy2)
STD_ROM_FN(nes_paperboy2)

struct BurnDriver BurnDrvnes_paperboy2 = {
	"nes_paperboy2", NULL, NULL, NULL, "1992",
	"Paperboy 2 (USA)\0", NULL, "Mindscape", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_paperboy2RomInfo, nes_paperboy2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_papillongalsRomDesc[] = {
	{ "Papillon Gals (Japan) (Unl).nes",          98320, 0x5b273e7f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_papillongals)
STD_ROM_FN(nes_papillongals)

struct BurnDriver BurnDrvnes_papillongals = {
	"nes_papillongals", NULL, NULL, NULL, "1989",
	"Papillon Gals (Japan) (Unl)\0", NULL, "Joy Van & Kinema Music", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_papillongalsRomInfo, nes_papillongalsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_parallelworldRomDesc[] = {
	{ "Parallel World (Japan).nes",          262160, 0xda1d8662, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_parallelworld)
STD_ROM_FN(nes_parallelworld)

struct BurnDriver BurnDrvnes_parallelworld = {
	"nes_parallelworld", NULL, NULL, NULL, "1990",
	"Parallel World (Japan)\0", NULL, "Varie", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PUZZLE | GBF_ACTION, 0,
	NESGetZipName, nes_parallelworldRomInfo, nes_parallelworldRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Parasol Henbee (Japan)
static struct BurnRomInfo nes_parasolhenbeejRomDesc[] = {
	{ "Parasol Henbee (Japan)(1991)(Epoch Co.).nes",          262160, 0xedfab3a6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_parasolhenbeej)
STD_ROM_FN(nes_parasolhenbeej)

struct BurnDriver BurnDrvnes_parasolhenbeej = {
	"nes_parasolhenbeej", "nes_parasolhenbee", NULL, NULL, "1991",
	"Parasol Henbee (Japan)\0", NULL, "Epoch Co.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_parasolhenbeejRomInfo, nes_parasolhenbeejRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Parasol Henbee (Hack, English)
// https://www.romhacking.net/translations/2582/
static struct BurnRomInfo nes_parasolhenbeeRomDesc[] = {
	{ "Parasol Henbee T-Eng (2016)(Zynk Oxhyde).nes",          262160, 0x6e435769, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_parasolhenbee)
STD_ROM_FN(nes_parasolhenbee)

struct BurnDriver BurnDrvnes_parasolhenbee = {
	"nes_parasolhenbee", NULL, NULL, NULL, "2016",
	"Parasol Henbee (Hack, English)\0", NULL, "Zynk Oxhyde", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_parasolhenbeeRomInfo, nes_parasolhenbeeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Parasol Stars - Rainbow Islands II (Euro)
static struct BurnRomInfo nes_parasstaraiisliiRomDesc[] = {
	{ "Parasol Stars - Rainbow Islands II (Europe).nes",          262160, 0xdc7a16e6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_parasstaraiislii)
STD_ROM_FN(nes_parasstaraiislii)

struct BurnDriver BurnDrvnes_parasstaraiislii = {
	"nes_parasstaraiislii", NULL, NULL, NULL, "1991",
	"Parasol Stars - Rainbow Islands II (Euro)\0", NULL, "Ocean", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_parasstaraiisliiRomInfo, nes_parasstaraiisliiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL, SCREEN_WIDTH, SCREEN_HEIGHT_PAL
};

// Paris-Dakar Rally Special (Japan)
static struct BurnRomInfo nes_parisdakralspejRomDesc[] = {
	{ "Paris-Dakar Rally Special (Japan).nes",          163856, 0x4b662975, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_parisdakralspej)
STD_ROM_FN(nes_parisdakralspej)

struct BurnDriver BurnDrvnes_parisdakralspej = {
	"nes_parisdakralspej", "nes_parisdakralspe", NULL, NULL, "1988",
	"Paris-Dakar Rally Special (Japan)\0", NULL, "CBS / Sony Group", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RACING | GBF_ADV, 0,
	NESGetZipName, nes_parisdakralspejRomInfo, nes_parisdakralspejRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Paris-Dakar Rally Special (Hack, English)
static struct BurnRomInfo nes_parisdakralspeRomDesc[] = {
	{ "Paris-Dakar Rally Special (T-Eng).nes",          163856, 0xe2b9be12, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_parisdakralspe)
STD_ROM_FN(nes_parisdakralspe)

struct BurnDriver BurnDrvnes_parisdakralspe = {
	"nes_parisdakralspe", NULL, NULL, NULL, "2013",
	"Paris-Dakar Rally Special (Hack, English)\0", NULL, "MrRichard999", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RACING | GBF_ADV, 0,
	NESGetZipName, nes_parisdakralspeRomInfo, nes_parisdakralspeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Parodius (Euro)
static struct BurnRomInfo nes_parodiusRomDesc[] = {
	{ "Parodius (Europe).nes",          262160, 0x22ad4753, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_parodius)
STD_ROM_FN(nes_parodius)

struct BurnDriver BurnDrvnes_parodius = {
	"nes_parodius", "nes_parodiusda", NULL, NULL, "1992",
	"Parodius (Euro)\0", NULL, "Palcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_parodiusRomInfo, nes_parodiusRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL, SCREEN_WIDTH, SCREEN_HEIGHT_PAL
};

// Parodius Da! (Japan)
static struct BurnRomInfo nes_parodiusdajRomDesc[] = {
	{ "Parodius Da! (Japan).nes",          262160, 0xec8aeffc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_parodiusdaj)
STD_ROM_FN(nes_parodiusdaj)

struct BurnDriver BurnDrvnes_parodiusdaj = {
	"nes_parodiusdaj", "nes_parodiusda", NULL, NULL, "1990",
	"Parodius Da! (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_parodiusdajRomInfo, nes_parodiusdajRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Parodius Da! (Hack, English)
static struct BurnRomInfo nes_parodiusdaRomDesc[] = {
	{ "Parodius Da! (T-Eng).nes",          393232, 0x7012e75a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_parodiusda)
STD_ROM_FN(nes_parodiusda)

struct BurnDriver BurnDrvnes_parodiusda = {
	"nes_parodiusda", NULL, NULL, NULL, "2011",
	"Parodius Da! (Hack, English)\0", NULL, "Stardust Crusaders", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_parodiusdaRomInfo, nes_parodiusdaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Peek-A-Boo Poker (Unl)
static struct BurnRomInfo nes_peekaboopokerRomDesc[] = {
	{ "Peek-A-Boo Poker (Unl).nes",          98320, 0x38f4ac1c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_peekaboopoker)
STD_ROM_FN(nes_peekaboopoker)

struct BurnDriver BurnDrvnes_peekaboopoker = {
	"nes_peekaboopoker", NULL, NULL, NULL, "1991",
	"Peek-A-Boo Poker (Unl)\0", NULL, "Panesian", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_CARD, 0,
	NESGetZipName, nes_peekaboopokerRomInfo, nes_peekaboopokerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Peepar Time (Japan)
static struct BurnRomInfo nes_peepartimeRomDesc[] = {
	{ "Peepar Time (Japan).nes",          49168, 0x532c30e1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_peepartime)
STD_ROM_FN(nes_peepartime)

struct BurnDriver BurnDrvnes_peepartime = {
	"nes_peepartime", NULL, NULL, NULL, "1990",
	"Peepar Time (Japan)\0", NULL, "Sanritsu", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION | GBF_PUZZLE, 0,
	NESGetZipName, nes_peepartimeRomInfo, nes_peepartimeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_penguseaRomDesc[] = {
	{ "Penguin & Seal, The (Unl).nes",          24592, 0x8daf3827, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pengusea)
STD_ROM_FN(nes_pengusea)

struct BurnDriver BurnDrvnes_pengusea = {
	"nes_pengusea", NULL, NULL, NULL, "1989",
	"Penguin & Seal, The (Unl)\0", NULL, "Sachen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_penguseaRomInfo, nes_penguseaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Penguin-kun Wars (Japan)
static struct BurnRomInfo nes_penguinkunwarsRomDesc[] = {
	{ "Penguin-kun Wars (Japan).nes",          40976, 0x27229b16, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_penguinkunwars)
STD_ROM_FN(nes_penguinkunwars)

struct BurnDriver BurnDrvnes_penguinkunwars = {
	"nes_penguinkunwars", NULL, NULL, NULL, "1985",
	"Penguin-kun Wars (Japan)\0", NULL, "ASCII Corp.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_BALLPADDLE, 0,
	NESGetZipName, nes_penguinkunwarsRomInfo, nes_penguinkunwarsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Perfect Bowling (Japan)
static struct BurnRomInfo nes_perfectbowlingRomDesc[] = {
	{ "Perfect Bowling (Japan).nes",          163856, 0x13f283ae, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_perfectbowling)
STD_ROM_FN(nes_perfectbowling)

struct BurnDriver BurnDrvnes_perfectbowling = {
	"nes_perfectbowling", NULL, NULL, NULL, "1989",
	"Perfect Bowling (Japan)\0", NULL, "Tonkin House", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_perfectbowlingRomInfo, nes_perfectbowlingRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Perman (Japan)
static struct BurnRomInfo nes_permanRomDesc[] = {
	{ "Perman (Japan).nes",          262160, 0x02dd2b01, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_perman)
STD_ROM_FN(nes_perman)

struct BurnDriver BurnDrvnes_perman = {
	"nes_perman", NULL, NULL, NULL, "1990",
	"Perman (Japan)\0", NULL, "Irem", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_permanRomInfo, nes_permanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Perman Part 2 - Himitsu Kessha Madoodan o Taose! (Japan)
static struct BurnRomInfo nes_permapar2RomDesc[] = {
	{ "Perman Part 2 - Himitsu Kessha Madoodan o Taose! (Japan).nes",          393232, 0x687837c8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_permapar2)
STD_ROM_FN(nes_permapar2)

struct BurnDriver BurnDrvnes_permapar2 = {
	"nes_permapar2", NULL, NULL, NULL, "1991",
	"Perman Part 2 - Himitsu Kessha Madoodan o Taose! (Japan)\0", NULL, "Irem", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_permapar2RomInfo, nes_permapar2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Pesterminator (USA)
static struct BurnRomInfo nes_pesterminatorRomDesc[] = {
	{ "Pesterminator (USA) (Unl).nes",          131088, 0x5cf70751, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pesterminator)
STD_ROM_FN(nes_pesterminator)

struct BurnDriver BurnDrvnes_pesterminator = {
	"nes_pesterminator", NULL, NULL, NULL, "1990",
	"Pesterminator (USA)\0", NULL, "Color Dreams", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_pesterminatorRomInfo, nes_pesterminatorRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Peter Pan & The Pirates (USA)
static struct BurnRomInfo nes_peterpanpirRomDesc[] = {
	{ "Peter Pan & The Pirates (USA).nes",          196624, 0xd21e83bb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_peterpanpir)
STD_ROM_FN(nes_peterpanpir)

struct BurnDriver BurnDrvnes_peterpanpir = {
	"nes_peterpanpir", NULL, NULL, NULL, "1991",
	"Peter Pan & The Pirates (USA)\0", NULL, "THQ", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_peterpanpirRomInfo, nes_peterpanpirRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Phantom Fighter (USA)
static struct BurnRomInfo nes_phantomfighterRomDesc[] = {
	{ "Phantom Fighter (USA).nes",          262160, 0x9dde4e60, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_phantomfighter)
STD_ROM_FN(nes_phantomfighter)

struct BurnDriver BurnDrvnes_phantomfighter = {
	"nes_phantomfighter", NULL, NULL, NULL, "1990",
	"Phantom Fighter (USA)\0", NULL, "FCI", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_phantomfighterRomInfo, nes_phantomfighterRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Pictionary (USA)
static struct BurnRomInfo nes_pictionaryRomDesc[] = {
	{ "Pictionary (USA).nes",          262160, 0xb1b1d1bb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pictionary)
STD_ROM_FN(nes_pictionary)

struct BurnDriver BurnDrvnes_pictionary = {
	"nes_pictionary", NULL, NULL, NULL, "1990",
	"Pictionary (USA)\0", NULL, "Ljn", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_PUZZLE | GBF_BOARD, 0,
	NESGetZipName, nes_pictionaryRomInfo, nes_pictionaryRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Pin Bot (USA)
static struct BurnRomInfo nes_pinbotRomDesc[] = {
	{ "Pin Bot (USA).nes",          196624, 0x65050f34, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pinbot)
STD_ROM_FN(nes_pinbot)

struct BurnDriver BurnDrvnes_pinbot = {
	"nes_pinbot", NULL, NULL, NULL, "1990",
	"Pin Bot (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_PINBALL, 0,
	NESGetZipName, nes_pinbotRomInfo, nes_pinbotRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Pinball (USA)
static struct BurnRomInfo nes_pinballRomDesc[] = {
	{ "Pinball (USA).nes",          24592, 0x88c15cf3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pinball)
STD_ROM_FN(nes_pinball)

struct BurnDriver BurnDrvnes_pinball = {
	"nes_pinball", NULL, NULL, NULL, "1984",
	"Pinball (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PINBALL, 0,
	NESGetZipName, nes_pinballRomInfo, nes_pinballRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Pinball CV by Redrum (Hack)
static struct BurnRomInfo nes_pinbacvbyredRomDesc[] = {
	{ "Pinball CV by Redrum (Hack).nes",          24592, 0xd61066d8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pinbacvbyred)
STD_ROM_FN(nes_pinbacvbyred)

struct BurnDriver BurnDrvnes_pinbacvbyred = {
	"nes_pinbacvbyred", "nes_pinball", NULL, NULL, "2003",
	"Pinball CV by Redrum (Hack)\0", NULL, "Redrum", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PINBALL, 0,
	NESGetZipName, nes_pinbacvbyredRomInfo, nes_pinbacvbyredRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Pinball Quest (USA)
static struct BurnRomInfo nes_pinballquestRomDesc[] = {
	{ "Pinball Quest (USA).nes",          262160, 0x488bf94e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pinballquest)
STD_ROM_FN(nes_pinballquest)

struct BurnDriver BurnDrvnes_pinballquest = {
	"nes_pinballquest", NULL, NULL, NULL, "1990",
	"Pinball Quest (USA)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_PINBALL | GBF_RPG, 0,
	NESGetZipName, nes_pinballquestRomInfo, nes_pinballquestRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Pirates! (USA)
static struct BurnRomInfo nes_piratesRomDesc[] = {
	{ "Pirates! (USA)(1991)(Ultra Games).nes",          262160, 0x64fc3667, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pirates)
STD_ROM_FN(nes_pirates)

struct BurnDriver BurnDrvnes_pirates = {
	"nes_pirates", NULL, NULL, NULL, "1991",
	"Pirates! (USA)\0", NULL, "Ultra Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION | GBF_STRATEGY, 0,
	NESGetZipName, nes_piratesRomInfo, nes_piratesRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Pizza Pop! (Japan)
static struct BurnRomInfo nes_pizzapopjRomDesc[] = {
	{ "Pizza Pop! (Japan).nes",          262160, 0x361729fa, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pizzapopj)
STD_ROM_FN(nes_pizzapopj)

struct BurnDriver BurnDrvnes_pizzapopj = {
	"nes_pizzapopj", "nes_pizzapop", NULL, NULL, "1992",
	"Pizza Pop! (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_pizzapopjRomInfo, nes_pizzapopjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Pizza Pop! (Hack, English)
// https://www.romhacking.net/translations/4630/
static struct BurnRomInfo nes_pizzapopRomDesc[] = {
	{ "Pizza Pop! (T-Eng).nes",          262160, 0xbcde6e2c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pizzapop)
STD_ROM_FN(nes_pizzapop)

struct BurnDriver BurnDrvnes_pizzapop = {
	"nes_pizzapop", NULL, NULL, NULL, "2019",
	"Pizza Pop! (Hack, English)\0", NULL, "pacnsacdave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_pizzapopRomInfo, nes_pizzapopRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Plasma Ball (Japan)
static struct BurnRomInfo nes_plasmaballjRomDesc[] = {
	{ "Plasma Ball (Japan).nes",          262160, 0x7279b50e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_plasmaballj)
STD_ROM_FN(nes_plasmaballj)

struct BurnDriver BurnDrvnes_plasmaballj = {
	"nes_plasmaballj", "nes_plasmaball", NULL, NULL, "1992",
	"Plasma Ball (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_BALLPADDLE, 0,
	NESGetZipName, nes_plasmaballjRomInfo, nes_plasmaballjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Plasma Ball (Hack, English)
// https://www.romhacking.net/translations/4540/
static struct BurnRomInfo nes_plasmaballRomDesc[] = {
	{ "Plasma Ball (T-eng).nes",          393232, 0x71cf9877, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_plasmaball)
STD_ROM_FN(nes_plasmaball)

struct BurnDriver BurnDrvnes_plasmaball = {
	"nes_plasmaball", NULL, NULL, NULL, "2019",
	"Plasma Ball (Hack, English)\0", NULL, "MrRichard999", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_NES, GBF_BALLPADDLE, 0,
	NESGetZipName, nes_plasmaballRomInfo, nes_plasmaballRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Platoon (USA)
static struct BurnRomInfo nes_platoonRomDesc[] = {
	{ "Platoon (USA).nes",          262160, 0xdec5bb7f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_platoon)
STD_ROM_FN(nes_platoon)

struct BurnDriver BurnDrvnes_platoon = {
	"nes_platoon", NULL, NULL, NULL, "1988",
	"Platoon (USA)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_ADV, 0,
	NESGetZipName, nes_platoonRomInfo, nes_platoonRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Po Po Team (Taiwan)
static struct BurnRomInfo nes_popoteamRomDesc[] = {
	{ "Po Po Team (Taiwan).nes",          196624, 0x1b461169, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_popoteam)
STD_ROM_FN(nes_popoteam)

struct BurnDriver BurnDrvnes_popoteam = {
	"nes_popoteam", NULL, NULL, NULL, "1992",
	"Po Po Team (Taiwan)\0", NULL, "Sachen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_popoteamRomInfo, nes_popoteamRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Pocket Zaurus - Juu Ouken no Nazo (Japan)
static struct BurnRomInfo nes_pockezauRomDesc[] = {
	{ "Pocket Zaurus - Juu Ouken no Nazo (Japan).nes",          262160, 0x568be3b8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pockezau)
STD_ROM_FN(nes_pockezau)

struct BurnDriver BurnDrvnes_pockezau = {
	"nes_pockezau", NULL, NULL, NULL, "1987",
	"Pocket Zaurus - Juu Ouken no Nazo (Japan)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_pockezauRomInfo, nes_pockezauRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Policeman (Unl)
static struct BurnRomInfo nes_policemanRomDesc[] = {
	{ "Policeman (Unl).nes",          131088, 0x6b1ddc17, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_policeman)
STD_ROM_FN(nes_policeman)

struct BurnDriver BurnDrvnes_policeman = {
	"nes_policeman", NULL, NULL, NULL, "1992",
	"Policeman (Unl)\0", NULL, "Micro Genius", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_policemanRomInfo, nes_policemanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Pooyan (Japan)
static struct BurnRomInfo nes_pooyanRomDesc[] = {
	{ "Pooyan (Japan).nes",          24592, 0x1d54dd4c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pooyan)
STD_ROM_FN(nes_pooyan)

struct BurnDriver BurnDrvnes_pooyan = {
	"nes_pooyan", NULL, NULL, NULL, "1985",
	"Pooyan (Japan)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_pooyanRomInfo, nes_pooyanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Popeye (World) (Rev A)
static struct BurnRomInfo nes_popeyeRomDesc[] = {
	{ "Popeye (World) (Rev A).nes",          24592, 0xfb1a91d0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_popeye)
STD_ROM_FN(nes_popeye)

struct BurnDriver BurnDrvnes_popeye = {
	"nes_popeye", NULL, NULL, NULL, "1986",
	"Popeye (World) (Rev A)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_popeyeRomInfo, nes_popeyeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Power Blade (USA)
static struct BurnRomInfo nes_powerbladeRomDesc[] = {
	{ "Power Blade (USA).nes",          262160, 0x76663e66, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_powerblade)
STD_ROM_FN(nes_powerblade)

struct BurnDriver BurnDrvnes_powerblade = {
	"nes_powerblade", NULL, NULL, NULL, "1991",
	"Power Blade (USA)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_powerbladeRomInfo, nes_powerbladeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Power Blade 2 (USA)
static struct BurnRomInfo nes_powerblade2RomDesc[] = {
	{ "Power Blade 2 (USA).nes",          262160, 0xf8e0bc9b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_powerblade2)
STD_ROM_FN(nes_powerblade2)

struct BurnDriver BurnDrvnes_powerblade2 = {
	"nes_powerblade2", NULL, NULL, NULL, "1992",
	"Power Blade 2 (USA)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_powerblade2RomInfo, nes_powerblade2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Power Blazer (Japan)
static struct BurnRomInfo nes_powerblazerjRomDesc[] = {
	{ "Power Blazer (Japan).nes",          262160, 0x2b17a194, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_powerblazerj)
STD_ROM_FN(nes_powerblazerj)

struct BurnDriver BurnDrvnes_powerblazerj = {
	"nes_powerblazerj", "nes_powerblazer", NULL, NULL, "1990",
	"Power Blazer (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_powerblazerjRomInfo, nes_powerblazerjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Power Blazer (Hack, English)
static struct BurnRomInfo nes_powerblazerRomDesc[] = {
	{ "Power Blazer (T-Eng).nes",          262160, 0xa9bd2381, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_powerblazer)
STD_ROM_FN(nes_powerblazer)

struct BurnDriver BurnDrvnes_powerblazer = {
	"nes_powerblazer", NULL, NULL, NULL, "2017",
	"Power Blazer (Hack, English)\0", NULL, "Stardust Crusaders", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_powerblazerRomInfo, nes_powerblazerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_powerpunchiiRomDesc[] = {
	{ "Power Punch II (USA).nes",          393232, 0xb4402fe5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_powerpunchii)
STD_ROM_FN(nes_powerpunchii)

struct BurnDriver BurnDrvnes_powerpunchii = {
	"nes_powerpunchii", NULL, NULL, NULL, "1992",
	"Power Punch II (USA)\0", NULL, "American Softworks", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_powerpunchiiRomInfo, nes_powerpunchiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_powerraniiiRomDesc[] = {
	{ "Power Rangers III (Unl).nes",          393232, 0x94192c10, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_powerraniii)
STD_ROM_FN(nes_powerraniii)

struct BurnDriver BurnDrvnes_powerraniii = {
	"nes_powerraniii", NULL, NULL, NULL, "1995",
	"Power Rangers III (Unl)\0", NULL, "J.Y. Company", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_powerraniiiRomInfo, nes_powerraniiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_powerrangersivRomDesc[] = {
	{ "Power Rangers IV (Unl).nes",          393232, 0x4faed070, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_powerrangersiv)
STD_ROM_FN(nes_powerrangersiv)

struct BurnDriver BurnDrvnes_powerrangersiv = {
	"nes_powerrangersiv", NULL, NULL, NULL, "1995",
	"Power Rangers IV (Unl)\0", NULL, "J.Y. Company", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_powerrangersivRomInfo, nes_powerrangersivRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_powersoccerRomDesc[] = {
	{ "Power Soccer (Japan).nes",          65552, 0xa99fa4a9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_powersoccer)
STD_ROM_FN(nes_powersoccer)

struct BurnDriver BurnDrvnes_powersoccer = {
	"nes_powersoccer", NULL, NULL, NULL, "1990",
	"Power Soccer (Japan)\0", NULL, "Tokuma Shoten", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSFOOTBALL, 0,
	NESGetZipName, nes_powersoccerRomInfo, nes_powersoccerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_predatorRomDesc[] = {
	{ "Predator (USA).nes",          262160, 0xca6d44ca, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_predator)
STD_ROM_FN(nes_predator)

struct BurnDriver BurnDrvnes_predator = {
	"nes_predator", NULL, NULL, NULL, "1989",
	"Predator (USA)\0", NULL, "Activision", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_predatorRomInfo, nes_predatorRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Prince of Persia (USA)
static struct BurnRomInfo nes_princeofpersiaRomDesc[] = {
	{ "Prince of Persia (USA).nes",          131088, 0x43c7e445, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_princeofpersia)
STD_ROM_FN(nes_princeofpersia)

struct BurnDriver BurnDrvnes_princeofpersia = {
	"nes_princeofpersia", NULL, NULL, NULL, "1992",
	"Prince of Persia (USA)\0", NULL, "Virgin Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_princeofpersiaRomInfo, nes_princeofpersiaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Salad no Kuni no Tomato Hime (Japan)
static struct BurnRomInfo nes_princtominsalkijRomDesc[] = {
	{ "Princess Tomato in Salad Kingdom (Japan).nes",          262160, 0x5085d4f4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_princtominsalkij)
STD_ROM_FN(nes_princtominsalkij)

struct BurnDriver BurnDrvnes_princtominsalkij = {
	"nes_princtominsalkij", "nes_princtominsalki", NULL, NULL, "1988",
	"Salad no Kuni no Tomato Hime (Japan)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_princtominsalkijRomInfo, nes_princtominsalkijRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Salad no Kuni no Tomato Hime (Hack, English v1.03)
static struct BurnRomInfo nes_princtominsalkitRomDesc[] = {
	{ "Salad no Kuni no Tomato Hime (2021)(T-Eng, v1.03)(Stardust Crusaders).nes",          524304, 0x6b333e13, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_princtominsalkit)
STD_ROM_FN(nes_princtominsalkit)

struct BurnDriver BurnDrvnes_princtominsalkit = {
	"nes_princtominsalkit", "nes_princtominsalki", NULL, NULL, "2021",
	"Salad no Kuni no Tomato Hime (Hack, English v1.03)\0", NULL, "Stardust Crusaders", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_princtominsalkitRomInfo, nes_princtominsalkitRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Princess Tomato in Salad Kingdom (USA)
static struct BurnRomInfo nes_princtominsalkiRomDesc[] = {
	{ "Princess Tomato in Salad Kingdom (USA).nes",          262160, 0x079c2139, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_princtominsalki)
STD_ROM_FN(nes_princtominsalki)

struct BurnDriver BurnDrvnes_princtominsalki = {
	"nes_princtominsalki", NULL, NULL, NULL, "1991",
	"Princess Tomato in Salad Kingdom (USA)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_princtominsalkiRomInfo, nes_princtominsalkiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Pro Wrestling (USA)
static struct BurnRomInfo nes_prowrestlingRomDesc[] = {
	{ "Pro Wrestling (USA).nes",          131088, 0x57bec3e6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_prowrestling)
STD_ROM_FN(nes_prowrestling)

struct BurnDriver BurnDrvnes_prowrestling = {
	"nes_prowrestling", NULL, NULL, NULL, "1987",
	"Pro Wrestling (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_prowrestlingRomInfo, nes_prowrestlingRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Probotector (Euro)
static struct BurnRomInfo nes_probotectorRomDesc[] = {
	{ "Probotector (Europe).nes",          131088, 0x8236d3e0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_probotector)
STD_ROM_FN(nes_probotector)

struct BurnDriver BurnDrvnes_probotector = {
	"nes_probotector", "nes_contra", NULL, NULL, "1990",
	"Probotector (Euro)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_probotectorRomInfo, nes_probotectorRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL, SCREEN_WIDTH, SCREEN_HEIGHT_PAL
};

// Punch-Out!! (USA)
static struct BurnRomInfo nes_punchoutRomDesc[] = {
	{ "Punch-Out!! (USA).nes",          262160, 0xa827ff1b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_punchout)
STD_ROM_FN(nes_punchout)

struct BurnDriver BurnDrvnes_punchout = {
	"nes_punchout", NULL, NULL, NULL, "1990",
	"Punch-Out!! (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_punchoutRomInfo, nes_punchoutRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Punisher, The (USA)
static struct BurnRomInfo nes_punishertheRomDesc[] = {
	{ "Punisher, The (USA).nes",          262160, 0x0d6bd840, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_punisherthe)
STD_ROM_FN(nes_punisherthe)

struct BurnDriver BurnDrvnes_punisherthe = {
	"nes_punisherthe", NULL, NULL, NULL, "1990",
	"Punisher, The (USA)\0", NULL, "Ljn", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_punishertheRomInfo, nes_punishertheRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Puss 'n Boots - Pero's Great Adventure (USA)
static struct BurnRomInfo nes_pussnbooRomDesc[] = {
	{ "Puss 'n Boots - Pero's Great Adventure (USA).nes",          131088, 0x5d07670a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pussnboo)
STD_ROM_FN(nes_pussnboo)

struct BurnDriver BurnDrvnes_pussnboo = {
	"nes_pussnboo", NULL, NULL, NULL, "1990",
	"Puss 'n Boots - Pero's Great Adventure (USA)\0", NULL, "Electro Brain", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_pussnbooRomInfo, nes_pussnbooRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Puyo Puyo (Japan)
static struct BurnRomInfo nes_puyopuyoRomDesc[] = {
	{ "Puyo Puyo (Japan).nes",          131088, 0x3f42a1cc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_puyopuyo)
STD_ROM_FN(nes_puyopuyo)

struct BurnDriver BurnDrvnes_puyopuyo = {
	"nes_puyopuyo", NULL, NULL, NULL, "1993",
	"Puyo Puyo (Japan)\0", NULL, "Tokuma Shoten", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_puyopuyoRomInfo, nes_puyopuyoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Puzslot (Japan)
static struct BurnRomInfo nes_puzslotRomDesc[] = {
	{ "Puzslot (Japan).nes",          262160, 0x996e7a8b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_puzslot)
STD_ROM_FN(nes_puzslot)

struct BurnDriver BurnDrvnes_puzslot = {
	"nes_puzslot", NULL, NULL, NULL, "1992",
	"Puzslot (Japan)\0", NULL, "Sammy", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_puzslotRomInfo, nes_puzslotRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Puzznic (USA)
static struct BurnRomInfo nes_puzznicRomDesc[] = {
	{ "Puzznic (USA).nes",          65552, 0xa44a0927, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_puzznic)
STD_ROM_FN(nes_puzznic)

struct BurnDriver BurnDrvnes_puzznic = {
	"nes_puzznic", NULL, NULL, NULL, "1990",
	"Puzznic (USA)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_puzznicRomInfo, nes_puzznicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Pyokotan no Daimeiro (Japan)
static struct BurnRomInfo nes_pyokonodaiRomDesc[] = {
	{ "Pyokotan no Daimeiro (Japan).nes",          262160, 0x1bb879b0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pyokonodai)
STD_ROM_FN(nes_pyokonodai)

struct BurnDriver BurnDrvnes_pyokonodai = {
	"nes_pyokonodai", NULL, NULL, NULL, "1993",
	"Pyokotan no Daimeiro (Japan)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_MINIGAMES, 0,
	NESGetZipName, nes_pyokonodaiRomInfo, nes_pyokonodaiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Pyramid (Unl)
static struct BurnRomInfo nes_pyramidRomDesc[] = {
	{ "Pyramid (Unl).nes",          24592, 0xafee5df1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pyramid)
STD_ROM_FN(nes_pyramid)

struct BurnDriver BurnDrvnes_pyramid = {
	"nes_pyramid", NULL, NULL, NULL, "1990",
	"Pyramid (Unl)\0", NULL, "Sachen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_pyramidRomInfo, nes_pyramidRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Pyramid II (Unl)
static struct BurnRomInfo nes_pyramidiiRomDesc[] = {
	{ "Pyramid II (Unl).nes",          81936, 0x36f1ad35, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_pyramidii)
STD_ROM_FN(nes_pyramidii)

struct BurnDriver BurnDrvnes_pyramidii = {
	"nes_pyramidii", NULL, NULL, NULL, "1990",
	"Pyramid II (Unl)\0", NULL, "Sachen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_pyramidiiRomInfo, nes_pyramidiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Q Boy (Asia) (Unl)
static struct BurnRomInfo nes_qboyRomDesc[] = {
	{ "Q Boy (Asia) (Unl).nes",          262160, 0x2dce9f48, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_qboy)
STD_ROM_FN(nes_qboy)

struct BurnDriver BurnDrvnes_qboy = {
	"nes_qboy", NULL, NULL, NULL, "1994",
	"Q Boy (Asia) (Unl)\0", NULL, "Sachen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_qboyRomInfo, nes_qboyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Q-bert (USA)
static struct BurnRomInfo nes_qbertRomDesc[] = {
	{ "Q-bert (USA).nes",          65552, 0x8f992f3c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_qbert)
STD_ROM_FN(nes_qbert)

struct BurnDriver BurnDrvnes_qbert = {
	"nes_qbert", NULL, NULL, NULL, "1989",
	"Q-bert (USA)\0", NULL, "Ultra Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_qbertRomInfo, nes_qbertRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// QIX (USA)
static struct BurnRomInfo nes_qixRomDesc[] = {
	{ "QIX (USA).nes",          131088, 0x4724713d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_qix)
STD_ROM_FN(nes_qix)

struct BurnDriver BurnDrvnes_qix = {
	"nes_qix", NULL, NULL, NULL, "1991",
	"QIX (USA)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_qixRomInfo, nes_qixRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Quarth (Japan)
static struct BurnRomInfo nes_quarthRomDesc[] = {
	{ "Quarth (Japan).nes",          65552, 0x439ff96a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_quarth)
STD_ROM_FN(nes_quarth)

struct BurnDriver BurnDrvnes_quarth = {
	"nes_quarth", NULL, NULL, NULL, "1990",
	"Quarth (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PUZZLE | GBF_SHOOT, 0,
	NESGetZipName, nes_quarthRomInfo, nes_quarthRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Quarter Back Scramble (Prototype)
static struct BurnRomInfo nes_qbscrambleRomDesc[] = {
	{ "Quarter Back Scramble (USA)(Proto)(1990)(Pony Canyon).nes",          262160, 0x0a55b11f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_qbscramble)
STD_ROM_FN(nes_qbscramble)

struct BurnDriver BurnDrvnes_qbscramble = {
	"nes_qbscramble", NULL, NULL, NULL, "1990",
	"Quarter Back Scramble (Prototype)\0", NULL, "Pony Canyon", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_PROTOTYPE, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_qbscrambleRomInfo, nes_qbscrambleRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Quarter Back Scramble (Japan)
static struct BurnRomInfo nes_qbscramblejRomDesc[] = {
	{ "Quarter Back Scramble (J)(1990)(Pony Canyon).nes",          262160, 0xc373aeec, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_qbscramblej)
STD_ROM_FN(nes_qbscramblej)

struct BurnDriver BurnDrvnes_qbscramblej = {
	"nes_qbscramblej", "nes_qbscramble", NULL, NULL, "1990",
	"Quarter Back Scramble (Japan)\0", NULL, "Pony Canyon", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_qbscramblejRomInfo, nes_qbscramblejRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mike Ditka's Big Play Football (Unl)
static struct BurnRomInfo nes_mdfootballRomDesc[] = {
	{ "Mike Ditka's Big Play Football (Unl)(2008)(NGD).nes",          262160, 0x6bf165f3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_mdfootball)
STD_ROM_FN(nes_mdfootball)

struct BurnDriver BurnDrvnes_mdfootball = {
	"nes_mdfootball", "nes_qbscramble", NULL, NULL, "2008",
	"Mike Ditka's Big Play Football (Unl)\0", NULL, "NGD", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_mdfootballRomInfo, nes_mdfootballRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Quattro Adventure (USA) (Unl)
static struct BurnRomInfo nes_quattadvRomDesc[] = {
	{ "Quattro Adventure (USA) (Unl).nes",          262160, 0xee8e3a91, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_quattadv)
STD_ROM_FN(nes_quattadv)

struct BurnDriver BurnDrvnes_quattadv = {
	"nes_quattadv", NULL, NULL, NULL, "1992",
	"Quattro Adventure (USA) (Unl)\0", NULL, "Camerica", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_quattadvRomInfo, nes_quattadvRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Quattro Arcade (USA) (Unl)
static struct BurnRomInfo nes_quattroarcadeRomDesc[] = {
	{ "Quattro Arcade (USA) (Unl).nes",          262160, 0x2f36c2f1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_quattroarcade)
STD_ROM_FN(nes_quattroarcade)

struct BurnDriver BurnDrvnes_quattroarcade = {
	"nes_quattroarcade", NULL, NULL, NULL, "1992",
	"Quattro Arcade (USA) (Unl)\0", NULL, "Camerica", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_quattroarcadeRomInfo, nes_quattroarcadeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Quattro Sports (USA) (Unl)
static struct BurnRomInfo nes_quattrosportsRomDesc[] = {
	{ "Quattro Sports (USA) (Unl).nes",          262160, 0x9adc4130, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_quattrosports)
STD_ROM_FN(nes_quattrosports)

struct BurnDriver BurnDrvnes_quattrosports = {
	"nes_quattrosports", NULL, NULL, NULL, "1992",
	"Quattro Sports (USA) (Unl)\0", NULL, "Camerica", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_quattrosportsRomInfo, nes_quattrosportsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Quest of Ki, The (Japan)
static struct BurnRomInfo nes_questofkithejRomDesc[] = {
	{ "Quest of Ki, The (Japan).nes",          196624, 0xccc47a57, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_questofkithej)
STD_ROM_FN(nes_questofkithej)

struct BurnDriver BurnDrvnes_questofkithej = {
	"nes_questofkithej", "nes_questofkithe", NULL, NULL, "1988",
	"Quest of Ki, The (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_questofkithejRomInfo, nes_questofkithejRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Quest of Ki, The (Hack, English)
static struct BurnRomInfo nes_questofkitheRomDesc[] = {
	{ "Quest of Ki, The (T-eng).nes",          196624, 0x027c28bd, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_questofkithe)
STD_ROM_FN(nes_questofkithe)

struct BurnDriver BurnDrvnes_questofkithe = {
	"nes_questofkithe", NULL, NULL, NULL, "2019",
	"Quest of Ki, The (Hack, English)\0", NULL, "Zynk Oxhyde", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_questofkitheRomInfo, nes_questofkitheRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Quinty (Japan)
static struct BurnRomInfo nes_quintyRomDesc[] = {
	{ "Quinty (Japan).nes",          262160, 0x1e9b49ec, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_quinty)
STD_ROM_FN(nes_quinty)

struct BurnDriver BurnDrvnes_quinty = {
	"nes_quinty", "nes_mendelpalace", NULL, NULL, "1989",
	"Quinty (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_quintyRomInfo, nes_quintyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_rbibaseballRomDesc[] = {
	{ "R.B.I. Baseball (USA).nes",          98320, 0x39207888, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rbibaseball)
STD_ROM_FN(nes_rbibaseball)

struct BurnDriver BurnDrvnes_rbibaseball = {
	"nes_rbibaseball", NULL, NULL, NULL, "1988",
	"R.B.I. Baseball (USA)\0", NULL, "Tengen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_rbibaseballRomInfo, nes_rbibaseballRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_rbibas2RomDesc[] = {
	{ "R.B.I. Baseball 2 (USA).nes",          196624, 0xbb49df09, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rbibas2)
STD_ROM_FN(nes_rbibas2)

struct BurnDriver BurnDrvnes_rbibas2 = {
	"nes_rbibas2", NULL, NULL, NULL, "1990",
	"R.B.I. Baseball 2 (USA)\0", NULL, "Tengen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_rbibas2RomInfo, nes_rbibas2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_rbibas3RomDesc[] = {
	{ "R.B.I. Baseball 3 (USA).nes",          196624, 0xd0f5ffd3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rbibas3)
STD_ROM_FN(nes_rbibas3)

struct BurnDriver BurnDrvnes_rbibas3 = {
	"nes_rbibas3", NULL, NULL, NULL, "1991",
	"R.B.I. Baseball 3 (USA)\0", NULL, "Tengen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_rbibas3RomInfo, nes_rbibas3RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_rcproamRomDesc[] = {
	{ "R.C. Pro-Am (USA) (Rev A).nes",          65552, 0x690a4eb2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rcproam)
STD_ROM_FN(nes_rcproam)

struct BurnDriver BurnDrvnes_rcproam = {
	"nes_rcproam", NULL, NULL, NULL, "1988",
	"R.C. Pro-Am (USA) (Rev A)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_rcproamRomInfo, nes_rcproamRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_rcproamiiRomDesc[] = {
	{ "R.C. Pro-Am II (USA).nes",          262160, 0x03db5562, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rcproamii)
STD_ROM_FN(nes_rcproamii)

struct BurnDriver BurnDrvnes_rcproamii = {
	"nes_rcproamii", NULL, NULL, NULL, "1992",
	"R.C. Pro-Am II (USA)\0", NULL, "Tradewest", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_rcproamiiRomInfo, nes_rcproamiiRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Racket Attack (USA)
static struct BurnRomInfo nes_racketattackRomDesc[] = {
	{ "Racket Attack (USA).nes",          393232, 0xc359cdb9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_racketattack)
STD_ROM_FN(nes_racketattack)

struct BurnDriver BurnDrvnes_racketattack = {
	"nes_racketattack", NULL, NULL, NULL, "1988",
	"Racket Attack (USA)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_racketattackRomInfo, nes_racketattackRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rackets & Rivals (Euro)
static struct BurnRomInfo nes_racketsrivalsRomDesc[] = {
	{ "Rackets & Rivals (Europe).nes",          262160, 0xa535e1be, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_racketsrivals)
STD_ROM_FN(nes_racketsrivals)

struct BurnDriver BurnDrvnes_racketsrivals = {
	"nes_racketsrivals", NULL, NULL, NULL, "1989",
	"Rackets & Rivals (Euro)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_racketsrivalsRomInfo, nes_racketsrivalsRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL, SCREEN_WIDTH, SCREEN_HEIGHT_PAL
};

// Rad Racer (USA)
static struct BurnRomInfo nes_radracerRomDesc[] = {
	{ "Rad Racer (USA).nes",          131088, 0x595daa35, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_radracer)
STD_ROM_FN(nes_radracer)

struct BurnDriver BurnDrvnes_radracer = {
	"nes_radracer", NULL, NULL, NULL, "1988",
	"Rad Racer (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_radracerRomInfo, nes_radracerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rad Racer II (USA)
static struct BurnRomInfo nes_radraceriiRomDesc[] = {
	{ "Rad Racer II (USA).nes",          131088, 0x39d371ec, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_radracerii)
STD_ROM_FN(nes_radracerii)

struct BurnDriver BurnDrvnes_radracerii = {
	"nes_radracerii", NULL, NULL, NULL, "1990",
	"Rad Racer II (USA)\0", NULL, "Square", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_radraceriiRomInfo, nes_radraceriiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rad Racket - Deluxe Tennis II (USA)
static struct BurnRomInfo nes_radracRomDesc[] = {
	{ "Rad Racket - Deluxe Tennis II (USA).nes",          65552, 0xdb37c5b2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_radrac)
STD_ROM_FN(nes_radrac)

struct BurnDriver BurnDrvnes_radrac = {
	"nes_radrac", NULL, NULL, NULL, "1991",
	"Rad Racket - Deluxe Tennis II (USA)\0", NULL, "American Video Entertainment", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_radracRomInfo, nes_radracRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Radia Senki - Reimei Hen (Japan)
static struct BurnRomInfo nes_radiasenjRomDesc[] = {
	{ "Radia Senki - Reimei Hen (Japan).nes",          393232, 0x3bca1cd7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_radiasenj)
STD_ROM_FN(nes_radiasenj)

struct BurnDriver BurnDrvnes_radiasenj = {
	"nes_radiasenj", "nes_radiasen", NULL, NULL, "1991",
	"Radia Senki - Reimei Hen (Japan)\0", NULL, "Tecmo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_radiasenjRomInfo, nes_radiasenjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Radia Senki - Reimei Hen (Hack, English)
// https://www.romhacking.net/translations/102/
static struct BurnRomInfo nes_radiasenRomDesc[] = {
	{ "Radia Senki - Reimei Hen (T-eng).nes",          393232, 0x1d76af30, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_radiasen)
STD_ROM_FN(nes_radiasen)

struct BurnDriver BurnDrvnes_radiasen = {
	"nes_radiasen", NULL, NULL, NULL, "1999",
	"Radia Senki - Reimei Hen (Hack, English)\0", NULL, "Dreamless, Jair, [cx]", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_radiasenRomInfo, nes_radiasenRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Raid 2020 (USA) (Unl)
static struct BurnRomInfo nes_raid2020RomDesc[] = {
	{ "Raid 2020 (USA) (Unl).nes",          98320, 0xf69a2c11, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_raid2020)
STD_ROM_FN(nes_raid2020)

struct BurnDriver BurnDrvnes_raid2020 = {
	"nes_raid2020", NULL, NULL, NULL, "1989",
	"Raid 2020 (USA) (Unl)\0", NULL, "Color Dreams", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_raid2020RomInfo, nes_raid2020RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Raid on Bungeling Bay (USA)
static struct BurnRomInfo nes_raidonbunbayRomDesc[] = {
	{ "Raid on Bungeling Bay (USA).nes",          24592, 0xb1155ae3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_raidonbunbay)
STD_ROM_FN(nes_raidonbunbay)

struct BurnDriver BurnDrvnes_raidonbunbay = {
	"nes_raidonbunbay", NULL, NULL, NULL, "1987",
	"Raid on Bungeling Bay (USA)\0", NULL, "Broderbund", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_raidonbunbayRomInfo, nes_raidonbunbayRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rainbow Islands - Ocean (Euro)
static struct BurnRomInfo nes_rainbisloceRomDesc[] = {
	{ "Rainbow Islands - Ocean (Europe).nes",          262160, 0xfac97247, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rainbisloce)
STD_ROM_FN(nes_rainbisloce)

struct BurnDriver BurnDrvnes_rainbisloce = {
	"nes_rainbisloce", NULL, NULL, NULL, "1988",
	"Rainbow Islands - Ocean (Euro)\0", NULL, "Ocean", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_rainbisloceRomInfo, nes_rainbisloceRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL, SCREEN_WIDTH, SCREEN_HEIGHT_PAL
};

// Rainbow Islands - Taito (Japan)
static struct BurnRomInfo nes_rainbisltaijRomDesc[] = {
	{ "Rainbow Islands - Taito (Japan).nes",          131088, 0x39872654, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rainbisltaij)
STD_ROM_FN(nes_rainbisltaij)

struct BurnDriver BurnDrvnes_rainbisltaij = {
	"nes_rainbisltaij", "nes_rainbisltai", NULL, NULL, "1988",
	"Rainbow Islands - Taito (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_rainbisltaijRomInfo, nes_rainbisltaijRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rainbow Islands - Taito (USA)
static struct BurnRomInfo nes_rainbisltaiRomDesc[] = {
	{ "Rainbow Islands - Taito (USA).nes",          131088, 0x5d56b6a4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rainbisltai)
STD_ROM_FN(nes_rainbisltai)

struct BurnDriver BurnDrvnes_rainbisltai = {
	"nes_rainbisltai", NULL, NULL, NULL, "1991",
	"Rainbow Islands - Taito (USA)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_rainbisltaiRomInfo, nes_rainbisltaiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rally Bike (USA)
static struct BurnRomInfo nes_rallybikeRomDesc[] = {
	{ "Rally Bike (USA).nes",          131088, 0xd2cdce48, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rallybike)
STD_ROM_FN(nes_rallybike)

struct BurnDriver BurnDrvnes_rallybike = {
	"nes_rallybike", NULL, NULL, NULL, "1990",
	"Rally Bike (USA)\0", NULL, "Romstar", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_rallybikeRomInfo, nes_rallybikeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rambo (USA) (Rev A)
static struct BurnRomInfo nes_ramboRomDesc[] = {
	{ "Rambo (USA) (Rev A).nes",          131088, 0x7c9468d1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rambo)
STD_ROM_FN(nes_rambo)

struct BurnDriver BurnDrvnes_rambo = {
	"nes_rambo", NULL, NULL, NULL, "1988",
	"Rambo (USA) (Rev A)\0", NULL, "Acclaim", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_ramboRomInfo, nes_ramboRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rampage (USA)
static struct BurnRomInfo nes_rampageRomDesc[] = {
	{ "Rampage (USA).nes",          196624, 0x628fe3c9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rampage)
STD_ROM_FN(nes_rampage)

struct BurnDriver BurnDrvnes_rampage = {
	"nes_rampage", NULL, NULL, NULL, "1988",
	"Rampage (USA)\0", NULL, "Data East", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_rampageRomInfo, nes_rampageRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rampart (USA)
static struct BurnRomInfo nes_rampartRomDesc[] = {
	{ "Rampart (USA).nes",          262160, 0x0cea6fca, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rampart)
STD_ROM_FN(nes_rampart)

struct BurnDriver BurnDrvnes_rampart = {
	"nes_rampart", NULL, NULL, NULL, "1992",
	"Rampart (USA)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_rampartRomInfo, nes_rampartRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Red Arremer II (Japan)
static struct BurnRomInfo nes_redarremeriiRomDesc[] = {
	{ "Red Arremer II (Japan).nes",          262160, 0x7998c426, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_redarremerii)
STD_ROM_FN(nes_redarremerii)

struct BurnDriver BurnDrvnes_redarremerii = {
	"nes_redarremerii", "nes_gargosqueii", NULL, NULL, "1992",
	"Red Arremer II (Japan)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ADV | GBF_PLATFORM, 0,
	NESGetZipName, nes_redarremeriiRomInfo, nes_redarremeriiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ren & Stimpy Show, The - Buckeroo$! (USA)
static struct BurnRomInfo nes_renstishoRomDesc[] = {
	{ "Ren & Stimpy Show, The - Buckeroo$! (USA).nes",          262160, 0xc319b1d1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_renstisho)
STD_ROM_FN(nes_renstisho)

struct BurnDriver BurnDrvnes_renstisho = {
	"nes_renstisho", NULL, NULL, NULL, "1993",
	"Ren & Stimpy Show, The - Buckeroo$! (USA)\0", NULL, "THQ", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM | GBF_SHOOT, 0,
	NESGetZipName, nes_renstishoRomInfo, nes_renstishoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Renegade (USA)
static struct BurnRomInfo nes_renegadeRomDesc[] = {
	{ "Renegade (USA).nes",          131088, 0x935f5d29, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_renegade)
STD_ROM_FN(nes_renegade)

struct BurnDriver BurnDrvnes_renegade = {
	"nes_renegade", NULL, NULL, NULL, "1988",
	"Renegade (USA)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_renegadeRomInfo, nes_renegadeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rescue - The Embassy Mission (USA)
static struct BurnRomInfo nes_rescueRomDesc[] = {
	{ "Rescue - The Embassy Mission (USA).nes",          262160, 0x0e4fe1f3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rescue)
STD_ROM_FN(nes_rescue)

struct BurnDriver BurnDrvnes_rescue = {
	"nes_rescue", NULL, NULL, NULL, "1990",
	"Rescue - The Embassy Mission (USA)\0", NULL, "Kemco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT | GBF_ADV, 0,
	NESGetZipName, nes_rescueRomInfo, nes_rescueRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ripple Island (Hack, English)
// https://www.romhacking.net/translations/3769/
static struct BurnRomInfo nes_ripislandRomDesc[] = {
	{ "Ripple Island T-Eng (2018)(LIPEMCO! Translations).nes",          262160, 0x51f5e289, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ripisland)
STD_ROM_FN(nes_ripisland)

struct BurnDriver BurnDrvnes_ripisland = {
	"nes_ripisland", NULL, NULL, NULL, "2018",
	"Ripple Island (Hack, English)\0", NULL, "LIPEMCO! Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_ripislandRomInfo, nes_ripislandRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ripple Island (Japan)
static struct BurnRomInfo nes_ripislandjRomDesc[] = {
	{ "Ripple Island (J)(1988)(Sunsoft).nes",          131088, 0x7148c342, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ripislandj)
STD_ROM_FN(nes_ripislandj)

struct BurnDriver BurnDrvnes_ripislandj = {
	"nes_ripislandj", "nes_ripisland", NULL, NULL, "1988",
	"Ripple Island (Japan)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_ripislandjRomInfo, nes_ripislandjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ring King (USA)
static struct BurnRomInfo nes_ringkingRomDesc[] = {
	{ "Ring King (USA).nes",          131088, 0x38e1163d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ringking)
STD_ROM_FN(nes_ringking)

struct BurnDriver BurnDrvnes_ringking = {
	"nes_ringking", NULL, NULL, NULL, "1987",
	"Ring King (USA)\0", NULL, "Data East", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_ringkingRomInfo, nes_ringkingRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// River City Ransom (USA)
static struct BurnRomInfo nes_rivercitranRomDesc[] = {
	{ "River City Ransom (USA).nes",          262160, 0xc3508f7e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rivercitran)
STD_ROM_FN(nes_rivercitran)

struct BurnDriver BurnDrvnes_rivercitran = {
	"nes_rivercitran", NULL, NULL, NULL, "1990",
	"River City Ransom (USA)\0", NULL, "Technos", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_rivercitranRomInfo, nes_rivercitranRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// River City Ransom - Nekketsu Hack (Hack, v1.2)
// https://www.romhacking.net/hacks/5998/
static struct BurnRomInfo nes_rivercitrannekRomDesc[] = {
	{ "River City Ransom - Nekketsu Hack v1.2 (2023)(FANS).nes",          262160, 0xe4d1a0a1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rivercitrannek)
STD_ROM_FN(nes_rivercitrannek)

struct BurnDriver BurnDrvnes_rivercitrannek = {
	"nes_rivercitrannek", "nes_rivercitran", NULL, NULL, "2023",
	"River City Ransom - Nekketsu Hack (Hack, v1.2)\0", NULL, "FANS", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_rivercitrannekRomInfo, nes_rivercitrannekRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Road Fighter (Japan)
static struct BurnRomInfo nes_roadfighterRomDesc[] = {
	{ "Road Fighter (Japan).nes",          24592, 0xf57abbf1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_roadfighter)
STD_ROM_FN(nes_roadfighter)

struct BurnDriver BurnDrvnes_roadfighter = {
	"nes_roadfighter", NULL, NULL, NULL, "1985",
	"Road Fighter (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_roadfighterRomInfo, nes_roadfighterRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Road Runner (USA) (Unl)
static struct BurnRomInfo nes_roadrunnerRomDesc[] = {
	{ "Road Runner (USA) (Unl).nes",          196624, 0xd4aa300d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_roadrunner)
STD_ROM_FN(nes_roadrunner)

struct BurnDriver BurnDrvnes_roadrunner = {
	"nes_roadrunner", NULL, NULL, NULL, "1989",
	"Road Runner (USA) (Unl)\0", NULL, "Tengen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_roadrunnerRomInfo, nes_roadrunnerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Road Worker (Unl)
static struct BurnRomInfo nes_roadworkerRomDesc[] = {
	{ "Road Worker (Unl).nes",          49168, 0x7877b76d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_roadworker)
STD_ROM_FN(nes_roadworker)

struct BurnDriver BurnDrvnes_roadworker = {
	"nes_roadworker", NULL, NULL, NULL, "200?",
	"Road Worker (Unl)\0", NULL, "Nice Code Software", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_roadworkerRomInfo, nes_roadworkerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// RoadBlasters (USA)
static struct BurnRomInfo nes_roadblastersRomDesc[] = {
	{ "RoadBlasters (USA).nes",          262160, 0xe76915b9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_roadblasters)
STD_ROM_FN(nes_roadblasters)

struct BurnDriver BurnDrvnes_roadblasters = {
	"nes_roadblasters", NULL, NULL, NULL, "1990",
	"RoadBlasters (USA)\0", NULL, "Mindscape", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RACING | GBF_SHOOT, 0,
	NESGetZipName, nes_roadblastersRomInfo, nes_roadblastersRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Robert Byrne's Pool Challenge (Prototype)
static struct BurnRomInfo nes_rpoolchalRomDesc[] = {
	{ "Robert Byrne's Pool Challenge Prototype (1996)(Odyssey Software).nes",          98320, 0x9b273e2b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rpoolchal)
STD_ROM_FN(nes_rpoolchal)

struct BurnDriver BurnDrvnes_rpoolchal = {
	"nes_rpoolchal", NULL, NULL, NULL, "1996",
	"Robert Byrne's Pool Challenge (Prototype)\0", NULL, "Odyssey Software", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_PROTOTYPE, 4, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_rpoolchalRomInfo, nes_rpoolchalRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Sara Parker's Pool Challenge (Unl)
static struct BurnRomInfo nes_spoolchalRomDesc[] = {
	{ "Sara Parker's Pool Challenge (2010)(RetroUSB).nes",          98320, 0x5a34e197, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_spoolchal)
STD_ROM_FN(nes_spoolchal)

struct BurnDriver BurnDrvnes_spoolchal = {
	"nes_spoolchal", "nes_rpoolchal", NULL, NULL, "2010",
	"Sara Parker's Pool Challenge (Unl)\0", NULL, "retroUSB", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 4, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_spoolchalRomInfo, nes_spoolchalRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Robin Hood - Prince of Thieves (USA)
static struct BurnRomInfo nes_robinhooRomDesc[] = {
	{ "Robin Hood - Prince of Thieves (USA).nes",          262160, 0x922583bf, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_robinhoo)
STD_ROM_FN(nes_robinhoo)

struct BurnDriver BurnDrvnes_robinhoo = {
	"nes_robinhoo", NULL, NULL, NULL, "1991",
	"Robin Hood - Prince of Thieves (USA)\0", NULL, "Virgin Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_robinhooRomInfo, nes_robinhooRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Robo Warrior (USA)
static struct BurnRomInfo nes_robowarriorRomDesc[] = {
	{ "Robo Warrior (USA).nes",          131088, 0xb202a98d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_robowarrior)
STD_ROM_FN(nes_robowarrior)

struct BurnDriver BurnDrvnes_robowarrior = {
	"nes_robowarrior", NULL, NULL, NULL, "1988",
	"Robo Warrior (USA)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_robowarriorRomInfo, nes_robowarriorRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Robocco Wars (Japan)
static struct BurnRomInfo nes_roboccowarsRomDesc[] = {
	{ "Robocco Wars (Japan).nes",          393232, 0x134f6648, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_roboccowars)
STD_ROM_FN(nes_roboccowars)

struct BurnDriver BurnDrvnes_roboccowars = {
	"nes_roboccowars", NULL, NULL, NULL, "1991",
	"Robocco Wars (Japan)\0", NULL, "IGS", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_roboccowarsRomInfo, nes_roboccowarsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// RoboCop (USA)
static struct BurnRomInfo nes_robocopRomDesc[] = {
	{ "RoboCop (USA).nes",          262160, 0x33be5cfd, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_robocop)
STD_ROM_FN(nes_robocop)

struct BurnDriver BurnDrvnes_robocop = {
	"nes_robocop", NULL, NULL, NULL, "1989",
	"RoboCop (USA)\0", NULL, "Data East", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_robocopRomInfo, nes_robocopRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// RoboCop 2 (Hack, Responsive Controls v1.1)
// https://www.romhacking.net/hacks/5188/
static struct BurnRomInfo nes_robocop2hRomDesc[] = {
	{ "RoboCop 2 (USA)(Hack, Responsive Controls v1.1).nes",          262160, 0xff6885d8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_robocop2h)
STD_ROM_FN(nes_robocop2h)

struct BurnDriver BurnDrvnes_robocop2h = {
	"nes_robocop2h", "nes_robocop2", NULL, NULL, "2020",
	"RoboCop 2 (Hack, Responsive Controls v1.1)\0", NULL, "Nesrocks", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_robocop2hRomInfo, nes_robocop2hRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// RoboCop 2 (USA)
static struct BurnRomInfo nes_robocop2RomDesc[] = {
	{ "RoboCop 2 (USA).nes",          262160, 0xf4baa4ee, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_robocop2)
STD_ROM_FN(nes_robocop2)

struct BurnDriver BurnDrvnes_robocop2 = {
	"nes_robocop2", NULL, NULL, NULL, "1991",
	"RoboCop 2 (USA)\0", NULL, "Data East", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_robocop2RomInfo, nes_robocop2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// RoboCop 3 (USA)
static struct BurnRomInfo nes_robocop3RomDesc[] = {
	{ "RoboCop 3 (USA).nes",          262160, 0xfbbb58a6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_robocop3)
STD_ROM_FN(nes_robocop3)

struct BurnDriver BurnDrvnes_robocop3 = {
	"nes_robocop3", NULL, NULL, NULL, "1992",
	"RoboCop 3 (USA)\0", NULL, "Ocean", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_robocop3RomInfo, nes_robocop3RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// RoboCop Vs The Terminator (USA)
static struct BurnRomInfo nes_robocvsterRomDesc[] = {
	{ "RoboCop Vs The Terminator (USA).nes",          262160, 0xf5d0e8e1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_robocvster)
STD_ROM_FN(nes_robocvster)

struct BurnDriver BurnDrvnes_robocvster = {
	"nes_robocvster", NULL, NULL, NULL, "1993",
	"RoboCop Vs The Terminator (USA)\0", NULL, "Virgin Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_robocvsterRomInfo, nes_robocvsterRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Robodemons (USA) (Unl)
static struct BurnRomInfo nes_robodemonsRomDesc[] = {
	{ "Robodemons (USA) (Unl).nes",          131088, 0x26ad792b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_robodemons)
STD_ROM_FN(nes_robodemons)

struct BurnDriver BurnDrvnes_robodemons = {
	"nes_robodemons", NULL, NULL, NULL, "1990",
	"Robodemons (USA) (Unl)\0", NULL, "Color Dreams", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_robodemonsRomInfo, nes_robodemonsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rock 'n' Ball (USA)
static struct BurnRomInfo nes_rocknballRomDesc[] = {
	{ "Rock 'n' Ball (USA).nes",          196624, 0x03db2942, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rocknball)
STD_ROM_FN(nes_rocknball)

struct BurnDriver BurnDrvnes_rocknball = {
	"nes_rocknball", NULL, NULL, NULL, "1990",
	"Rock 'n' Ball (USA)\0", NULL, "NTVIC", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_PINBALL, 0,
	NESGetZipName, nes_rocknballRomInfo, nes_rocknballRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rockball (Asia) (Unl)
static struct BurnRomInfo nes_rockballRomDesc[] = {
	{ "Rockball (Asia) (Unl).nes",          131088, 0x9490c38e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rockball)
STD_ROM_FN(nes_rockball)

struct BurnDriver BurnDrvnes_rockball = {
	"nes_rockball", NULL, NULL, NULL, "1993",
	"Rockball (Asia) (Unl)\0", NULL, "Sachen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_rockballRomInfo, nes_rockballRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rocket Ranger (USA)
static struct BurnRomInfo nes_rocketrangerRomDesc[] = {
	{ "Rocket Ranger (USA).nes",          262160, 0x361e3634, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rocketranger)
STD_ROM_FN(nes_rocketranger)

struct BurnDriver BurnDrvnes_rocketranger = {
	"nes_rocketranger", NULL, NULL, NULL, "1990",
	"Rocket Ranger (USA)\0", NULL, "Kemco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_rocketrangerRomInfo, nes_rocketrangerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rocketeer, The (USA)
static struct BurnRomInfo nes_rocketeertheRomDesc[] = {
	{ "Rocketeer, The (USA).nes",          262160, 0x4c84abe0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rocketeerthe)
STD_ROM_FN(nes_rocketeerthe)

struct BurnDriver BurnDrvnes_rocketeerthe = {
	"nes_rocketeerthe", NULL, NULL, NULL, "1991",
	"Rocketeer, The (USA)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_rocketeertheRomInfo, nes_rocketeertheRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rockin' Kats (USA)
static struct BurnRomInfo nes_rockinkatsRomDesc[] = {
	{ "Rockin' Kats (USA).nes",          262160, 0xa3b4f5de, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rockinkats)
STD_ROM_FN(nes_rockinkats)

struct BurnDriver BurnDrvnes_rockinkats = {
	"nes_rockinkats", NULL, NULL, NULL, "1991",
	"Rockin' Kats (USA)\0", NULL, "Atlus", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_rockinkatsRomInfo, nes_rockinkatsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rockman (Japan)
static struct BurnRomInfo nes_rockmanRomDesc[] = {
	{ "Rockman (Japan).nes",          131088, 0xe0141a24, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rockman)
STD_ROM_FN(nes_rockman)

struct BurnDriver BurnDrvnes_rockman = {
	"nes_rockman", "nes_megaman", NULL, NULL, "1987",
	"Rockman (Japan)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_rockmanRomInfo, nes_rockmanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rockman 2 - Dr. Wily no Nazo (Japan)
static struct BurnRomInfo nes_rockm2RomDesc[] = {
	{ "Rockman 2 - Dr. Wily no Nazo (Japan).nes",          262160, 0x30b91650, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rockm2)
STD_ROM_FN(nes_rockm2)

struct BurnDriver BurnDrvnes_rockm2 = {
	"nes_rockm2", "nes_megaman2", NULL, NULL, "1988",
	"Rockman 2 - Dr. Wily no Nazo (Japan)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_rockm2RomInfo, nes_rockm2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rockman 3 - Dr. Wily no Saigo! (Japan)
static struct BurnRomInfo nes_rockm3RomDesc[] = {
	{ "Rockman 3 - Dr. Wily no Saigo! (Japan).nes",          393232, 0xfce6cea2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rockm3)
STD_ROM_FN(nes_rockm3)

struct BurnDriver BurnDrvnes_rockm3 = {
	"nes_rockm3", "nes_megaman3", NULL, NULL, "1990",
	"Rockman 3 - Dr. Wily no Saigo! (Japan)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_rockm3RomInfo, nes_rockm3RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rockman 4 - Aratanaru Yabou!! (Japan)
static struct BurnRomInfo nes_rockm4RomDesc[] = {
	{ "Rockman 4 - Aratanaru Yabou!! (Japan).nes",          524304, 0x771a9138, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rockm4)
STD_ROM_FN(nes_rockm4)

struct BurnDriver BurnDrvnes_rockm4 = {
	"nes_rockm4", "nes_megaman4", NULL, NULL, "1991",
	"Rockman 4 - Aratanaru Yabou!! (Japan)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_rockm4RomInfo, nes_rockm4RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rockman 5 - Blues no Wana! (Japan)
static struct BurnRomInfo nes_rockm5RomDesc[] = {
	{ "Rockman 5 - Blues no Wana! (Japan).nes",          524304, 0x9d01e44c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rockm5)
STD_ROM_FN(nes_rockm5)

struct BurnDriver BurnDrvnes_rockm5 = {
	"nes_rockm5", "nes_megaman5", NULL, NULL, "1992",
	"Rockman 5 - Blues no Wana! (Japan)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_rockm5RomInfo, nes_rockm5RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rockman 6 - Shijou Saidai no Tatakai!! (Japan)
static struct BurnRomInfo nes_rockm6RomDesc[] = {
	{ "Rockman 6 - Shijou Saidai no Tatakai!! (Japan).nes",          524304, 0xab1d7979, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rockm6)
STD_ROM_FN(nes_rockm6)

struct BurnDriver BurnDrvnes_rockm6 = {
	"nes_rockm6", "nes_megaman6", NULL, NULL, "1993",
	"Rockman 6 - Shijou Saidai no Tatakai!! (Japan)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_rockm6RomInfo, nes_rockm6RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rod Land (Euro)
static struct BurnRomInfo nes_rodlandeRomDesc[] = {
	{ "Rod Land (Europe).nes",          131088, 0x11a245a0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rodlande)
STD_ROM_FN(nes_rodlande)

struct BurnDriver BurnDrvnes_rodlande = {
	"nes_rodlande", "nes_rodland", NULL, NULL, "1993",
	"Rod Land (Euro)\0", NULL, "Storm", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_rodlandeRomInfo, nes_rodlandeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL, SCREEN_WIDTH, SCREEN_HEIGHT_PAL
};

// Rod Land (Japan)
static struct BurnRomInfo nes_rodlandRomDesc[] = {
	{ "Rod Land (Japan).nes",          131088, 0x3da3a621, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rodland)
STD_ROM_FN(nes_rodland)

struct BurnDriver BurnDrvnes_rodland = {
	"nes_rodland", NULL, NULL, NULL, "1992",
	"Rod Land (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_rodlandRomInfo, nes_rodlandRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rollerball (USA)
static struct BurnRomInfo nes_rollerballRomDesc[] = {
	{ "Rollerball (USA).nes",          163856, 0xe45a440d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rollerball)
STD_ROM_FN(nes_rollerball)

struct BurnDriver BurnDrvnes_rollerball = {
	"nes_rollerball", NULL, NULL, NULL, "1990",
	"Rollerball (USA)\0", NULL, "HAL Laboratory", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PINBALL, 0,
	NESGetZipName, nes_rollerballRomInfo, nes_rollerballRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rollerblade Racer (USA)
static struct BurnRomInfo nes_rolleracRomDesc[] = {
	{ "Rollerblade Racer (USA).nes",          262160, 0x09e3c83b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rollerac)
STD_ROM_FN(nes_rollerac)

struct BurnDriver BurnDrvnes_rollerac = {
	"nes_rollerac", NULL, NULL, NULL, "1993",
	"Rollerblade Racer (USA)\0", NULL, "Hi Tech Expressions", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_rolleracRomInfo, nes_rolleracRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rollergames (USA)
static struct BurnRomInfo nes_rollergamesRomDesc[] = {
	{ "Rollergames (USA).nes",          262160, 0x80da9f53, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rollergames)
STD_ROM_FN(nes_rollergames)

struct BurnDriver BurnDrvnes_rollergames = {
	"nes_rollergames", NULL, NULL, NULL, "1990",
	"Rollergames (USA)\0", NULL, "Ultra Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_rollergamesRomInfo, nes_rollergamesRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rolling Thunder (Japan)
static struct BurnRomInfo nes_rollingthunderjRomDesc[] = {
	{ "Rolling Thunder (Japan).nes",          262160, 0x9853edf7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rollingthunderj)
STD_ROM_FN(nes_rollingthunderj)

struct BurnDriver BurnDrvnes_rollingthunderj = {
	"nes_rollingthunderj", "nes_rollingthunder", NULL, NULL, "1989",
	"Rolling Thunder (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_rollingthunderjRomInfo, nes_rollingthunderjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rolling Thunder (USA)
static struct BurnRomInfo nes_rollingthunderRomDesc[] = {
	{ "Rolling Thunder (USA) (Unl).nes",          262160, 0xe68a35bc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rollingthunder)
STD_ROM_FN(nes_rollingthunder)

struct BurnDriver BurnDrvnes_rollingthunder = {
	"nes_rollingthunder", NULL, NULL, NULL, "1989",
	"Rolling Thunder (USA)\0", NULL, "Tengen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_rollingthunderRomInfo, nes_rollingthunderRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Romancia (Japan)
static struct BurnRomInfo nes_romanciajRomDesc[] = {
	{ "Romancia (Japan).nes",          131088, 0x1d5c630b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_romanciaj)
STD_ROM_FN(nes_romanciaj)

struct BurnDriver BurnDrvnes_romanciaj = {
	"nes_romanciaj", "nes_romancia", NULL, NULL, "1987",
	"Romancia (Japan)\0", NULL, "Tokyo Shoseki", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_romanciajRomInfo, nes_romanciajRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Romancia (Hack, English)
// https://www.romhacking.net/translations/1264/
static struct BurnRomInfo nes_romanciaRomDesc[] = {
	{ "Romancia (T-Eng).nes",          131088, 0xc0785ed4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_romancia)
STD_ROM_FN(nes_romancia)

struct BurnDriver BurnDrvnes_romancia = {
	"nes_romancia", NULL, NULL, NULL, "2008",
	"Romancia (Hack, English)\0", NULL, "DvD Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_romanciaRomInfo, nes_romanciaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rush'n Attack (USA)
static struct BurnRomInfo nes_rushnattackRomDesc[] = {
	{ "Rush'n Attack (USA).nes",          131088, 0x14a113a5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rushnattack)
STD_ROM_FN(nes_rushnattack)

struct BurnDriver BurnDrvnes_rushnattack = {
	"nes_rushnattack", NULL, NULL, NULL, "1987",
	"Rush'n Attack (USA)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_rushnattackRomInfo, nes_rushnattackRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Rygar (USA) (Rev A)
static struct BurnRomInfo nes_rygarRomDesc[] = {
	{ "Rygar (USA) (Rev A).nes",          131088, 0x04cda7e1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_rygar)
STD_ROM_FN(nes_rygar)

struct BurnDriver BurnDrvnes_rygar = {
	"nes_rygar", NULL, NULL, NULL, "1987",
	"Rygar (USA) (Rev A)\0", NULL, "Tecmo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_rygarRomInfo, nes_rygarRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// S.C.A.T. - Special Cybernetic Attack Team (USA)
static struct BurnRomInfo nes_scatRomDesc[] = {
	{ "S.C.A.T. - Special Cybernetic Attack Team (USA).nes",          262160, 0xd3bf87d1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_scat)
STD_ROM_FN(nes_scat)

struct BurnDriver BurnDrvnes_scat = {
	"nes_scat", NULL, NULL, NULL, "1991",
	"S.C.A.T. - Special Cybernetic Attack Team (USA)\0", NULL, "Natsume", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_scatRomInfo, nes_scatRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Saint Seiya - Ougon Densetsu (Japan)
static struct BurnRomInfo nes_saintseiougdenjRomDesc[] = {
	{ "Saint Seiya - Ougon Densetsu (Japan).nes",          262160, 0xe54ef7f0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_saintseiougdenj)
STD_ROM_FN(nes_saintseiougdenj)

struct BurnDriver BurnDrvnes_saintseiougdenj = {
	"nes_saintseiougdenj", "nes_saintseiougden", NULL, NULL, "1987",
	"Saint Seiya - Ougon Densetsu (Japan)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM | GBF_RPG, 0,
	NESGetZipName, nes_saintseiougdenjRomInfo, nes_saintseiougdenjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Saint Seiya - Ougon Densetsu (Hack, English)
static struct BurnRomInfo nes_saintseiougdenRomDesc[] = {
	{ "Saint Seiya - Ougon Densetsu (T-Eng).nes",          262160, 0x0914dd20, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_saintseiougden)
STD_ROM_FN(nes_saintseiougden)

struct BurnDriver BurnDrvnes_saintseiougden = {
	"nes_saintseiougden", NULL, NULL, NULL, "2001",
	"Saint Seiya - Ougon Densetsu (Hack, English)\0", NULL, "KingMike", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_RPG, 0,
	NESGetZipName, nes_saintseiougdenRomInfo, nes_saintseiougdenRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Saint Seiya - Ougon Densetsu Kanketsu Hen (Japan)
static struct BurnRomInfo nes_saintseiougdenkahenjRomDesc[] = {
	{ "Saint Seiya - Ougon Densetsu Kanketsu Hen (Japan).nes",          262160, 0xf8d258a3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_saintseiougdenkahenj)
STD_ROM_FN(nes_saintseiougdenkahenj)

struct BurnDriver BurnDrvnes_saintseiougdenkahenj = {
	"nes_saintseiougdenkahenj", "nes_saintseiougdenkahen", NULL, NULL, "1988",
	"Saint Seiya - Ougon Densetsu Kanketsu Hen (Japan)\0", NULL, "Shinsei", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM | GBF_RPG, 0,
	NESGetZipName, nes_saintseiougdenkahenjRomInfo, nes_saintseiougdenkahenjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Saint Seiya - Ougon Densetsu Kanketsu Hen (Hack, English)
static struct BurnRomInfo nes_saintseiougdenkahenRomDesc[] = {
	{ "Saint Seiya - Ougon Densetsu Kanketsu Hen (T-Eng).nes",          262160, 0x912be32d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_saintseiougdenkahen)
STD_ROM_FN(nes_saintseiougdenkahen)

struct BurnDriver BurnDrvnes_saintseiougdenkahen = {
	"nes_saintseiougdenkahen", NULL, NULL, NULL, "2010",
	"Saint Seiya - Ougon Densetsu Kanketsu Hen (Hack, English)\0", NULL, "Djinn, aishsha", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_RPG, 0,
	NESGetZipName, nes_saintseiougdenkahenRomInfo, nes_saintseiougdenkahenRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Saiyuuki World (Japan)
static struct BurnRomInfo nes_saiyuukiworldRomDesc[] = {
	{ "Saiyuuki World (Japan).nes",          131088, 0x5ad9aeef, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_saiyuukiworld)
STD_ROM_FN(nes_saiyuukiworld)

struct BurnDriver BurnDrvnes_saiyuukiworld = {
	"nes_saiyuukiworld", NULL, NULL, NULL, "1988",
	"Saiyuuki World (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_saiyuukiworldRomInfo, nes_saiyuukiworldRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Saiyuuki World 2 - Tenjoukai no Majin (Japan)
static struct BurnRomInfo nes_saiyuwor2RomDesc[] = {
	{ "Saiyuuki World 2 - Tenjoukai no Majin (Japan).nes",          262160, 0x0a7eedbb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_saiyuwor2)
STD_ROM_FN(nes_saiyuwor2)

struct BurnDriver BurnDrvnes_saiyuwor2 = {
	"nes_saiyuwor2", "nes_whompem", NULL, NULL, "1990",
	"Saiyuuki World 2 - Tenjoukai no Majin (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_saiyuwor2RomInfo, nes_saiyuwor2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Salamander (Japan)
static struct BurnRomInfo nes_salamanderRomDesc[] = {
	{ "Salamander (Japan).nes",          131088, 0xbf822264, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_salamander)
STD_ROM_FN(nes_salamander)

struct BurnDriver BurnDrvnes_salamander = {
	"nes_salamander", NULL, NULL, NULL, "1987",
	"Salamander (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_HORSHOOT | GBF_VERSHOOT, 0,
	NESGetZipName, nes_salamanderRomInfo, nes_salamanderRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Sangokushi II - Haou no Tairiku (Japan)
static struct BurnRomInfo nes_sangokushiiihanouRomDesc[] = {
	{ "Sangokushi II - Haou no Tairiku (Japan).nes",          524304, 0x5c09bcaf, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sangokushiiihanou)
STD_ROM_FN(nes_sangokushiiihanou)

struct BurnDriver BurnDrvnes_sangokushiiihanou = {
	"nes_sangokushiiihanou", NULL, NULL, NULL, "1992",
	"Sangokushi II - Haou no Tairiku (Japan)\0", NULL, "Namco", "Miscellaneous",
	L"Sangokushi II - Haou no Tairiku (Japan)\0\u4e09\u56fd\u5fd7\u2161 - \u8987\u738b\u306e\u5927\u9678\0", NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_sangokushiiihanouRomInfo, nes_sangokushiiihanouRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Sanrio Cup - Pon Pon Volley (Hack, English)
// https://www.romhacking.net/translations/210/
static struct BurnRomInfo nes_sanriocupRomDesc[] = {
	{ "Sanrio Cup - Pon Pon Volley T-Eng (2014)(Gaijin Productions).nes",          65552, 0x74df8f28, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sanriocup)
STD_ROM_FN(nes_sanriocup)

struct BurnDriver BurnDrvnes_sanriocup = {
	"nes_sanriocup", NULL, NULL, NULL, "2014",
	"Sanrio Cup - Pon Pon Volley (Hack, English)\0", NULL, "Gaijin Productions", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_sanriocupRomInfo, nes_sanriocupRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Sanrio Cup - Pon Pon Volley (Japan)
static struct BurnRomInfo nes_sanriocupjRomDesc[] = {
	{ "Sanrio Cup - Pon Pon Volley (J)(1992)(Character Soft).nes",          65552, 0x96447ea5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sanriocupj)
STD_ROM_FN(nes_sanriocupj)

struct BurnDriver BurnDrvnes_sanriocupj = {
	"nes_sanriocupj", "nes_sanriocup", NULL, NULL, "1992",
	"Sanrio Cup - Pon Pon Volley (Japan)\0", NULL, "Character Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_sanriocupjRomInfo, nes_sanriocupjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Sansara Naga (Japan)
static struct BurnRomInfo nes_sansaranagajRomDesc[] = {
	{ "Sansara Naga (Japan).nes",          393232, 0xe329df2e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sansaranagaj)
STD_ROM_FN(nes_sansaranagaj)

struct BurnDriver BurnDrvnes_sansaranagaj = {
	"nes_sansaranagaj", "nes_sansaranaga", NULL, NULL, "1990",
	"Sansara Naga (Japan)\0", NULL, "Victor", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_sansaranagajRomInfo, nes_sansaranagajRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Sansara Naga (Hack, English)
static struct BurnRomInfo nes_sansaranagaRomDesc[] = {
	{ "Sansara Naga (T-eng).nes",          655376, 0x84d7b375, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sansaranaga)
STD_ROM_FN(nes_sansaranaga)

struct BurnDriver BurnDrvnes_sansaranaga = {
	"nes_sansaranaga", NULL, NULL, NULL, "2014",
	"Sansara Naga (Hack, English)\0", NULL, "Stardust Crusaders", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_sansaranagaRomInfo, nes_sansaranagaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Secret Ties (USA) (Prototype)
static struct BurnRomInfo nes_secrettiesRomDesc[] = {
	{ "Secret Ties (USA) (Proto).nes",          262160, 0x9e131010, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_secretties)
STD_ROM_FN(nes_secretties)

struct BurnDriver BurnDrvnes_secretties = {
	"nes_secretties", NULL, NULL, NULL, "1991",
	"Secret Ties (USA) (Prototype)\0", NULL, "Vic Tokai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_PROTOTYPE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_secrettiesRomInfo, nes_secrettiesRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Section-Z (USA)
static struct BurnRomInfo nes_sectionzRomDesc[] = {
	{ "Section-Z (USA).nes",          131088, 0x3ce543e6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sectionz)
STD_ROM_FN(nes_sectionz)

struct BurnDriver BurnDrvnes_sectionz = {
	"nes_sectionz", NULL, NULL, NULL, "1987",
	"Section-Z (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_sectionzRomInfo, nes_sectionzRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Seicross (USA)
static struct BurnRomInfo nes_seicrossRomDesc[] = {
	{ "Seicross (USA).nes",          40976, 0xc0d823ed, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_seicross)
STD_ROM_FN(nes_seicross)

struct BurnDriver BurnDrvnes_seicross = {
	"nes_seicross", NULL, NULL, NULL, "1988",
	"Seicross (USA)\0", NULL, "FCI", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_seicrossRomInfo, nes_seicrossRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Seikima II - Akuma no Gyakushuu (Japan)
static struct BurnRomInfo nes_seikima2RomDesc[] = {
	{ "Seikima II - Akuma no Gyakushuu (J)(1986)(CBS-Sony).nes",          65552, 0xb546589d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_seikima2)
STD_ROM_FN(nes_seikima2)

struct BurnDriver BurnDrvnes_seikima2 = {
	"nes_seikima2", NULL, NULL, NULL, "1986",
	"Seikima II - Akuma no Gyakushuu (Japan)\0", NULL, "CBS-Sony", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_seikima2RomInfo, nes_seikima2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Seirei Densetsu Lickle (Japan)
static struct BurnRomInfo nes_seiredenlicRomDesc[] = {
	{ "Seirei Densetsu Lickle (Japan).nes",          393232, 0x2823a809, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_seiredenlic)
STD_ROM_FN(nes_seiredenlic)

struct BurnDriver BurnDrvnes_seiredenlic = {
	"nes_seiredenlic", "nes_littlesamson", NULL, NULL, "1992",
	"Seirei Densetsu Lickle (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_seiredenlicRomInfo, nes_seiredenlicRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Seiryaku Simulation - Planet of Conspiracy - Shancara (Hack, English v1.01)
// https://www.romhacking.net/translations/7239/
static struct BurnRomInfo nes_shancaraRomDesc[] = {
	{ "Seiryaku Simulation - Planet of Conspiracy - Shancara T-Eng v1.01 (2024)(BlackPaladin).nes",          262160, 0x7ea7e5df, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_shancara)
STD_ROM_FN(nes_shancara)

struct BurnDriver BurnDrvnes_shancara = {
	"nes_shancara", NULL, NULL, NULL, "2024",
	"Seiryaku Simulation - Planet of Conspiracy - Shancara (Hack, English v1.01)\0", NULL, "BlackPaladin", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 4, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_shancaraRomInfo, nes_shancaraRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Seiryaku Simulation - Inbou no Wakusei - Shancara (Japan)
static struct BurnRomInfo nes_shancarajRomDesc[] = {
	{ "Seiryaku Simulation - Inbou no Wakusei - Shancara (J)(1992)(IGS).nes",          262160, 0xdcfe4112, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_shancaraj)
STD_ROM_FN(nes_shancaraj)

struct BurnDriver BurnDrvnes_shancaraj = {
	"nes_shancaraj", "nes_shancara", NULL, NULL, "1992",
	"Seiryaku Simulation - Inbou no Wakusei - Shancara (Japan)\0", NULL, "IGS Corporation", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 4, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_shancarajRomInfo, nes_shancarajRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Senjou no Ookami (Japan)
static struct BurnRomInfo nes_senjounoookamiRomDesc[] = {
	{ "Senjou no Ookami (Japan).nes",          131088, 0x982d11b5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_senjounoookami)
STD_ROM_FN(nes_senjounoookami)

struct BurnDriver BurnDrvnes_senjounoookami = {
	"nes_senjounoookami", NULL, NULL, NULL, "1986",
	"Senjou no Ookami (Japan)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_senjounoookamiRomInfo, nes_senjounoookamiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Shadow of the Ninja (USA)
static struct BurnRomInfo nes_shadoninRomDesc[] = {
	{ "Shadow of the Ninja (USA).nes",          262160, 0xf74a04ab, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_shadonin)
STD_ROM_FN(nes_shadonin)

struct BurnDriver BurnDrvnes_shadonin = {
	"nes_shadonin", NULL, NULL, NULL, "1990",
	"Shadow of the Ninja (USA)\0", NULL, "Natsume", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, nes_shadoninRomInfo, nes_shadoninRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Shadow Warriors (Euro)
static struct BurnRomInfo nes_shadowwarriorsRomDesc[] = {
	{ "Shadow Warriors (Europe).nes",          262160, 0x1d2fb2b7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_shadowwarriors)
STD_ROM_FN(nes_shadowwarriors)

struct BurnDriver BurnDrvnes_shadowwarriors = {
	"nes_shadowwarriors", "nes_ninjagaiden", NULL, NULL, "1991",
	"Shadow Warriors (Euro)\0", NULL, "Tecmo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, nes_shadowwarriorsRomInfo, nes_shadowwarriorsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL, SCREEN_WIDTH, SCREEN_HEIGHT_PAL
};

// Shadow Warriors Episode II - The Dark Sword of Chaos (Euro)
static struct BurnRomInfo nes_shadowarepiiiRomDesc[] = {
	{ "Shadow Warriors Episode II - The Dark Sword of Chaos (Europe).nes",          262160, 0x96b6a919, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_shadowarepiii)
STD_ROM_FN(nes_shadowarepiii)

struct BurnDriver BurnDrvnes_shadowarepiii = {
	"nes_shadowarepiii", "nes_ninjagaiii", NULL, NULL, "1991",
	"Shadow Warriors Episode II - The Dark Sword of Chaos (Euro)\0", NULL, "Tecmo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, nes_shadowarepiiiRomInfo, nes_shadowarepiiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL, SCREEN_WIDTH, SCREEN_HEIGHT_PAL
};

// Shadowgate (USA)
static struct BurnRomInfo nes_shadowgateRomDesc[] = {
	{ "Shadowgate (USA).nes",          262160, 0x6287952c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_shadowgate)
STD_ROM_FN(nes_shadowgate)

struct BurnDriver BurnDrvnes_shadowgate = {
	"nes_shadowgate", NULL, NULL, NULL, "1989",
	"Shadowgate (USA)\0", NULL, "Kemco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_shadowgateRomInfo, nes_shadowgateRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Shanghai (Japan)
static struct BurnRomInfo nes_shanghaiRomDesc[] = {
	{ "Shanghai (Japan).nes",          131088, 0x8ff2acfe, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_shanghai)
STD_ROM_FN(nes_shanghai)

struct BurnDriver BurnDrvnes_shanghai = {
	"nes_shanghai", NULL, NULL, NULL, "1987",
	"Shanghai (Japan)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_shanghaiRomInfo, nes_shanghaiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Shatterhand (USA)
static struct BurnRomInfo nes_shatterhandRomDesc[] = {
	{ "Shatterhand (USA).nes",          262160, 0x80b3ffaf, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_shatterhand)
STD_ROM_FN(nes_shatterhand)

struct BurnDriver BurnDrvnes_shatterhand = {
	"nes_shatterhand", NULL, NULL, NULL, "1991",
	"Shatterhand (USA)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_shatterhandRomInfo, nes_shatterhandRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Shin 4 Nin Uchi Mahjong (Japan)
static struct BurnRomInfo nes_shin4ninuchmaRomDesc[] = {
	{ "Shin 4 Nin Uchi Mahjong (Japan).nes",          393232, 0x44df4a58, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_shin4ninuchma)
STD_ROM_FN(nes_shin4ninuchma)

struct BurnDriver BurnDrvnes_shin4ninuchma = {
	"nes_shin4ninuchma", NULL, NULL, NULL, "1991",
	"Shin 4 Nin Uchi Mahjong (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_MAHJONG, 0,
	NESGetZipName, nes_shin4ninuchmaRomInfo, nes_shin4ninuchmaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Shinobi (USA) (Unl)
static struct BurnRomInfo nes_shinobiRomDesc[] = {
	{ "Shinobi (USA) (Unl).nes",          262160, 0xf4aa0c2e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_shinobi)
STD_ROM_FN(nes_shinobi)

struct BurnDriver BurnDrvnes_shinobi = {
	"nes_shinobi", NULL, NULL, NULL, "1989",
	"Shinobi (USA) (Unl)\0", NULL, "Tengen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_shinobiRomInfo, nes_shinobiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Shinobi Arcade (Hack, v2.1)
// https://www.romhacking.net/hacks/2348/
static struct BurnRomInfo nes_shinobiarcRomDesc[] = {
	{ "Shinobi Arcade v2.1 (2023)(the jabu).nes",          262160, 0x9d73be88, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_shinobiarc)
STD_ROM_FN(nes_shinobiarc)

struct BurnDriver BurnDrvnes_shinobiarc = {
	"nes_shinobiarc", "nes_shinobi", NULL, NULL, "2023",
	"Shinobi Arcade (Hack, v2.1)\0", NULL, "the jabu", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_shinobiarcRomInfo, nes_shinobiarcRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Shockwave (USA)
static struct BurnRomInfo nes_shockwaveRomDesc[] = {
	{ "Shockwave (USA).nes",          65552, 0x96f37945, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_shockwave)
STD_ROM_FN(nes_shockwave)

struct BurnDriver BurnDrvnes_shockwave = {
	"nes_shockwave", NULL, NULL, NULL, "1990",
	"Shockwave (USA)\0", NULL, "AGCI", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_shockwaveRomInfo, nes_shockwaveRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Shooting Range (USA)
static struct BurnRomInfo nes_shootingrangeRomDesc[] = {
	{ "Shooting Range (USA).nes",          65552, 0xca35a3a2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_shootingrange)
STD_ROM_FN(nes_shootingrange)

struct BurnDriver BurnDrvnes_shootingrange = {
	"nes_shootingrange", NULL, NULL, NULL, "1989",
	"Shooting Range (USA)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_shootingrangeRomInfo, nes_shootingrangeRomName, NULL, NULL, NULL, NULL, NESZapperInputInfo, NESZapperDIPInfo,
	NESZapperInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Shufflepuck Cafe (Japan)
static struct BurnRomInfo nes_shufflepuckcafejRomDesc[] = {
	{ "Shufflepuck Cafe (Japan).nes",          131088, 0x528af8b0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_shufflepuckcafej)
STD_ROM_FN(nes_shufflepuckcafej)

struct BurnDriver BurnDrvnes_shufflepuckcafej = {
	"nes_shufflepuckcafej", "nes_shufflepuckcafe", NULL, NULL, "1990",
	"Shufflepuck Cafe (Japan)\0", NULL, "Pony Canyon", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_BALLPADDLE, 0,
	NESGetZipName, nes_shufflepuckcafejRomInfo, nes_shufflepuckcafejRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Shufflepuck Cafe (Hack, English)
static struct BurnRomInfo nes_shufflepuckcafeRomDesc[] = {
	{ "Shufflepuck Cafe (T-Eng).nes",          131088, 0x60253774, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_shufflepuckcafe)
STD_ROM_FN(nes_shufflepuckcafe)

struct BurnDriver BurnDrvnes_shufflepuckcafe = {
	"nes_shufflepuckcafe", NULL, NULL, NULL, "2016",
	"Shufflepuck Cafe (Hack, English)\0", NULL, "MadHacker", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_BALLPADDLE, 0,
	NESGetZipName, nes_shufflepuckcafeRomInfo, nes_shufflepuckcafeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Side Pocket (USA)
static struct BurnRomInfo nes_sidepocketRomDesc[] = {
	{ "Side Pocket (USA).nes",          131088, 0x1fbacf06, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sidepocket)
STD_ROM_FN(nes_sidepocket)

struct BurnDriver BurnDrvnes_sidepocket = {
	"nes_sidepocket", NULL, NULL, NULL, "1987",
	"Side Pocket (USA)\0", NULL, "Data East", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_sidepocketRomInfo, nes_sidepocketRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Sidewinder (USA) (Unl)
static struct BurnRomInfo nes_sidewinderRomDesc[] = {
	{ "Sidewinder (USA).nes",          32784, 0x11b37264, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sidewinder)
STD_ROM_FN(nes_sidewinder)

struct BurnDriver BurnDrvnes_sidewinder = {
	"nes_sidewinder", "nes_missioncobra", NULL, NULL, "1989",
	"Sidewinder (USA) (Unl)\0", NULL, "Sachen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_sidewinderRomInfo, nes_sidewinderRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Silent Service (USA)
static struct BurnRomInfo nes_silentserviceRomDesc[] = {
	{ "Silent Service (USA).nes",          131088, 0x8b4a38b0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_silentservice)
STD_ROM_FN(nes_silentservice)

struct BurnDriver BurnDrvnes_silentservice = {
	"nes_silentservice", NULL, NULL, NULL, "1989",
	"Silent Service (USA)\0", NULL, "Ultra Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SIM, 0,
	NESGetZipName, nes_silentserviceRomInfo, nes_silentserviceRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Silk Worm (USA)
static struct BurnRomInfo nes_silkwormRomDesc[] = {
	{ "Silk Worm (USA).nes",          262160, 0x8af9b095, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_silkworm)
STD_ROM_FN(nes_silkworm)

struct BurnDriver BurnDrvnes_silkworm = {
	"nes_silkworm", NULL, NULL, NULL, "1990",
	"Silk Worm (USA)\0", NULL, "Sammy", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_silkwormRomInfo, nes_silkwormRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Silva Saga (Japan)
static struct BurnRomInfo nes_silvasagajRomDesc[] = {
	{ "Silva Saga (Japan).nes",          524304, 0x3648889b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_silvasagaj)
STD_ROM_FN(nes_silvasagaj)

struct BurnDriver BurnDrvnes_silvasagaj = {
	"nes_silvasagaj", "nes_silvasaga", NULL, NULL, "1992",
	"Silva Saga (Japan)\0", NULL, "Seta", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_silvasagajRomInfo, nes_silvasagajRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Silva Saga (Hack, English)
static struct BurnRomInfo nes_silvasagaRomDesc[] = {
	{ "Silva Saga (T-Eng).nes",          786448, 0x75a9eb48, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_silvasaga)
STD_ROM_FN(nes_silvasaga)

struct BurnDriver BurnDrvnes_silvasaga = {
	"nes_silvasaga", NULL, NULL, NULL, "2016",
	"Silva Saga (Hack, English)\0", NULL, "aishsha", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_silvasagaRomInfo, nes_silvasagaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Silver Eagle (Taiwan)
static struct BurnRomInfo nes_silvereagleRomDesc[] = {
	{ "Silver Eagle (Taiwan).nes",          262160, 0x16d7c36f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_silvereagle)
STD_ROM_FN(nes_silvereagle)

struct BurnDriver BurnDrvnes_silvereagle = {
	"nes_silvereagle", NULL, NULL, NULL, "1994",
	"Silver Eagle (Taiwan)\0", NULL, "Sachen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_silvereagleRomInfo, nes_silvereagleRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Silver Surfer (USA)
static struct BurnRomInfo nes_silversurferRomDesc[] = {
	{ "Silver Surfer (USA).nes",          393232, 0x9a83817c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_silversurfer)
STD_ROM_FN(nes_silversurfer)

struct BurnDriver BurnDrvnes_silversurfer = {
	"nes_silversurfer", NULL, NULL, NULL, "1990",
	"Silver Surfer (USA)\0", NULL, "Arcadia", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_silversurferRomInfo, nes_silversurferRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_simcityRomDesc[] = {
	{ "Sim City (Prototype).nes",          262160, 0x6dcc8626, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_simcity)
STD_ROM_FN(nes_simcity)

struct BurnDriver BurnDrvnes_simcity = {
	"nes_simcity", NULL, NULL, NULL, "1991",
	"Sim City (Prototype)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_PROTOTYPE, 1, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_simcityRomInfo, nes_simcityRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_simpsbarvsspamuRomDesc[] = {
	{ "Simpsons, The - Bart vs. the Space Mutants (USA) (Rev A).nes",          262160, 0xc8602800, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_simpsbarvsspamu)
STD_ROM_FN(nes_simpsbarvsspamu)

struct BurnDriver BurnDrvnes_simpsbarvsspamu = {
	"nes_simpsbarvsspamu", NULL, NULL, NULL, "1991",
	"Simpsons, The - Bart vs. the Space Mutants (USA) (Rev A)\0", NULL, "Acclaim", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_simpsbarvsspamuRomInfo, nes_simpsbarvsspamuRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_simpsbarvsworRomDesc[] = {
	{ "Simpsons, The - Bart vs. the World (USA).nes",          393232, 0x5101bae1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_simpsbarvswor)
STD_ROM_FN(nes_simpsbarvswor)

struct BurnDriver BurnDrvnes_simpsbarvswor = {
	"nes_simpsbarvswor", NULL, NULL, NULL, "1991",
	"Simpsons, The - Bart vs. the World (USA)\0", NULL, "Acclaim", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_simpsbarvsworRomInfo, nes_simpsbarvsworRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_simpsbarmeeradmanRomDesc[] = {
	{ "Simpsons, The - Bartman Meets Radioactive Man (USA).nes",          393232, 0x7c86930e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_simpsbarmeeradman)
STD_ROM_FN(nes_simpsbarmeeradman)

struct BurnDriver BurnDrvnes_simpsbarmeeradman = {
	"nes_simpsbarmeeradman", NULL, NULL, NULL, "1992",
	"Simpsons, The - Bartman Meets Radioactive Man (USA)\0", NULL, "Acclaim", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_simpsbarmeeradmanRomInfo, nes_simpsbarmeeradmanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_skateboyRomDesc[] = {
	{ "Skate Boy (Spain) (Gluk Video) (Unl).nes",          40976, 0xb8fda07b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_skateboy)
STD_ROM_FN(nes_skateboy)

struct BurnDriver BurnDrvnes_skateboy = {
	"nes_skateboy", NULL, NULL, NULL, "1992",
	"Skate Boy (Spain) (Gluk Video) (Unl)\0", NULL, "Gluk Video", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_skateboyRomInfo, nes_skateboyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_skateordieRomDesc[] = {
	{ "Skate or Die (USA).nes",          131088, 0x713309ba, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_skateordie)
STD_ROM_FN(nes_skateordie)

struct BurnDriver BurnDrvnes_skateordie = {
	"nes_skateordie", NULL, NULL, NULL, "1988",
	"Skate or Die (USA)\0", NULL, "Ultra Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_skateordieRomInfo, nes_skateordieRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_skateordie2RomDesc[] = {
	{ "Skate or Die 2 - The Search for Double Trouble (USA).nes",          393232, 0x290296d4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_skateordie2)
STD_ROM_FN(nes_skateordie2)

struct BurnDriver BurnDrvnes_skateordie2 = {
	"nes_skateordie2", NULL, NULL, NULL, "1990",
	"Skate or Die 2 - The Search for Double Trouble (USA)\0", NULL, "Electronic Arts", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_skateordie2RomInfo, nes_skateordie2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_skiordieRomDesc[] = {
	{ "Ski or Die (USA).nes",          262160, 0x8415e33f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_skiordie)
STD_ROM_FN(nes_skiordie)

struct BurnDriver BurnDrvnes_skiordie = {
	"nes_skiordie", NULL, NULL, NULL, "1991",
	"Ski or Die (USA)\0", NULL, "Ultra Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_skiordieRomInfo, nes_skiordieRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_skullcroRomDesc[] = {
	{ "Skull & Crossbones (USA) (Unl).nes",          196624, 0xa8b93a4b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_skullcro)
STD_ROM_FN(nes_skullcro)

struct BurnDriver BurnDrvnes_skullcro = {
	"nes_skullcro", NULL, NULL, NULL, "1990",
	"Skull & Crossbones (USA)\0", NULL, "Tengen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_skullcroRomInfo, nes_skullcroRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_skydestroyerRomDesc[] = {
	{ "Sky Destroyer (Japan).nes",          24592, 0x6fe201bd, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_skydestroyer)
STD_ROM_FN(nes_skydestroyer)

struct BurnDriver BurnDrvnes_skydestroyer = {
	"nes_skydestroyer", NULL, NULL, NULL, "1985",
	"Sky Destroyer (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_skydestroyerRomInfo, nes_skydestroyerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_skykidRomDesc[] = {
	{ "Sky Kid (USA).nes",          163856, 0x8b190ddc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_skykid)
STD_ROM_FN(nes_skykid)

struct BurnDriver BurnDrvnes_skykid = {
	"nes_skykid", NULL, NULL, NULL, "1987",
	"Sky Kid (USA)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_skykidRomInfo, nes_skykidRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_skysharkRomDesc[] = {
	{ "Sky Shark (USA) (Rev 0A).nes",          196624, 0x147e6b6c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_skyshark)
STD_ROM_FN(nes_skyshark)

struct BurnDriver BurnDrvnes_skyshark = {
	"nes_skyshark", NULL, NULL, NULL, "1989",
	"Sky Shark (USA) (Rev 0A)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_skysharkRomInfo, nes_skysharkRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Slalom (USA)
static struct BurnRomInfo nes_slalomRomDesc[] = {
	{ "Slalom (USA).nes",          40976, 0x6115164d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_slalom)
STD_ROM_FN(nes_slalom)

struct BurnDriver BurnDrvnes_slalom = {
	"nes_slalom", NULL, NULL, NULL, "1987",
	"Slalom (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_slalomRomInfo, nes_slalomRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Smash T.V. (USA)
static struct BurnRomInfo nes_smashtvRomDesc[] = {
	{ "Smash T.V. (USA).nes",          262160, 0x447a45a0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_smashtv)
STD_ROM_FN(nes_smashtv)

struct BurnDriver BurnDrvnes_smashtv = {
	"nes_smashtv", NULL, NULL, NULL, "1991",
	"Smash T.V. (USA)\0", NULL, "Acclaim", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_smashtvRomInfo, nes_smashtvRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Smurfs, The (Euro)
static struct BurnRomInfo nes_smurfsRomDesc[] = {
	{ "Smurfs, The PAL (1994)(Infogrames).nes",          131088, 0x732b1a7a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_smurfs)
STD_ROM_FN(nes_smurfs)

struct BurnDriver BurnDrvnes_smurfs = {
	"nes_smurfs", NULL, NULL, NULL, "1994",
	"Smurfs, The (Euro)\0", NULL, "Infogrames", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_smurfsRomInfo, nes_smurfsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL, SCREEN_WIDTH, SCREEN_HEIGHT_PAL
};

// Snake Rattle n Roll (USA)
static struct BurnRomInfo nes_snakeratnrolRomDesc[] = {
	{ "Snake Rattle n Roll (USA).nes",          65552, 0x558f9a33, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_snakeratnrol)
STD_ROM_FN(nes_snakeratnrol)

struct BurnDriver BurnDrvnes_snakeratnrol = {
	"nes_snakeratnrol", NULL, NULL, NULL, "1990",
	"Snake Rattle n Roll (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_snakeratnrolRomInfo, nes_snakeratnrolRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Snake's Revenge (USA)
static struct BurnRomInfo nes_snakesrevengeRomDesc[] = {
	{ "Snake's Revenge (USA).nes",          262160, 0x255a25fe, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_snakesrevenge)
STD_ROM_FN(nes_snakesrevenge)

struct BurnDriver BurnDrvnes_snakesrevenge = {
	"nes_snakesrevenge", NULL, NULL, NULL, "1990",
	"Snake's Revenge (USA)\0", NULL, "Ultra Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_ADV, 0,
	NESGetZipName, nes_snakesrevengeRomInfo, nes_snakesrevengeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Snoopy's Silly Sports Spectacular (USA)
static struct BurnRomInfo nes_snoopssilspospRomDesc[] = {
	{ "Snoopy's Silly Sports Spectacular (USA).nes",          262160, 0xc5211378, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_snoopssilsposp)
STD_ROM_FN(nes_snoopssilsposp)

struct BurnDriver BurnDrvnes_snoopssilsposp = {
	"nes_snoopssilsposp", NULL, NULL, NULL, "1990",
	"Snoopy's Silly Sports Spectacular (USA)\0", NULL, "Kemco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_snoopssilspospRomInfo, nes_snoopssilspospRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Snow Brothers (USA)
static struct BurnRomInfo nes_snowbrothersRomDesc[] = {
	{ "Snow Brothers (USA).nes",          262160, 0x701f4326, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_snowbrothers)
STD_ROM_FN(nes_snowbrothers)

struct BurnDriver BurnDrvnes_snowbrothers = {
	"nes_snowbrothers", NULL, NULL, NULL, "1991",
	"Snow Brothers (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_snowbrothersRomInfo, nes_snowbrothersRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Soccer (USA)
static struct BurnRomInfo nes_soccerRomDesc[] = {
	{ "Soccer (USA).nes",          40976, 0x820d62ab, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_soccer)
STD_ROM_FN(nes_soccer)

struct BurnDriver BurnDrvnes_soccer = {
	"nes_soccer", NULL, NULL, NULL, "1985",
	"Soccer (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSFOOTBALL, 0,
	NESGetZipName, nes_soccerRomInfo, nes_soccerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_socceleaRomDesc[] = {
	{ "Soccer League - Winner's Cup (Japan).nes",          262160, 0xe08f129d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_soccelea)
STD_ROM_FN(nes_soccelea)

struct BurnDriver BurnDrvnes_soccelea = {
	"nes_soccelea", NULL, NULL, NULL, "1988",
	"Soccer League - Winner's Cup (Japan)\0", NULL, "Data East", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSFOOTBALL, 0,
	NESGetZipName, nes_socceleaRomInfo, nes_socceleaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Solar Jetman - Hunt for the Golden Warpship (USA)
static struct BurnRomInfo nes_solarjetRomDesc[] = {
	{ "Solar Jetman - Hunt for the Golden Warpship (USA).nes",          262160, 0x1c17ce33, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_solarjet)
STD_ROM_FN(nes_solarjet)

struct BurnDriver BurnDrvnes_solarjet = {
	"nes_solarjet", NULL, NULL, NULL, "1990",
	"Solar Jetman - Hunt for the Golden Warpship (USA)\0", NULL, "Tradewest", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_solarjetRomInfo, nes_solarjetRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Solitaire (USA) (Rev 1.1)
static struct BurnRomInfo nes_solitaireRomDesc[] = {
	{ "Solitaire REV1.1 (U)(1992)(AVE).nes",          65552, 0x74aad703, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_solitaire)
STD_ROM_FN(nes_solitaire)

struct BurnDriver BurnDrvnes_solitaire = {
	"nes_solitaire", NULL, NULL, NULL, "1992",
	"Solitaire (USA) (Rev 1.1)\0", NULL, "American Video Entertainment", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_CARD, 0,
	NESGetZipName, nes_solitaireRomInfo, nes_solitaireRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Solomon's Key (USA)
static struct BurnRomInfo nes_solomonskeyRomDesc[] = {
	{ "Solomon's Key (USA).nes",          65552, 0x99773bc4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_solomonskey)
STD_ROM_FN(nes_solomonskey)

struct BurnDriver BurnDrvnes_solomonskey = {
	"nes_solomonskey", NULL, NULL, NULL, "1987",
	"Solomon's Key (USA)\0", NULL, "Tecmo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM | GBF_PUZZLE, 0,
	NESGetZipName, nes_solomonskeyRomInfo, nes_solomonskeyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Solomon no Kagi (Japan)
static struct BurnRomInfo nes_solomonskeyjRomDesc[] = {
	{ "Solomon no Kagi (Jpn)(1986)(Tecmo).nes",          65552, 0x013ed497, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_solomonskeyj)
STD_ROM_FN(nes_solomonskeyj)

struct BurnDriver BurnDrvnes_solomonskeyj = {
	"nes_solomonskeyj", "nes_solomonskey", NULL, NULL, "1986",
	"Solomon no Kagi (Japan)\0", NULL, "Tecmo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM | GBF_PUZZLE, 0,
	NESGetZipName, nes_solomonskeyjRomInfo, nes_solomonskeyjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Solstice - Sanjigen Meikyuu no Kyoujuu (Japan)
static struct BurnRomInfo nes_solsticeRomDesc[] = {
	{ "Solstice (Japan)(1990)(Epic-Sony Records).nes",          131088, 0x59bb08e7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_solstice)
STD_ROM_FN(nes_solstice)

struct BurnDriver BurnDrvnes_solstice = {
	"nes_solstice", "nes_solst", NULL, NULL, "1990",
	"Solstice - Sanjigen Meikyuu no Kyoujuu (Japan)\0", NULL, "Epic/Sony Records", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM | GBF_PUZZLE, 0,
	NESGetZipName, nes_solsticeRomInfo, nes_solsticeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Solstice - The Quest for the Staff of Demnos (USA)
static struct BurnRomInfo nes_solstRomDesc[] = {
	{ "Solstice - The Quest for the Staff of Demnos (USA)(1990)(Sony Imagesoft).nes",          131088, 0x1d60732e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_solst)
STD_ROM_FN(nes_solst)

struct BurnDriver BurnDrvnes_solst = {
	"nes_solst", NULL, NULL, NULL, "1990",
	"Solstice - The Quest for the Staff of Demnos (USA)\0", NULL, "Sony Imagesoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM | GBF_PUZZLE, 0,
	NESGetZipName, nes_solstRomInfo, nes_solstRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Son Son (Japan)
static struct BurnRomInfo nes_sonsonRomDesc[] = {
	{ "Son Son (Japan).nes",          40976, 0xf7c8f42d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sonson)
STD_ROM_FN(nes_sonson)

struct BurnDriver BurnDrvnes_sonson = {
	"nes_sonson", NULL, NULL, NULL, "1986",
	"Son Son (Japan)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_sonsonRomInfo, nes_sonsonRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Space Harrier (Japan)
static struct BurnRomInfo nes_spaceharrierRomDesc[] = {
	{ "Space Harrier (Japan).nes",          131088, 0x91930e95, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_spaceharrier)
STD_ROM_FN(nes_spaceharrier)

struct BurnDriver BurnDrvnes_spaceharrier = {
	"nes_spaceharrier", NULL, NULL, NULL, "1989",
	"Space Harrier (Japan)\0", NULL, "Takara", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_spaceharrierRomInfo, nes_spaceharrierRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Space Hunter (Japan)
static struct BurnRomInfo nes_spacehunterRomDesc[] = {
	{ "Space Hunter (Japan).nes",          65552, 0xb155899c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_spacehunter)
STD_ROM_FN(nes_spacehunter)

struct BurnDriver BurnDrvnes_spacehunter = {
	"nes_spacehunter", NULL, NULL, NULL, "1986",
	"Space Hunter (Japan)\0", NULL, "Kemco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_spacehunterRomInfo, nes_spacehunterRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Space Invaders (Japan)
static struct BurnRomInfo nes_spaceinvadersRomDesc[] = {
	{ "Space Invaders (Japan).nes",          24592, 0x525c0dab, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_spaceinvaders)
STD_ROM_FN(nes_spaceinvaders)

struct BurnDriver BurnDrvnes_spaceinvaders = {
	"nes_spaceinvaders", NULL, NULL, NULL, "1985",
	"Space Invaders (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_spaceinvadersRomInfo, nes_spaceinvadersRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Spartan X (Japan)
static struct BurnRomInfo nes_spartanxRomDesc[] = {
	{ "Spartan X (Japan).nes",          40976, 0x872adc83, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_spartanx)
STD_ROM_FN(nes_spartanx)

struct BurnDriver BurnDrvnes_spartanx = {
	"nes_spartanx", NULL, NULL, NULL, "1985",
	"Spartan X (Japan)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_spartanxRomInfo, nes_spartanxRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Spartan X 2 (Japan)
static struct BurnRomInfo nes_spartanx2jRomDesc[] = {
	{ "Spartan X 2 (Japan).nes",          262160, 0x09825979, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_spartanx2j)
STD_ROM_FN(nes_spartanx2j)

struct BurnDriver BurnDrvnes_spartanx2j = {
	"nes_spartanx2j", "nes_spartanx2", NULL, NULL, "1991",
	"Spartan X 2 (Japan)\0", NULL, "Irem", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_spartanx2jRomInfo, nes_spartanx2jRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Spartan X 2 (Hack, English)
static struct BurnRomInfo nes_spartanx2RomDesc[] = {
	{ "Spartan X 2 (T-Eng).nes",          262160, 0x30003fc6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_spartanx2)
STD_ROM_FN(nes_spartanx2)

struct BurnDriver BurnDrvnes_spartanx2 = {
	"nes_spartanx2", NULL, NULL, NULL, "2003",
	"Spartan X 2 (Hack, English)\0", NULL, "Abstract Crouton Productions", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_spartanx2RomInfo, nes_spartanx2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Spelunker (USA)
static struct BurnRomInfo nes_spelunkerRomDesc[] = {
	{ "Spelunker (USA).nes",          40976, 0x7ea3404f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_spelunker)
STD_ROM_FN(nes_spelunker)

struct BurnDriver BurnDrvnes_spelunker = {
	"nes_spelunker", NULL, NULL, NULL, "1987",
	"Spelunker (USA)\0", NULL, "Broderbund", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_spelunkerRomInfo, nes_spelunkerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Spelunker II - Yuusha e no Chousen (Japan)
static struct BurnRomInfo nes_speluiijRomDesc[] = {
	{ "Spelunker II - Yuusha e no Chousen (Japan).nes",          131088, 0xf076f168, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_speluiij)
STD_ROM_FN(nes_speluiij)

struct BurnDriver BurnDrvnes_speluiij = {
	"nes_speluiij", "nes_speluii", NULL, NULL, "1987",
	"Spelunker II - Yuusha e no Chousen (Japan)\0", NULL, "Irem", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_speluiijRomInfo, nes_speluiijRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Spelunker II - Yuusha e no Chousen (Hack, English)
static struct BurnRomInfo nes_speluiiRomDesc[] = {
	{ "Spelunker II - Yuusha e no Chousen (T-eng).nes",          262160, 0x72a28744, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_speluii)
STD_ROM_FN(nes_speluii)

struct BurnDriver BurnDrvnes_speluii = {
	"nes_speluii", NULL, NULL, NULL, "2003",
	"Spelunker II - Yuusha e no Chousen (Hack, English)\0", NULL, "Sarysa", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_speluiiRomInfo, nes_speluiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Spider-Man - Return of the Sinister Six (USA)
static struct BurnRomInfo nes_spidemanRomDesc[] = {
	{ "Spider-Man - Return of the Sinister Six (USA).nes",          393232, 0x095b180b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_spideman)
STD_ROM_FN(nes_spideman)

struct BurnDriver BurnDrvnes_spideman = {
	"nes_spideman", NULL, NULL, NULL, "1992",
	"Spider-Man - Return of the Sinister Six (USA)\0", NULL, "Ljn", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_spidemanRomInfo, nes_spidemanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Splatter House - Wanpaku Graffiti (Japan)
static struct BurnRomInfo nes_splathouRomDesc[] = {
	{ "Splatter House - Wanpaku Graffiti (Japan).nes",          262160, 0xb7eeb48b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_splathou)
STD_ROM_FN(nes_splathou)

struct BurnDriver BurnDrvnes_splathou = {
	"nes_splathou", NULL, NULL, NULL, "1989",
	"Splatter House - Wanpaku Graffiti (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM | GBF_SCRFIGHT, 0,
	NESGetZipName, nes_splathouRomInfo, nes_splathouRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Spot (USA)
static struct BurnRomInfo nes_spotRomDesc[] = {
	{ "Spot (USA).nes",          131088, 0x1d6e0953, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_spot)
STD_ROM_FN(nes_spot)

struct BurnDriver BurnDrvnes_spot = {
	"nes_spot", NULL, NULL, NULL, "1990",
	"Spot (USA)\0", NULL, "Arcadia", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_spotRomInfo, nes_spotRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Spy Hunter (USA)
static struct BurnRomInfo nes_spyhunterRomDesc[] = {
	{ "Spy Hunter (USA).nes",          65552, 0x1e060ae0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_spyhunter)
STD_ROM_FN(nes_spyhunter)

struct BurnDriver BurnDrvnes_spyhunter = {
	"nes_spyhunter", NULL, NULL, NULL, "1987",
	"Spy Hunter (USA)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RACING | GBF_VERSHOOT, 0,
	NESGetZipName, nes_spyhunterRomInfo, nes_spyhunterRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Spy vs Spy (USA)
static struct BurnRomInfo nes_spyvsspyRomDesc[] = {
	{ "Spy vs Spy (USA).nes",          40976, 0x23d23dcc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_spyvsspy)
STD_ROM_FN(nes_spyvsspy)

struct BurnDriver BurnDrvnes_spyvsspy = {
	"nes_spyvsspy", NULL, NULL, NULL, "1988",
	"Spy vs Spy (USA)\0", NULL, "Kemco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION | GBF_STRATEGY, 0,
	NESGetZipName, nes_spyvsspyRomInfo, nes_spyvsspyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Spy vs Spy - The Island Caper (Japan)
static struct BurnRomInfo nes_spyvsspyislcajRomDesc[] = {
	{ "Spy vs Spy - The Island Caper (Japan).nes",          131088, 0x23dff27d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_spyvsspyislcaj)
STD_ROM_FN(nes_spyvsspyislcaj)

struct BurnDriver BurnDrvnes_spyvsspyislcaj = {
	"nes_spyvsspyislcaj", "nes_spyvsspyislca", NULL, NULL, "1987",
	"Spy vs Spy - The Island Caper (Japan)\0", NULL, "Kemco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_ACTION | GBF_STRATEGY, 0,
	NESGetZipName, nes_spyvsspyislcajRomInfo, nes_spyvsspyislcajRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Spy vs Spy - The Island Caper (Hack, English)
static struct BurnRomInfo nes_spyvsspyislcaRomDesc[] = {
	{ "Spy vs Spy - The Island Caper (T-Eng).nes",          131088, 0xf9e51c93, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_spyvsspyislca)
STD_ROM_FN(nes_spyvsspyislca)

struct BurnDriver BurnDrvnes_spyvsspyislca = {
	"nes_spyvsspyislca", NULL, NULL, NULL, "2015",
	"Spy vs Spy - The Island Caper (Hack, English)\0", NULL, "pacnsacdave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_NES, GBF_ACTION | GBF_STRATEGY, 0,
	NESGetZipName, nes_spyvsspyislcaRomInfo, nes_spyvsspyislcaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Sqoon (USA)
static struct BurnRomInfo nes_sqoonRomDesc[] = {
	{ "Sqoon (USA).nes",          40976, 0xa3815bac, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sqoon)
STD_ROM_FN(nes_sqoon)

struct BurnDriver BurnDrvnes_sqoon = {
	"nes_sqoon", NULL, NULL, NULL, "1987",
	"Sqoon (USA)\0", NULL, "Irem", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_sqoonRomInfo, nes_sqoonRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Squashed (USA) (Prototype)
static struct BurnRomInfo nes_squashedRomDesc[] = {
	{ "Squashed (USA) (Proto).nes",          262160, 0xdaad65e0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_squashed)
STD_ROM_FN(nes_squashed)

struct BurnDriver BurnDrvnes_squashed = {
	"nes_squashed", NULL, NULL, NULL, "1991",
	"Squashed (USA) (Prototype)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_PROTOTYPE, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_squashedRomInfo, nes_squashedRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Stanley - The Search for Dr. Livingston (USA)
static struct BurnRomInfo nes_stanleyRomDesc[] = {
	{ "Stanley - The Search for Dr. Livingston (USA).nes",          262160, 0x4871ef6e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_stanley)
STD_ROM_FN(nes_stanley)

struct BurnDriver BurnDrvnes_stanley = {
	"nes_stanley", NULL, NULL, NULL, "1992",
	"Stanley - The Search for Dr. Livingston (USA)\0", NULL, "Electro Brain", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_stanleyRomInfo, nes_stanleyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Lasalle Ishii no Child's Quest (Japan)
static struct BurnRomInfo nes_lasalishiiRomDesc[] = {
	{ "Lasalle Ishii no Child's Quest (J)(1989)(Namcot).nes",          196624, 0xc78d14f9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_lasalishii)
STD_ROM_FN(nes_lasalishii)

struct BurnDriver BurnDrvnes_lasalishii = {
	"nes_lasalishii", "nes_stardomwar", NULL, NULL, "1989",
	"Lasalle Ishii no Child's Quest (Japan)\0", NULL, "Namcot", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_lasalishiiRomInfo, nes_lasalishiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Stardom Warriors (Hack, English)
// https://www.romhacking.net/translations/7115/
static struct BurnRomInfo nes_stardomwarRomDesc[] = {
	{ "Stardom Warriors T-Eng (2023)(Polinym).nes",          196624, 0x8d36c66b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_stardomwar)
STD_ROM_FN(nes_stardomwar)

struct BurnDriver BurnDrvnes_stardomwar = {
	"nes_stardomwar", NULL, NULL, NULL, "2023",
	"Stardom Warriors (Hack, English)\0", NULL, "Polinym", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_stardomwarRomInfo, nes_stardomwarRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Star Force (USA)
static struct BurnRomInfo nes_starforceRomDesc[] = {
	{ "Star Force (USA).nes",          65552, 0xb3cf12b8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_starforce)
STD_ROM_FN(nes_starforce)

struct BurnDriver BurnDrvnes_starforce = {
	"nes_starforce", NULL, NULL, NULL, "1987",
	"Star Force (USA)\0", NULL, "Tecmo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_starforceRomInfo, nes_starforceRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Star Gate (Japan)
static struct BurnRomInfo nes_stargateRomDesc[] = {
	{ "Star Gate (Japan).nes",          24592, 0x2b265d30, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_stargate)
STD_ROM_FN(nes_stargate)

struct BurnDriver BurnDrvnes_stargate = {
	"nes_stargate", NULL, NULL, NULL, "1987",
	"Star Gate (Japan)\0", NULL, "HAL Laboratory", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_stargateRomInfo, nes_stargateRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Hoshi wo Miru Hito (Japan)
static struct BurnRomInfo nes_hosmiruhitoRomDesc[] = {
	{ "Hoshi wo Miru Hito (J)(1987)(Hot-B).nes",          131088, 0x0ec30976, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_hosmiruhito)
STD_ROM_FN(nes_hosmiruhito)

struct BurnDriver BurnDrvnes_hosmiruhito = {
	"nes_hosmiruhito", "nes_stargazers", NULL, NULL, "1987",
	"Hoshi wo Miru Hito (Japan)\0", NULL, "Hot-B", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_hosmiruhitoRomInfo, nes_hosmiruhitoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Stargazers (Hack, English)
// https://www.romhacking.net/translations/7105/
static struct BurnRomInfo nes_stargazersRomDesc[] = {
	{ "Stargazers T-Eng (2023)(brandnewscooby).nes",          262160, 0x06feb35c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_stargazers)
STD_ROM_FN(nes_stargazers)

struct BurnDriver BurnDrvnes_stargazers = {
	"nes_stargazers", NULL, NULL, NULL, "2023",
	"Stargazers (Hack, English)\0", NULL, "brandnewscooby", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_stargazersRomInfo, nes_stargazersRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Star Luster (Japan)
static struct BurnRomInfo nes_starlusterRomDesc[] = {
	{ "Star Luster (Japan).nes",          40976, 0xd8604b5a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_starluster)
STD_ROM_FN(nes_starluster)

struct BurnDriver BurnDrvnes_starluster = {
	"nes_starluster", NULL, NULL, NULL, "1985",
	"Star Luster (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SIM | GBF_SHOOT, 0,
	NESGetZipName, nes_starlusterRomInfo, nes_starlusterRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Star Soldier (USA)
static struct BurnRomInfo nes_starsoldierRomDesc[] = {
	{ "Star Soldier (USA).nes",          65552, 0x69004001, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_starsoldier)
STD_ROM_FN(nes_starsoldier)

struct BurnDriver BurnDrvnes_starsoldier = {
	"nes_starsoldier", NULL, NULL, NULL, "1989",
	"Star Soldier (USA)\0", NULL, "Taxan", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_starsoldierRomInfo, nes_starsoldierRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Star Trek - 25th Anniversary (USA)
static struct BurnRomInfo nes_startre25tannRomDesc[] = {
	{ "Star Trek - 25th Anniversary (USA).nes",          524304, 0x76356073, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_startre25tann)
STD_ROM_FN(nes_startre25tann)

struct BurnDriver BurnDrvnes_startre25tann = {
	"nes_startre25tann", NULL, NULL, NULL, "1992",
	"Star Trek - 25th Anniversary (USA)\0", NULL, "Ultra Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_startre25tannRomInfo, nes_startre25tannRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Star Trek - The Next Generation (USA)
static struct BurnRomInfo nes_startrenexgenRomDesc[] = {
	{ "Star Trek - The Next Generation (USA).nes",          131088, 0x268202ae, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_startrenexgen)
STD_ROM_FN(nes_startrenexgen)

struct BurnDriver BurnDrvnes_startrenexgen = {
	"nes_startrenexgen", NULL, NULL, NULL, "1993",
	"Star Trek - The Next Generation (USA)\0", NULL, "Absolute", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SIM, 0,
	NESGetZipName, nes_startrenexgenRomInfo, nes_startrenexgenRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Star Trek V - The Final Frontier (Prototype)
static struct BurnRomInfo nes_startrevfinfrRomDesc[] = {
	{ "Star Trek V - The Final Frontier (Prototype).nes",          262160, 0x49365548, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_startrevfinfr)
STD_ROM_FN(nes_startrevfinfr)

struct BurnDriver BurnDrvnes_startrevfinfr = {
	"nes_startrevfinfr", NULL, NULL, NULL, "1989",
	"Star Trek V - The Final Frontier (Prototype)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_PROTOTYPE, 1, HARDWARE_NES, GBF_PLATFORM | GBF_RUNGUN, 0,
	NESGetZipName, nes_startrevfinfrRomInfo, nes_startrevfinfrRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Star Voyager (USA)
static struct BurnRomInfo nes_starvoyagerRomDesc[] = {
	{ "Star Voyager (USA).nes",          65552, 0x686d4669, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_starvoyager)
STD_ROM_FN(nes_starvoyager)

struct BurnDriver BurnDrvnes_starvoyager = {
	"nes_starvoyager", NULL, NULL, NULL, "1987",
	"Star Voyager (USA)\0", NULL, "Acclaim", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SIM | GBF_SHOOT, 0,
	NESGetZipName, nes_starvoyagerRomInfo, nes_starvoyagerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Star Wars (Namco) (Japan)
static struct BurnRomInfo nes_starwarsjRomDesc[] = {
	{ "Star Wars (Namco) (Japan).nes",          262160, 0xcce17a0e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_starwarsj)
STD_ROM_FN(nes_starwarsj)

struct BurnDriver BurnDrvnes_starwarsj = {
	"nes_starwarsj", "nes_starwars", NULL, NULL, "1987",
	"Star Wars (Namco) (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_starwarsjRomInfo, nes_starwarsjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Star Wars (Namco) (Hack, English)
static struct BurnRomInfo nes_starwarstRomDesc[] = {
	{ "Star Wars (Namco) (T-eng).nes",          262160, 0x8c04cec8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_starwarst)
STD_ROM_FN(nes_starwarst)

struct BurnDriver BurnDrvnes_starwarst = {
	"nes_starwarst", "nes_starwars", NULL, NULL, "2005",
	"Star Wars (Namco) (Hack, English)\0", NULL, "Mukimuki & Shinta", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_starwarstRomInfo, nes_starwarstRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Star Wars (USA)
static struct BurnRomInfo nes_starwarsRomDesc[] = {
	{ "Star Wars (USA).nes",          262160, 0xeb506bf9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_starwars)
STD_ROM_FN(nes_starwars)

struct BurnDriver BurnDrvnes_starwars = {
	"nes_starwars", NULL, NULL, NULL, "1991",
	"Star Wars (USA)\0", NULL, "JVC", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_starwarsRomInfo, nes_starwarsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Star Wars - The Empire Strikes Back (USA)
static struct BurnRomInfo nes_starwaresbRomDesc[] = {
	{ "Star Wars - The Empire Strikes Back (USA).nes",          524304, 0x44d3224f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_starwaresb)
STD_ROM_FN(nes_starwaresb)

struct BurnDriver BurnDrvnes_starwaresb = {
	"nes_starwaresb", NULL, NULL, NULL, "1992",
	"Star Wars - The Empire Strikes Back (USA)\0", NULL, "JVC", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_starwaresbRomInfo, nes_starwaresbRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Star Wars - The Empire Strikes Back Easy (Hack)
static struct BurnRomInfo nes_starwaresbeasRomDesc[] = {
	{ "Star Wars - The Empire Strikes Back Easy (Hack).nes",          524304, 0x11be60fe, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_starwaresbeas)
STD_ROM_FN(nes_starwaresbeas)

struct BurnDriver BurnDrvnes_starwaresbeas = {
	"nes_starwaresbeas", "nes_starwaresb", NULL, NULL, "2019",
	"Star Wars - The Empire Strikes Back Easy (Hack)\0", NULL, "chronix", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_starwaresbeasRomInfo, nes_starwaresbeasRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Star Wars Easy (Hack)
static struct BurnRomInfo nes_starwarseasyRomDesc[] = {
	{ "Star Wars Easy (Hack).nes",          262160, 0x964f462d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_starwarseasy)
STD_ROM_FN(nes_starwarseasy)

struct BurnDriver BurnDrvnes_starwarseasy = {
	"nes_starwarseasy", "nes_starwars", NULL, NULL, "2018",
	"Star Wars Easy (Hack)\0", NULL, "chronix", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_starwarseasyRomInfo, nes_starwarseasyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Starship Hector (USA)
static struct BurnRomInfo nes_starshiphectorRomDesc[] = {
	{ "Starship Hector (USA).nes",          131088, 0xac4af6a0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_starshiphector)
STD_ROM_FN(nes_starshiphector)

struct BurnDriver BurnDrvnes_starshiphector = {
	"nes_starshiphector", NULL, NULL, NULL, "1990",
	"Starship Hector (USA)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_starshiphectorRomInfo, nes_starshiphectorRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// StarTropics (USA)
static struct BurnRomInfo nes_startropicsRomDesc[] = {
	{ "StarTropics (USA).nes",          524304, 0x88504279, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_startropics)
STD_ROM_FN(nes_startropics)

struct BurnDriver BurnDrvnes_startropics = {
	"nes_startropics", NULL, NULL, NULL, "1990",
	"StarTropics (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_startropicsRomInfo, nes_startropicsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// StarTropics - Music Fix (Hack)
// https://www.romhacking.net/reviews/10836
static struct BurnRomInfo nes_startropicsmfRomDesc[] = {
	{ "Startropics - Music Fix (2023)(rainwarrior).nes",          524304, 0x5aab03a2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_startropicsmf)
STD_ROM_FN(nes_startropicsmf)

struct BurnDriver BurnDrvnes_startropicsmf = {
	"nes_startropicsmf", "nes_startropics", NULL, NULL, "2023",
	"StarTropics - Music Fix (Hack)\0", NULL, "rainwarrior", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_startropicsmfRomInfo, nes_startropicsmfRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Startropics II - Zoda's Revenge (USA)
static struct BurnRomInfo nes_startiiRomDesc[] = {
	{ "Startropics II - Zoda's Revenge (USA).nes",          524304, 0x76124d08, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_startii)
STD_ROM_FN(nes_startii)

struct BurnDriver BurnDrvnes_startii = {
	"nes_startii", NULL, NULL, NULL, "1994",
	"Startropics II - Zoda's Revenge (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_startiiRomInfo, nes_startiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Sted - Iseki Wakusei no Yabou (Japan)
static struct BurnRomInfo nes_stedjRomDesc[] = {
	{ "Sted - Iseki Wakusei no Yabou (Japan).nes",          262160, 0xa86fb17a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_stedj)
STD_ROM_FN(nes_stedj)

struct BurnDriver BurnDrvnes_stedj = {
	"nes_stedj", "nes_sted", NULL, NULL, "1990",
	"Sted - Iseki Wakusei no Yabou (Japan)\0", NULL, "KAC", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_stedjRomInfo, nes_stedjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Sted - Iseki Wakusei no Yabou (Hack, English)
static struct BurnRomInfo nes_stedRomDesc[] = {
	{ "Sted - Iseki Wakusei no Yabou (T-eng).nes",          262160, 0x5e63ec57, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sted)
STD_ROM_FN(nes_sted)

struct BurnDriver BurnDrvnes_sted = {
	"nes_sted", NULL, NULL, NULL, "1999",
	"Sted - Iseki Wakusei no Yabou (Hack, English)\0", NULL, "J2e Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_stedRomInfo, nes_stedRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Stick Hunter - Exciting Ice Hockey (Japan)
static struct BurnRomInfo nes_stickhunRomDesc[] = {
	{ "Stick Hunter - Exciting Ice Hockey (Japan).nes",          131088, 0x67495228, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_stickhun)
STD_ROM_FN(nes_stickhun)

struct BurnDriver BurnDrvnes_stickhun = {
	"nes_stickhun", NULL, NULL, NULL, "1987",
	"Stick Hunter - Exciting Ice Hockey (Japan)\0", NULL, "KAC", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_stickhunRomInfo, nes_stickhunRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Stinger (USA)
static struct BurnRomInfo nes_stingerRomDesc[] = {
	{ "Stinger (USA).nes",          131088, 0xf6b9629f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_stinger)
STD_ROM_FN(nes_stinger)

struct BurnDriver BurnDrvnes_stinger = {
	"nes_stinger", "nes_moerotwi", NULL, NULL, "1987",
	"Stinger (USA)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_stingerRomInfo, nes_stingerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Street Fighter 2010 - The Final Fight (USA)
static struct BurnRomInfo nes_streefig201RomDesc[] = {
	{ "Street Fighter 2010 - The Final Fight (USA).nes",          262160, 0xa7355946, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_streefig201)
STD_ROM_FN(nes_streefig201)

struct BurnDriver BurnDrvnes_streefig201 = {
	"nes_streefig201", NULL, NULL, NULL, "1990",
	"Street Fighter 2010 - The Final Fight (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_streefig201RomInfo, nes_streefig201RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Street Heroes (Taiwan).nes
static struct BurnRomInfo nes_streetheroesRomDesc[] = {
	{ "Street Heroes (Taiwan).nes",          1048592, 0xdd65a6cc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_streetheroes)
STD_ROM_FN(nes_streetheroes)

struct BurnDriver BurnDrvnes_streetheroes = {
	"nes_streetheroes", NULL, NULL, NULL, "1995",
	"Street Heroes (Taiwan)\0", NULL, "Sachen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_streetheroesRomInfo, nes_streetheroesRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Strider (USA)
static struct BurnRomInfo nes_striderRomDesc[] = {
	{ "Strider (USA).nes",          262160, 0x5307702a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_strider)
STD_ROM_FN(nes_strider)

struct BurnDriver BurnDrvnes_strider = {
	"nes_strider", NULL, NULL, NULL, "1989",
	"Strider (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_striderRomInfo, nes_striderRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Strike Wolf (USA)
static struct BurnRomInfo nes_strikewolfRomDesc[] = {
	{ "Strike Wolf (USA).nes",          262160, 0x21264238, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_strikewolf)
STD_ROM_FN(nes_strikewolf)

struct BurnDriver BurnDrvnes_strikewolf = {
	"nes_strikewolf", NULL, NULL, NULL, "1992",
	"Strike Wolf (USA)\0", NULL, "Micro Genius", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_strikewolfRomInfo, nes_strikewolfRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Stunt Kids (USA) (Unl)
static struct BurnRomInfo nes_stuntkidsRomDesc[] = {
	{ "Stunt Kids (USA) (Unl).nes",          131088, 0x7384aa7d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_stuntkids)
STD_ROM_FN(nes_stuntkids)

struct BurnDriver BurnDrvnes_stuntkids = {
	"nes_stuntkids", NULL, NULL, NULL, "1992",
	"Stunt Kids (USA) (Unl)\0", NULL, "Camerica", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_stuntkidsRomInfo, nes_stuntkidsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Sugoro Quest - Dice no Senshitachi (Japan)
static struct BurnRomInfo nes_sugorquejRomDesc[] = {
	{ "Sugoro Quest - Dice no Senshitachi (Japan).nes",          262160, 0x0ac48932, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sugorquej)
STD_ROM_FN(nes_sugorquej)

struct BurnDriver BurnDrvnes_sugorquej = {
	"nes_sugorquej", "nes_sugorque", NULL, NULL, "1991",
	"Sugoro Quest - Dice no Senshitachi (Japan)\0", NULL, "Technos", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG | GBF_BOARD, 0,
	NESGetZipName, nes_sugorquejRomInfo, nes_sugorquejRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Sugoro Quest - Dice no Senshitachi (Hack, English)
static struct BurnRomInfo nes_sugorqueRomDesc[] = {
	{ "Sugoro Quest - Dice no Senshitachi (T-eng).nes",          262160, 0xd2cdeb7b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sugorque)
STD_ROM_FN(nes_sugorque)

struct BurnDriver BurnDrvnes_sugorque = {
	"nes_sugorque", NULL, NULL, NULL, "2007",
	"Sugoro Quest - Dice no Senshitachi (Hack, English)\0", NULL, "AlanMidas", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG | GBF_BOARD, 0,
	NESGetZipName, nes_sugorqueRomInfo, nes_sugorqueRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Sukeban Deka 3 (Japan)
static struct BurnRomInfo nes_sukebandeka3jRomDesc[] = {
	{ "Sukeban Deka 3 (Japan).nes",          131088, 0x1bc8ce10, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sukebandeka3j)
STD_ROM_FN(nes_sukebandeka3j)

struct BurnDriver BurnDrvnes_sukebandeka3j = {
	"nes_sukebandeka3j", "nes_sukebandeka3", NULL, NULL, "1987",
	"Sukeban Deka 3 (Japan)\0", NULL, "Toei Animation", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_sukebandeka3jRomInfo, nes_sukebandeka3jRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Sukeban Deka 3 (Hack, English)
static struct BurnRomInfo nes_sukebandeka3RomDesc[] = {
	{ "Sukeban Deka 3 (T-Eng).nes",          131088, 0xfec242b9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sukebandeka3)
STD_ROM_FN(nes_sukebandeka3)

struct BurnDriver BurnDrvnes_sukebandeka3 = {
	"nes_sukebandeka3", NULL, NULL, NULL, "2016",
	"Sukeban Deka 3 (Hack, English)\0", NULL, "MrRichard999", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_sukebandeka3RomInfo, nes_sukebandeka3RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Summer Carnival '92 - Recca (Japan)
static struct BurnRomInfo nes_summecar92RomDesc[] = {
	{ "Summer Carnival '92 - Recca (Japan).nes",          262160, 0x2e15075a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_summecar92)
STD_ROM_FN(nes_summecar92)

struct BurnDriver BurnDrvnes_summecar92 = {
	"nes_summecar92", NULL, NULL, NULL, "1992",
	"Summer Carnival '92 - Recca (Japan)\0", NULL, "Naxat Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_summecar92RomInfo, nes_summecar92RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Sunday Funday - The Ride (USA) (Unl)
static struct BurnRomInfo nes_sundafunRomDesc[] = {
	{ "Sunday Funday - The Ride (USA) (Unl).nes",          262160, 0x4f7e1243, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sundafun)
STD_ROM_FN(nes_sundafun)

struct BurnDriver BurnDrvnes_sundafun = {
	"nes_sundafun", "nes_menacebeach", NULL, NULL, "1995",
	"Sunday Funday - The Ride (USA) (Unl)\0", NULL, "Wisdom Tree", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_sundafunRomInfo, nes_sundafunRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Sunman (Euro) (Prototype)
static struct BurnRomInfo nes_sunmanRomDesc[] = {
	{ "Sunman (Europe) (Prototype).nes",          262160, 0x2bce4dc7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sunman)
STD_ROM_FN(nes_sunman)

struct BurnDriver BurnDrvnes_sunman = {
	"nes_sunman", NULL, NULL, NULL, "1992",
	"Sunman (Euro) (Prototype)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_PROTOTYPE, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, nes_sunmanRomInfo, nes_sunmanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL, SCREEN_WIDTH, SCREEN_HEIGHT_PAL
};

// Superman (Hack, v1.1)
static struct BurnRomInfo nes_supermanhRomDesc[] = {
	{ "Superman v1.1 (2023)(kenoi).nes",          262160, 0x1c5a3eb8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_supermanh)
STD_ROM_FN(nes_supermanh)

struct BurnDriver BurnDrvnes_supermanh = {
	"nes_supermanh", "nes_sunman", NULL, NULL, "2023",
	"Superman (Hack, v1.1)\0", NULL, "kenoi", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, nes_supermanhRomInfo, nes_supermanhRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL, SCREEN_WIDTH, SCREEN_HEIGHT_PAL
};

// Superman II - Specter Edition (Hack, v2.1)
static struct BurnRomInfo nes_superman2hRomDesc[] = {
	{ "Superman II - Specter Edition v2.1 (2017)(pacnsacdave).nes",          262160, 0xf70f1143, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_superman2h)
STD_ROM_FN(nes_superman2h)

struct BurnDriver BurnDrvnes_superman2h = {
	"nes_superman2h", "nes_sunman", NULL, NULL, "2017",
	"Superman II - Specter Edition (Hack, v2.1)\0", NULL, "pacnsacdave", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, nes_superman2hRomInfo, nes_superman2hRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL, SCREEN_WIDTH, SCREEN_HEIGHT_PAL
};

// Super Arabian (Japan)
static struct BurnRomInfo nes_superarabianRomDesc[] = {
	{ "Super Arabian (Japan).nes",          24592, 0xf2988a21, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_superarabian)
STD_ROM_FN(nes_superarabian)

struct BurnDriver BurnDrvnes_superarabian = {
	"nes_superarabian", NULL, NULL, NULL, "1985",
	"Super Arabian (Japan)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_superarabianRomInfo, nes_superarabianRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super C (USA)
static struct BurnRomInfo nes_supercRomDesc[] = {
	{ "Super C (USA).nes",          262160, 0xed53852d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_superc)
STD_ROM_FN(nes_superc)

struct BurnDriver BurnDrvnes_superc = {
	"nes_superc", NULL, NULL, NULL, "1990",
	"Super C (USA)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_supercRomInfo, nes_supercRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Cars (USA)
static struct BurnRomInfo nes_supercarsRomDesc[] = {
	{ "Super Cars (USA).nes",          131088, 0x729db2e4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_supercars)
STD_ROM_FN(nes_supercars)

struct BurnDriver BurnDrvnes_supercars = {
	"nes_supercars", NULL, NULL, NULL, "1991",
	"Super Cars (USA)\0", NULL, "Electro Brain", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_supercarsRomInfo, nes_supercarsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Dodge Ball (USA)
static struct BurnRomInfo nes_superdodgeballRomDesc[] = {
	{ "Super Dodge Ball (USA).nes",          262160, 0x052a50d7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_superdodgeball)
STD_ROM_FN(nes_superdodgeball)

struct BurnDriver BurnDrvnes_superdodgeball = {
	"nes_superdodgeball", NULL, NULL, NULL, "1989",
	"Super Dodge Ball (USA)\0", NULL, "Sony Imagesoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_superdodgeballRomInfo, nes_superdodgeballRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Gun (USA)
static struct BurnRomInfo nes_supergunRomDesc[] = {
	{ "Super Gun (USA).nes",          98320, 0x3555dc26, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_supergun)
STD_ROM_FN(nes_supergun)

struct BurnDriver BurnDrvnes_supergun = {
	"nes_supergun", NULL, NULL, NULL, "1992",
	"Super Gun (USA)\0", NULL, "Caltron", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_supergunRomInfo, nes_supergunRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Mario Bros. (World)
static struct BurnRomInfo nes_smbRomDesc[] = {
	{ "Super Mario Bros. (World).nes",          40976, 0x3337ec46, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_smb)
STD_ROM_FN(nes_smb)

struct BurnDriver BurnDrvnes_smb = {
	"nes_smb", NULL, NULL, NULL, "1985",
	"Super Mario Bros. (World)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_smbRomInfo, nes_smbRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Mario Bros. 2 (USA) (Rev A)
static struct BurnRomInfo nes_smb2RomDesc[] = {
	{ "Super Mario Bros. 2 (USA) (Rev A).nes",          262160, 0xe0ca425c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_smb2)
STD_ROM_FN(nes_smb2)

struct BurnDriver BurnDrvnes_smb2 = {
	"nes_smb2", NULL, NULL, NULL, "1988",
	"Super Mario Bros. 2 (USA) (Rev A)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_smb2RomInfo, nes_smb2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Mario Bros. 2 J (Japan, MMC3 Conversion)
static struct BurnRomInfo nes_smb2jRomDesc[] = {
	{ "Super Mario Bros. 2 J (Japan, MMC3 Conversion).nes",          81936, 0x0133ebf9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_smb2j)
STD_ROM_FN(nes_smb2j)

struct BurnDriver BurnDrvnes_smb2j = {
	"nes_smb2j", NULL, NULL, NULL, "2020",
	"Super Mario Bros. 2 J (Japan, MMC3 Conversion)\0", NULL, "Loopy", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_smb2jRomInfo, nes_smb2jRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Mario Bros. 3 (USA) (Rev A)
static struct BurnRomInfo nes_smb3RomDesc[] = {
	{ "Super Mario Bros. 3 (USA) (Rev A).nes",          393232, 0x0b742b33, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_smb3)
STD_ROM_FN(nes_smb3)

struct BurnDriver BurnDrvnes_smb3 = {
	"nes_smb3", NULL, NULL, NULL, "1990",
	"Super Mario Bros. 3 (USA) (Rev A)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_smb3RomInfo, nes_smb3RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Mario Bros. 3 Definitive Edition (Hack)
// http://www.romhacking.net/hacks/5097/
static struct BurnRomInfo nes_smb3defediRomDesc[] = {
	{ "Super Mario Bros. 3 Definitive Edition (Hack).nes",          524304, 0x2a59f8c5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_smb3defedi)
STD_ROM_FN(nes_smb3defedi)

struct BurnDriver BurnDrvnes_smb3defedi = {
	"nes_smb3defedi", "nes_smb3", NULL, NULL, "2020",
	"Super Mario Bros. 3 Definitive Edition (Hack)\0", NULL, "ActionGamer", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_smb3defediRomInfo, nes_smb3defediRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Mario Bros. 3Mix (Hack)
// http://www.romhacking.net/hacks/2068/
static struct BurnRomInfo nes_smb3miRomDesc[] = {
	{ "Super Mario Bros. 3Mix (Hack).nes",          786448, 0x16b3fe50, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_smb3mi)
STD_ROM_FN(nes_smb3mi)

struct BurnDriver BurnDrvnes_smb3mi = {
	"nes_smb3mi", "nes_smb3", NULL, NULL, "2014",
	"Super Mario Bros. 3Mix (Hack)\0", NULL, "Southbird", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_smb3miRomInfo, nes_smb3miRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Royal Flush - Princess Sidestory (GlobalHack)
// http://www.romhacking.net/hacks/1633/
static struct BurnRomInfo nes_royalflushRomDesc[] = {
	{ "Royal Flush - Princess Sidestory GlobalHack (2013)(Darkdata).nes",          393232, 0x95e67f56, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_royalflush)
STD_ROM_FN(nes_royalflush)

struct BurnDriver BurnDrvnes_royalflush = {
	"nes_royalflush", "nes_smb3", NULL, NULL, "2013",
	"Royal Flush - Princess Sidestory (GlobalHack)\0", NULL, "Darkdata", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_royalflushRomInfo, nes_royalflushRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Mario Bros. Special 35th Anniversary (Hack, v1.3)
// https://www.romhacking.net/hacks/6067/
static struct BurnRomInfo nes_smbsp35thRomDesc[] = {
	{ "Super Mario Bros. Special 35th Anniversary (Hack, v1.3).nes",          98320, 0x3800de83, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_smbsp35th)
STD_ROM_FN(nes_smbsp35th)

struct BurnDriver BurnDrvnes_smbsp35th = {
	"nes_smbsp35th", "nes_smb", NULL, NULL, "2021",
	"Super Mario Bros. Special 35th Anniversary (Hack, v1.3)\0", NULL, "Frantik", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_smbsp35thRomInfo, nes_smbsp35thRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Mario Bros. Special (Hack, Triforce89)
static struct BurnRomInfo nes_smbspehRomDesc[] = {
	{ "Super Mario Bros. Special (Hack, Triforce89).nes",          98320, 0xab872e74, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_smbspeh)
STD_ROM_FN(nes_smbspeh)

struct BurnDriver BurnDrvnes_smbspeh = {
	"nes_smbspeh", "nes_smb", NULL, NULL, "2020",
	"Super Mario Bros. Special (Hack, Triforce89)\0", NULL, "Triforce89", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_smbspehRomInfo, nes_smbspehRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_smbspeRomDesc[] = {
	{ "Super Mario Bros. Special (Hack, v1.0-rc1).nes",          73744, 0xba34bcad, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_smbspe)
STD_ROM_FN(nes_smbspe)

struct BurnDriver BurnDrvnes_smbspe = {
	"nes_smbspe", "nes_smb", NULL, NULL, "2021",
	"Super Mario Bros. Special (Hack, v1.0-rc1)\0", NULL, "Frantik", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_smbspeRomInfo, nes_smbspeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_smbspex1RomDesc[] = {
	{ "Super Mario Bros. Special X1 (Hack).nes",          98320, 0x5a44876f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_smbspex1)
STD_ROM_FN(nes_smbspex1)

struct BurnDriver BurnDrvnes_smbspex1 = {
	"nes_smbspex1", "nes_smb", NULL, NULL, "2017",
	"Super Mario Bros. Special X1 (Hack)\0", NULL, "Messatu", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_smbspex1RomInfo, nes_smbspex1RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_smbtwoplaRomDesc[] = {
	{ "Super Mario Bros. Two Players (Hack).nes",          73744, 0x393bc874, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_smbtwopla)
STD_ROM_FN(nes_smbtwopla)

struct BurnDriver BurnDrvnes_smbtwopla = {
	"nes_smbtwopla", "nes_smb", NULL, NULL, "2018",
	"Super Mario Bros. Two Players (Hack)\0", NULL, "Corpse Grinder", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_smbtwoplaRomInfo, nes_smbtwoplaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_supermarworRomDesc[] = {
	{ "Super Mario World (Unl).nes",          786448, 0x6d5953a8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_supermarwor)
STD_ROM_FN(nes_supermarwor)

struct BurnDriver BurnDrvnes_supermarwor = {
	"nes_supermarwor", NULL, NULL, NULL, "1995",
	"Super Mario World (Unl)\0", NULL, "J.Y. Company", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_supermarworRomInfo, nes_supermarworRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_superpangRomDesc[] = {
	{ "Super Pang (Taiwan).nes",          65552, 0xf7c73ecc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_superpang)
STD_ROM_FN(nes_superpang)

struct BurnDriver BurnDrvnes_superpang = {
	"nes_superpang", NULL, NULL, NULL, "1991",
	"Super Pang (Taiwan)\0", NULL, "Sachen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_superpangRomInfo, nes_superpangRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_superpang2RomDesc[] = {
	{ "Super Pang 2 (Taiwan).nes",          98320, 0xa5043905, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_superpang2)
STD_ROM_FN(nes_superpang2)

struct BurnDriver BurnDrvnes_superpang2 = {
	"nes_superpang2", NULL, NULL, NULL, "1992",
	"Super Pang 2 (Taiwan)\0", NULL, "Sachen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_superpang2RomInfo, nes_superpang2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_superpinballRomDesc[] = {
	{ "Super Pinball (Japan).nes",          131088, 0xc8ee3210, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_superpinball)
STD_ROM_FN(nes_superpinball)

struct BurnDriver BurnDrvnes_superpinball = {
	"nes_superpinball", NULL, NULL, NULL, "1988",
	"Super Pinball (Japan)\0", NULL, "Coconuts/C-Dream", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_PINBALL, 0,
	NESGetZipName, nes_superpinballRomInfo, nes_superpinballRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_superpitfallRomDesc[] = {
	{ "Super Pitfall (USA).nes",          131088, 0xa4958020, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_superpitfall)
STD_ROM_FN(nes_superpitfall)

struct BurnDriver BurnDrvnes_superpitfall = {
	"nes_superpitfall", NULL, NULL, NULL, "1987",
	"Super Pitfall (USA)\0", NULL, "Activision", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_superpitfallRomInfo, nes_superpitfallRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_superrugbyRomDesc[] = {
	{ "Super Rugby (Japan).nes",          262160, 0xf2e219e5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_superrugby)
STD_ROM_FN(nes_superrugby)

struct BurnDriver BurnDrvnes_superrugby = {
	"nes_superrugby", NULL, NULL, NULL, "1989",
	"Super Rugby (Japan)\0", NULL, "TSS", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_superrugbyRomInfo, nes_superrugbyRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_supershiRomDesc[] = {
	{ "Super Shinobi, The (Unl).nes",          524304, 0xa36c26e7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_supershi)
STD_ROM_FN(nes_supershi)

struct BurnDriver BurnDrvnes_supershi = {
	"nes_supershi", NULL, NULL, NULL, "199?",
	"Super Shinobi, The (Unl)\0", NULL, "Realtec", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_supershiRomInfo, nes_supershiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Spike V'Ball (USA)
static struct BurnRomInfo nes_superspivbalRomDesc[] = {
	{ "Super Spike V'Ball (USA).nes",          262160, 0xc2d3f5b3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_superspivbal)
STD_ROM_FN(nes_superspivbal)

struct BurnDriver BurnDrvnes_superspivbal = {
	"nes_superspivbal", NULL, NULL, NULL, "1990",
	"Super Spike V'Ball (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_superspivbalRomInfo, nes_superspivbalRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Sprint (USA)
static struct BurnRomInfo nes_supersprintRomDesc[] = {
	{ "Super Sprint (USA).nes",          131088, 0x3c7b0120, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_supersprint)
STD_ROM_FN(nes_supersprint)

struct BurnDriver BurnDrvnes_supersprint = {
	"nes_supersprint", NULL, NULL, NULL, "1988",
	"Super Sprint (USA)\0", NULL, "Tengen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_supersprintRomInfo, nes_supersprintRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Spy Hunter (USA)
static struct BurnRomInfo nes_superspyhunterRomDesc[] = {
	{ "Super Spy Hunter (USA).nes",          262160, 0x81d24ccc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_superspyhunter)
STD_ROM_FN(nes_superspyhunter)

struct BurnDriver BurnDrvnes_superspyhunter = {
	"nes_superspyhunter", NULL, NULL, NULL, "1992",
	"Super Spy Hunter (USA)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RACING | GBF_SHOOT, 0,
	NESGetZipName, nes_superspyhunterRomInfo, nes_superspyhunterRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Star Force (Japan)
static struct BurnRomInfo nes_superstarforceRomDesc[] = {
	{ "Super Star Force (Japan).nes",          131088, 0x0ca0b143, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_superstarforce)
STD_ROM_FN(nes_superstarforce)

struct BurnDriver BurnDrvnes_superstarforce = {
	"nes_superstarforce", NULL, NULL, NULL, "1986",
	"Super Star Force (Japan)\0", NULL, "Tecmo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_superstarforceRomInfo, nes_superstarforceRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Super Turrican (Euro)
static struct BurnRomInfo nes_superturricanRomDesc[] = {
	{ "Super Turrican (Europe).nes",          262160, 0x55cbc495, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_superturrican)
STD_ROM_FN(nes_superturrican)

struct BurnDriver BurnDrvnes_superturrican = {
	"nes_superturrican", NULL, NULL, NULL, "1993",
	"Super Turrican (Euro)\0", NULL, "Imagineer", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_superturricanRomInfo, nes_superturricanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL, SCREEN_WIDTH, SCREEN_HEIGHT_PAL
};

// Super Xevious - Gump no Nazo (Japan)
static struct BurnRomInfo nes_superxevRomDesc[] = {
	{ "Super Xevious - Gump no Nazo (Japan).nes",          163856, 0xb6c7e249, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_superxev)
STD_ROM_FN(nes_superxev)

struct BurnDriver BurnDrvnes_superxev = {
	"nes_superxev", NULL, NULL, NULL, "1986",
	"Super Xevious - Gump no Nazo (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_superxevRomInfo, nes_superxevRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Superman (USA)
static struct BurnRomInfo nes_supermanRomDesc[] = {
	{ "Superman (USA).nes",          262160, 0x721be58a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_superman)
STD_ROM_FN(nes_superman)

struct BurnDriver BurnDrvnes_superman = {
	"nes_superman", NULL, NULL, NULL, "1988",
	"Superman (USA)\0", NULL, "Kemco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_supermanRomInfo, nes_supermanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Swamp Thing (USA)
static struct BurnRomInfo nes_swampthingRomDesc[] = {
	{ "Swamp Thing (USA).nes",          262160, 0xcc4c6f33, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_swampthing)
STD_ROM_FN(nes_swampthing)

struct BurnDriver BurnDrvnes_swampthing = {
	"nes_swampthing", NULL, NULL, NULL, "1992",
	"Swamp Thing (USA)\0", NULL, "THQ", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_swampthingRomInfo, nes_swampthingRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Sweet Home (Hack, English)
static struct BurnRomInfo nes_sweethomeeRomDesc[] = {
	{ "Sweet Home (Eng Hack).nes",          262160, 0x0bd7d357, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sweethomee)
STD_ROM_FN(nes_sweethomee)

struct BurnDriver BurnDrvnes_sweethomee = {
	"nes_sweethomee", "nes_sweethome", NULL, NULL, "2000",
	"Sweet Home (Hack, English)\0", NULL, "Gaijin Productions", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_sweethomeeRomInfo, nes_sweethomeeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Sweet Home (Japan)
static struct BurnRomInfo nes_sweethomeRomDesc[] = {
	{ "Sweet Home (Japan).nes",          262160, 0x40803bc5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_sweethome)
STD_ROM_FN(nes_sweethome)

struct BurnDriver BurnDrvnes_sweethome = {
	"nes_sweethome", NULL, NULL, NULL, "1989",
	"Sweet Home (Japan)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_sweethomeRomInfo, nes_sweethomeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Sword Master (USA) (Hack, Sample Fix)
static struct BurnRomInfo nes_swordmasterhRomDesc[] = {
	{ "Sword Master (USA)(Hack Sample Fix).nes",          262160, 0xcc1a0cfa, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_swordmasterh)
STD_ROM_FN(nes_swordmasterh)

struct BurnDriver BurnDrvnes_swordmasterh = {
	"nes_swordmasterh", "nes_swordmaster", NULL, NULL, "2020",
	"Sword Master (USA) (Hack, Sample Fix)\0", NULL, "TakuikaNinja", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_swordmasterhRomInfo, nes_swordmasterhRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Sword Master (USA)
static struct BurnRomInfo nes_swordmasterRomDesc[] = {
	{ "Sword Master (USA).nes",          262160, 0x6ccd5c11, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_swordmaster)
STD_ROM_FN(nes_swordmaster)

struct BurnDriver BurnDrvnes_swordmaster = {
	"nes_swordmaster", NULL, NULL, NULL, "1992",
	"Sword Master (USA)\0", NULL, "Activision", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_swordmasterRomInfo, nes_swordmasterRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Swords and Serpents (USA)
static struct BurnRomInfo nes_swordandserRomDesc[] = {
	{ "Swords and Serpents (USA).nes",          131088, 0x071e3f72, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_swordandser)
STD_ROM_FN(nes_swordandser)

struct BurnDriver BurnDrvnes_swordandser = {
	"nes_swordandser", NULL, NULL, NULL, "1990",
	"Swords and Serpents (USA)\0", NULL, "Acclaim", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_RPG | GBF_MAZE, 0,
	NESGetZipName, nes_swordandserRomInfo, nes_swordandserRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NES4ScoreInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// T&C 2 - Thrilla's Surfari (USA)
static struct BurnRomInfo nes_tc2RomDesc[] = {
	{ "T&C 2 - Thrilla's Surfari (USA).nes",          262160, 0x54c4f37e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tc2)
STD_ROM_FN(nes_tc2)

struct BurnDriver BurnDrvnes_tc2 = {
	"nes_tc2", NULL, NULL, NULL, "1992",
	"T&C 2 - Thrilla's Surfari (USA)\0", NULL, "Ljn", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_tc2RomInfo, nes_tc2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// T&C Surf Design (USA)
static struct BurnRomInfo nes_tcsurfdesignRomDesc[] = {
	{ "T&C Surf Design (USA).nes",          65552, 0x9c94ed32, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tcsurfdesign)
STD_ROM_FN(nes_tcsurfdesign)

struct BurnDriver BurnDrvnes_tcsurfdesign = {
	"nes_tcsurfdesign", NULL, NULL, NULL, "1988",
	"T&C Surf Design (USA)\0", NULL, "Ljn", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_tcsurfdesignRomInfo, nes_tcsurfdesignRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Taboo - The Sixth Sense (USA)
static struct BurnRomInfo nes_tabooRomDesc[] = {
	{ "Taboo - The Sixth Sense (USA).nes",          65552, 0xe057b507, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_taboo)
STD_ROM_FN(nes_taboo)

struct BurnDriver BurnDrvnes_taboo = {
	"nes_taboo", NULL, NULL, NULL, "1989",
	"Taboo - The Sixth Sense (USA)\0", NULL, "Tradewest", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_MISC, 0,
	NESGetZipName, nes_tabooRomInfo, nes_tabooRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tag Team Wrestling (USA)
static struct BurnRomInfo nes_tagteawreRomDesc[] = {
	{ "Tag Team Wrestling (USA).nes",          40976, 0x41f82f6e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tagteawre)
STD_ROM_FN(nes_tagteawre)

struct BurnDriver BurnDrvnes_tagteawre = {
	"nes_tagteawre", NULL, NULL, NULL, "1986",
	"Tag Team Wrestling (USA)\0", NULL, "Data East", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_tagteawreRomInfo, nes_tagteawreRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tagin' Dragon (Unl)
static struct BurnRomInfo nes_tagindragonRomDesc[] = {
	{ "Tagin' Dragon (Unl).nes",          49168, 0x163720d6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tagindragon)
STD_ROM_FN(nes_tagindragon)

struct BurnDriver BurnDrvnes_tagindragon = {
	"nes_tagindragon", NULL, NULL, NULL, "1990",
	"Tagin' Dragon (Unl)\0", NULL, "Bunch Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_MAZE | GBF_ACTION, 0,
	NESGetZipName, nes_tagindragonRomInfo, nes_tagindragonRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Taito Chase H.Q. (Japan)
static struct BurnRomInfo nes_taitochasehqRomDesc[] = {
	{ "Taito Chase H.Q. (Japan).nes",          262160, 0xb3408ee4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_taitochasehq)
STD_ROM_FN(nes_taitochasehq)

struct BurnDriver BurnDrvnes_taitochasehq = {
	"nes_taitochasehq", NULL, NULL, NULL, "1989",
	"Taito Chase H.Q. (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_taitochasehqRomInfo, nes_taitochasehqRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Taito Grand Prix - Eikou e no License (Japan)
static struct BurnRomInfo nes_taitograprijRomDesc[] = {
	{ "Taito Grand Prix - Eikou e no License (Japan).nes",          262160, 0x613bd034, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_taitograprij)
STD_ROM_FN(nes_taitograprij)

struct BurnDriver BurnDrvnes_taitograprij = {
	"nes_taitograprij", "nes_taitograpri", NULL, NULL, "1987",
	"Taito Grand Prix - Eikou e no License (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_taitograprijRomInfo, nes_taitograprijRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Taito Grand Prix - Eikou e no License (Hack, English)
static struct BurnRomInfo nes_taitograpriRomDesc[] = {
	{ "Taito Grand Prix - Eikou e no License (T-Eng).nes",          262160, 0xb58f4f5a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_taitograpri)
STD_ROM_FN(nes_taitograpri)

struct BurnDriver BurnDrvnes_taitograpri = {
	"nes_taitograpri", NULL, NULL, NULL, "2015",
	"Taito Grand Prix - Eikou e no License (Hack, English)\0", NULL, "MrRichard999", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_taitograpriRomInfo, nes_taitograpriRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Taiyou no Yuusha Firebird (Japan)
static struct BurnRomInfo nes_taiyonoyuufirjRomDesc[] = {
	{ "Taiyou no Yuusha Firebird (Japan).nes",          262160, 0xbe1d0344, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_taiyonoyuufirj)
STD_ROM_FN(nes_taiyonoyuufirj)

struct BurnDriver BurnDrvnes_taiyonoyuufirj = {
	"nes_taiyonoyuufirj", "nes_taiyonoyuufir", NULL, NULL, "1992",
	"Taiyou no Yuusha Firebird (Japan)\0", NULL, "Irem", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_taiyonoyuufirjRomInfo, nes_taiyonoyuufirjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Taiyou no Yuusha Firebird (Hack, English)
// https://www.romhacking.net/translations/147/
static struct BurnRomInfo nes_taiyonoyuufirRomDesc[] = {
	{ "Taiyou no Yuusha Firebird (T-eng).nes",          262160, 0xbfacf6de, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_taiyonoyuufir)
STD_ROM_FN(nes_taiyonoyuufir)

struct BurnDriver BurnDrvnes_taiyonoyuufir = {
	"nes_taiyonoyuufir", NULL, NULL, NULL, "2016",
	"Taiyou no Yuusha Firebird (Hack, English)\0", NULL, "Dragoon-X Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_taiyonoyuufirRomInfo, nes_taiyonoyuufirRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Taiyou no Shinden - Asteka 2 (Japan)
static struct BurnRomInfo nes_asteka2RomDesc[] = {
	{ "Taiyou no Shinden - Asteka 2 (J)(1988)(Tokyo Shoseki).nes",          262160, 0x01259d1f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_asteka2)
STD_ROM_FN(nes_asteka2)

struct BurnDriver BurnDrvnes_asteka2 = {
	"nes_asteka2", "nes_tmbtreasure", NULL, NULL, "1988",
	"Taiyou no Shinden - Asteka 2 (Japan)\0", NULL, "Tokyo Shoseki", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG | GBF_ADV, 0,
	NESGetZipName, nes_asteka2RomInfo, nes_asteka2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Takahashi Meijin no Bouken-jima (Japan)
static struct BurnRomInfo nes_takahashiRomDesc[] = {
	{ "Takahashi Meijin no Bouken-jima (Japan)(1986)(Hudson Soft).nes",          65552, 0x0bb95602, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_takahashi)
STD_ROM_FN(nes_takahashi)

struct BurnDriver BurnDrvnes_takahashi = {
	"nes_takahashi", "nes_adventureisland", NULL, NULL, "1986",
	"Takahashi Meijin no Bouken-jima (Japan)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_takahashiRomInfo, nes_takahashiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Takahashi Meijin no Bouken-jima III (Japan)
static struct BurnRomInfo nes_takahashi3RomDesc[] = {
	{ "Takahashi Meijin no Bouken-jima III (Japan)(1992)(Hudson Soft).nes",          262160, 0xd9d35f73, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_takahashi3)
STD_ROM_FN(nes_takahashi3)

struct BurnDriver BurnDrvnes_takahashi3 = {
	"nes_takahashi3", "nes_advenisl3", NULL, NULL, "1992",
	"Takahashi Meijin no Bouken-jima III (Japan)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_takahashi3RomInfo, nes_takahashi3RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Takahashi Meijin no Bouken-jima II (Japan)
static struct BurnRomInfo nes_takahashi2RomDesc[] = {
	{ "Takahashi Meijin no Bouken-jima II (Japan)(1991)(Hudson Soft).nes",          262160, 0xcba2f8e5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_takahashi2)
STD_ROM_FN(nes_takahashi2)

struct BurnDriver BurnDrvnes_takahashi2 = {
	"nes_takahashi2", "nes_advenislii", NULL, NULL, "1991",
	"Takahashi Meijin no Bouken-jima II (Japan)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_takahashi2RomInfo, nes_takahashi2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Takahashi Meijin no Bouken-jima IV (Japan)
static struct BurnRomInfo nes_takahashi4RomDesc[] = {
	{ "Takahashi Meijin no Bouken-jima IV (Japan)(1994)(Hudson Soft).nes",          393232, 0x5ef1196b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_takahashi4)
STD_ROM_FN(nes_takahashi4)

struct BurnDriver BurnDrvnes_takahashi4 = {
	"nes_takahashi4", "nes_advenisliv", NULL, NULL, "1994",
	"Takahashi Meijin no Bouken-jima IV (Japan)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_takahashi4RomInfo, nes_takahashi4RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Takahashi Meijin no Bugutte Honey (Japan)
static struct BurnRomInfo nes_takahmeinobughoRomDesc[] = {
	{ "Takahashi Meijin no Bugutte Honey (Japan)(1987)(Hudson Soft).nes",          163856, 0x312e6a31, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_takahmeinobugho)
STD_ROM_FN(nes_takahmeinobugho)

struct BurnDriver BurnDrvnes_takahmeinobugho = {
	"nes_takahmeinobugho", NULL, NULL, NULL, "1987",
	"Takahashi Meijin no Bugutte Honey (Japan)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_takahmeinobughoRomInfo, nes_takahmeinobughoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Takeda Shingen (Hack, English)
// https://gbatemp.net/download/takeda-shingen-english-patch-1-0-for-the-famicom.37398/
static struct BurnRomInfo nes_tashingenRomDesc[] = {
	{ "Takeda Shingen T-Eng (2022)(MrRichard999).nes",          131088, 0x295f0a9f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tashingen)
STD_ROM_FN(nes_tashingen)

struct BurnDriver BurnDrvnes_tashingen = {
	"nes_tashingen", NULL, NULL, NULL, "2022",
	"Takeda Shingen (Hack, English)\0", NULL, "MrRichard999", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_tashingenRomInfo, nes_tashingenRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Takeda Shingen (Japan)
static struct BurnRomInfo nes_tashingenjRomDesc[] = {
	{ "Takeda Shingen (J)(1988)(Hot-B).nes",          131088, 0x394b0b7b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tashingenj)
STD_ROM_FN(nes_tashingenj)

struct BurnDriver BurnDrvnes_tashingenj = {
	"nes_tashingenj", "nes_tashingen", NULL, NULL, "1988",
	"Takeda Shingen (Japan)\0", NULL, "Hot-B", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_tashingenjRomInfo, nes_tashingenjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Takeshi no Sengoku Fuuunji (Japan)
static struct BurnRomInfo nes_takesnosenfuuRomDesc[] = {
	{ "Takeshi no Sengoku Fuuunji (Japan).nes",          262160, 0x5c80a4a2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_takesnosenfuu)
STD_ROM_FN(nes_takesnosenfuu)

struct BurnDriver BurnDrvnes_takesnosenfuu = {
	"nes_takesnosenfuu", NULL, NULL, NULL, "1988",
	"Takeshi no Sengoku Fuuunji (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_BOARD, 0,
	NESGetZipName, nes_takesnosenfuuRomInfo, nes_takesnosenfuuRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Takeshi no Chousenjou (Japan)
static struct BurnRomInfo nes_takesschajRomDesc[] = {
	{ "Takeshi's Challenge (Japan).nes",          131088, 0xe810b35c, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_takesschaj)
STD_ROM_FN(nes_takesschaj)

struct BurnDriver BurnDrvnes_takesschaj = {
	"nes_takesschaj", "nes_takesscha", NULL, NULL, "1986",
	"Takeshi no Chousenjou (Japan)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_takesschajRomInfo, nes_takesschajRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Takeshi's Challenge (Hack, English)
static struct BurnRomInfo nes_takesschaRomDesc[] = {
	{ "Takeshi's Challenge (T-Eng).nes",          262160, 0x18c9b8ad, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_takesscha)
STD_ROM_FN(nes_takesscha)

struct BurnDriver BurnDrvnes_takesscha = {
	"nes_takesscha", NULL, NULL, NULL, "2011",
	"Takeshi's Challenge (Hack, English)\0", NULL, "KingMike", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_takesschaRomInfo, nes_takesschaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// TaleSpin (USA)
static struct BurnRomInfo nes_talespinRomDesc[] = {
	{ "TaleSpin (USA).nes",          262160, 0x143dcab6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_talespin)
STD_ROM_FN(nes_talespin)

struct BurnDriver BurnDrvnes_talespin = {
	"nes_talespin", NULL, NULL, NULL, "1991",
	"TaleSpin (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_talespinRomInfo, nes_talespinRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Target Renegade (USA)
static struct BurnRomInfo nes_targetrenegadeRomDesc[] = {
	{ "Target Renegade (USA).nes",          262160, 0xfe07b4ac, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_targetrenegade)
STD_ROM_FN(nes_targetrenegade)

struct BurnDriver BurnDrvnes_targetrenegade = {
	"nes_targetrenegade", NULL, NULL, NULL, "1990",
	"Target Renegade (USA)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_targetrenegadeRomInfo, nes_targetrenegadeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tasac (Taiwan)
static struct BurnRomInfo nes_tasacRomDesc[] = {
	{ "Tasac (Taiwan).nes",          65552, 0xcf0bbd95, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tasac)
STD_ROM_FN(nes_tasac)

struct BurnDriver BurnDrvnes_tasac = {
	"nes_tasac", NULL, NULL, NULL, "1992",
	"Tasac (Taiwan)\0", NULL, "Sachen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_tasacRomInfo, nes_tasacRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tashiro Masashi no Princess ga Ippai (Japan)
static struct BurnRomInfo nes_tashimasnoprigaipjRomDesc[] = {
	{ "Tashiro Masashi no Princess ga Ippai (Japan).nes",          262160, 0x7b5a1e17, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tashimasnoprigaipj)
STD_ROM_FN(nes_tashimasnoprigaipj)

struct BurnDriver BurnDrvnes_tashimasnoprigaipj = {
	"nes_tashimasnoprigaipj", "nes_tashimasnoprigaip", NULL, NULL, "1989",
	"Tashiro Masashi no Princess ga Ippai (Japan)\0", NULL, "CBS/Sony Group", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_tashimasnoprigaipjRomInfo, nes_tashimasnoprigaipjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tashiro Masashi no Princess ga Ippai (Hack, English)
// https://www.romhacking.net/translations/7055/
static struct BurnRomInfo nes_tashimasnoprigaipRomDesc[] = {
	{ "Tashiro Masashi no Princess ga Ippai T-Eng (2023)(Zynk Oxhyde).nes",          262160, 0x736e3691, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tashimasnoprigaip)
STD_ROM_FN(nes_tashimasnoprigaip)

struct BurnDriver BurnDrvnes_tashimasnoprigaip = {
	"nes_tashimasnoprigaip", NULL, NULL, NULL, "2023",
	"Tashiro Masashi no Princess ga Ippai (Hack, English)\0", NULL, "Zynk Oxhyde", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_tashimasnoprigaipRomInfo, nes_tashimasnoprigaipRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tatakae! Chou Robot Seimeitai Transformers - Convoy no Nazo (Japan)
static struct BurnRomInfo nes_tatakchorobseitrRomDesc[] = {
	{ "Tatakae! Chou Robot Seimeitai Transformers - Convoy no Nazo (Japan)(1986)(Takara).nes",          65552, 0xffd5a66f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tatakchorobseitr)
STD_ROM_FN(nes_tatakchorobseitr)

struct BurnDriver BurnDrvnes_tatakchorobseitr = {
	"nes_tatakchorobseitr", "nes_transformers", NULL, NULL, "1986",
	"Tatakae! Chou Robot Seimeitai Transformers - Convoy no Nazo (Japan)\0", NULL, "Takara", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_tatakchorobseitrRomInfo, nes_tatakchorobseitrRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tatakae!! Rahmen Man - Sakuretsu Choujin 102 Gei (Japan)
static struct BurnRomInfo nes_tatakrahmanRomDesc[] = {
	{ "Tatakae!! Rahmen Man - Sakuretsu Choujin 102 Gei (Japan)(1988)(Shinsei).nes",          262160, 0xad9c24f5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tatakrahman)
STD_ROM_FN(nes_tatakrahman)

struct BurnDriver BurnDrvnes_tatakrahman = {
	"nes_tatakrahman", NULL, NULL, NULL, "1988",
	"Tatakae!! Rahmen Man - Sakuretsu Choujin 102 Gei (Japan)\0", NULL, "Shinsei", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_tatakrahmanRomInfo, nes_tatakrahmanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tatakai no Banka (Japan, Rev A)
static struct BurnRomInfo nes_tatakainobankaRomDesc[] = {
	{ "Tatakai no Banka (Japan)(Rev A)(1986)(Capcom).nes",          131088, 0xa3120923, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tatakainobanka)
STD_ROM_FN(nes_tatakainobanka)

struct BurnDriver BurnDrvnes_tatakainobanka = {
	"nes_tatakainobanka", "nes_trojan", NULL, NULL, "1986",
	"Tatakai no Banka (Japan, Rev A)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_tatakainobankaRomInfo, nes_tatakainobankaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tecmo Baseball (USA)
static struct BurnRomInfo nes_tecmobaseballRomDesc[] = {
	{ "Tecmo Baseball (USA)(1989)(Tecmo).nes",          131088, 0x7fd237e6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tecmobaseball)
STD_ROM_FN(nes_tecmobaseball)

struct BurnDriver BurnDrvnes_tecmobaseball = {
	"nes_tecmobaseball", NULL, NULL, NULL, "1989",
	"Tecmo Baseball (USA)\0", NULL, "Tecmo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_tecmobaseballRomInfo, nes_tecmobaseballRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tecmo Bowl (USA)
static struct BurnRomInfo nes_tecmobowlRomDesc[] = {
	{ "Tecmo Bowl (USA)(1989)(Tecmo).nes",          262160, 0xe815e1fb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tecmobowl)
STD_ROM_FN(nes_tecmobowl)

struct BurnDriver BurnDrvnes_tecmobowl = {
	"nes_tecmobowl", NULL, NULL, NULL, "1989",
	"Tecmo Bowl (USA)\0", NULL, "Tecmo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_tecmobowlRomInfo, nes_tecmobowlRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tecmo Cup - Soccer Game (USA)
static struct BurnRomInfo nes_tecmocupRomDesc[] = {
	{ "Tecmo Cup - Soccer Game (USA)(1992)(Tecmo).nes",          262160, 0x04de5917, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tecmocup)
STD_ROM_FN(nes_tecmocup)

struct BurnDriver BurnDrvnes_tecmocup = {
	"nes_tecmocup", NULL, NULL, NULL, "1992",
	"Tecmo Cup - Soccer Game (USA)\0", NULL, "Tecmo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SPORTSFOOTBALL | GBF_RPG, 0,
	NESGetZipName, nes_tecmocupRomInfo, nes_tecmocupRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tecmo NBA Basketball (USA)
static struct BurnRomInfo nes_tecmonbabasRomDesc[] = {
	{ "Tecmo NBA Basketball (USA)(1992)(Tecmo).nes",          393232, 0xd31d7ab8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tecmonbabas)
STD_ROM_FN(nes_tecmonbabas)

struct BurnDriver BurnDrvnes_tecmonbabas = {
	"nes_tecmonbabas", NULL, NULL, NULL, "1992",
	"Tecmo NBA Basketball (USA)\0", NULL, "Tecmo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_tecmonbabasRomInfo, nes_tecmonbabasRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tecmo Super Bowl (USA)
static struct BurnRomInfo nes_tecmosuperbowlRomDesc[] = {
	{ "Tecmo Super Bowl (USA)(1991)(Tecmo).nes",          393232, 0x1f7c5660, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tecmosuperbowl)
STD_ROM_FN(nes_tecmosuperbowl)

struct BurnDriver BurnDrvnes_tecmosuperbowl = {
	"nes_tecmosuperbowl", NULL, NULL, NULL, "1991",
	"Tecmo Super Bowl (USA)\0", NULL, "Tecmo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_tecmosuperbowlRomInfo, nes_tecmosuperbowlRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tecmo World Cup Soccer (Japan)
static struct BurnRomInfo nes_tecmoworcupsocRomDesc[] = {
	{ "Tecmo World Cup Soccer (Japan)(1990)(Tecmo).nes",          131088, 0x19f24980, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tecmoworcupsoc)
STD_ROM_FN(nes_tecmoworcupsoc)

struct BurnDriver BurnDrvnes_tecmoworcupsoc = {
	"nes_tecmoworcupsoc", NULL, NULL, NULL, "1990",
	"Tecmo World Cup Soccer (Japan)\0", NULL, "Tecmo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSFOOTBALL, 0,
	NESGetZipName, nes_tecmoworcupsocRomInfo, nes_tecmoworcupsocRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tecmo World Wrestling (USA)
static struct BurnRomInfo nes_tecmoworwreRomDesc[] = {
	{ "Tecmo World Wrestling (USA)(1990)(Tecmo).nes",          262160, 0x12444337, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tecmoworwre)
STD_ROM_FN(nes_tecmoworwre)

struct BurnDriver BurnDrvnes_tecmoworwre = {
	"nes_tecmoworwre", NULL, NULL, NULL, "1990",
	"Tecmo World Wrestling (USA)\0", NULL, "Tecmo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_tecmoworwreRomInfo, nes_tecmoworwreRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Teenage Mutant Hero Turtles (Euro)
static struct BurnRomInfo nes_tmhtRomDesc[] = {
	{ "Teenage Mutant Hero Turtles (Euro)(1990)(Palcom).nes",          262160, 0x6d1e30a7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tmht)
STD_ROM_FN(nes_tmht)

struct BurnDriver BurnDrvnes_tmht = {
	"nes_tmht", "nes_tmnt", NULL, NULL, "1990",
	"Teenage Mutant Hero Turtles (Euro)\0", NULL, "Palcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_tmhtRomInfo, nes_tmhtRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL, SCREEN_WIDTH, SCREEN_HEIGHT_PAL
};

// Teenage Mutant Hero Turtles II - The Arcade Game (Euro)
static struct BurnRomInfo nes_tmhtiiarcgamRomDesc[] = {
	{ "Teenage Mutant Hero Turtles II - The Arcade Game (Euro)(1991)(Konami).nes",          524304, 0xa5bbb96b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tmhtiiarcgam)
STD_ROM_FN(nes_tmhtiiarcgam)

struct BurnDriver BurnDrvnes_tmhtiiarcgam = {
	"nes_tmhtiiarcgam", "nes_tmntiiarcgam", NULL, NULL, "1991",
	"Teenage Mutant Hero Turtles II - The Arcade Game (Euro)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_tmhtiiarcgamRomInfo, nes_tmhtiiarcgamRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL, SCREEN_WIDTH, SCREEN_HEIGHT_PAL
};

// Teenage Mutant Ninja Turtles (USA)
static struct BurnRomInfo nes_tmntRomDesc[] = {
	{ "Teenage Mutant Ninja Turtles (USA)(1989)(Ultra Games).nes",          262160, 0x83213ca0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tmnt)
STD_ROM_FN(nes_tmnt)

struct BurnDriver BurnDrvnes_tmnt = {
	"nes_tmnt", NULL, NULL, NULL, "1989",
	"Teenage Mutant Ninja Turtles (USA)\0", NULL, "Ultra Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_tmntRomInfo, nes_tmntRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Teenage Mutant Ninja Turtles - Texas Edition (Hack)
// https://www.romhacking.net/hacks/8090/
static struct BurnRomInfo nes_tmntteRomDesc[] = {
	{ "Teenage Mutant Ninja Turtles - Texas Edition (2023)(SomeOldGuy).nes",          262160, 0xd4947ef5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tmntte)
STD_ROM_FN(nes_tmntte)

struct BurnDriver BurnDrvnes_tmntte = {
	"nes_tmntte", "nes_tmnt", NULL, NULL, "2023",
	"Teenage Mutant Ninja Turtles - Texas Edition (Hack)\0", NULL, "SomeOldGuy", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_tmntteRomInfo, nes_tmntteRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Teenage Mutant Ninja Turtles II - The Arcade Game (Japan)
static struct BurnRomInfo nes_tmntiiarcgamjRomDesc[] = {
	{ "Teenage Mutant Ninja Turtles II - The Arcade Game (Japan).nes",          524304, 0x7a476257, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tmntiiarcgamj)
STD_ROM_FN(nes_tmntiiarcgamj)

struct BurnDriver BurnDrvnes_tmntiiarcgamj = {
	"nes_tmntiiarcgamj", "nes_tmntiiarcgam", NULL, NULL, "1990",
	"Teenage Mutant Ninja Turtles II - The Arcade Game (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_tmntiiarcgamjRomInfo, nes_tmntiiarcgamjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Teenage Mutant Ninja Turtles II - The Arcade Game (USA)
static struct BurnRomInfo nes_tmntiiarcgamRomDesc[] = {
	{ "Teenage Mutant Ninja Turtles II - The Arcade Game (USA).nes",          524304, 0xc9ffbbdb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tmntiiarcgam)
STD_ROM_FN(nes_tmntiiarcgam)

struct BurnDriver BurnDrvnes_tmntiiarcgam = {
	"nes_tmntiiarcgam", NULL, NULL, NULL, "1990",
	"Teenage Mutant Ninja Turtles II - The Arcade Game (USA)\0", NULL, "Ultra Games", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_tmntiiarcgamRomInfo, nes_tmntiiarcgamRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Teenage Mutant Ninja Turtles II - The Manhattan Project (Japan)
static struct BurnRomInfo nes_tmntiimanproRomDesc[] = {
	{ "Teenage Mutant Ninja Turtles II - The Manhattan Project (Japan).nes",          524304, 0x7929f237, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tmntiimanpro)
STD_ROM_FN(nes_tmntiimanpro)

struct BurnDriver BurnDrvnes_tmntiimanpro = {
	"nes_tmntiimanpro", "nes_tmntiii", NULL, NULL, "1991",
	"Teenage Mutant Ninja Turtles II - The Manhattan Project (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_tmntiimanproRomInfo, nes_tmntiimanproRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Teenage Mutant Ninja Turtles III - The Manhattan Project (USA)
static struct BurnRomInfo nes_tmntiiiRomDesc[] = {
	{ "Teenage Mutant Ninja Turtles III - The Manhattan Project (USA).nes",          524304, 0xdbb3bc30, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tmntiii)
STD_ROM_FN(nes_tmntiii)

struct BurnDriver BurnDrvnes_tmntiii = {
	"nes_tmntiii", NULL, NULL, NULL, "1992",
	"Teenage Mutant Ninja Turtles III - The Manhattan Project (USA)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_tmntiiiRomInfo, nes_tmntiiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Teenage Mutant Ninja Turtles Tournament Fighters (USA)
static struct BurnRomInfo nes_tmnttoufigRomDesc[] = {
	{ "Teenage Mutant Ninja Turtles Tournament Fighters (USA).nes",          262160, 0xac05464f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tmnttoufig)
STD_ROM_FN(nes_tmnttoufig)

struct BurnDriver BurnDrvnes_tmnttoufig = {
	"nes_tmnttoufig", NULL, NULL, NULL, "1994",
	"Teenage Mutant Ninja Turtles Tournament Fighters (USA)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_tmnttoufigRomInfo, nes_tmnttoufigRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tenchi wo Kurau (Japan)
static struct BurnRomInfo nes_tenchiwokurauRomDesc[] = {
	{ "Tenchi wo Kurau (Japan).nes",          262160, 0xf14e7fc1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tenchiwokurau)
STD_ROM_FN(nes_tenchiwokurau)

struct BurnDriver BurnDrvnes_tenchiwokurau = {
	"nes_tenchiwokurau", "nes_destianemp", NULL, NULL, "1989",
	"Tenchi wo Kurau (Japan)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_tenchiwokurauRomInfo, nes_tenchiwokurauRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tenchi wo Kurau II - Shokatsu Koumei Den (Japan)
static struct BurnRomInfo nes_tenchwokuriijRomDesc[] = {
	{ "Tenchi wo Kurau II - Shokatsu Koumei Den (Japan).nes",          524304, 0x052519a2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tenchwokuriij)
STD_ROM_FN(nes_tenchwokuriij)

struct BurnDriver BurnDrvnes_tenchwokuriij = {
	"nes_tenchwokuriij", "nes_tenchwokurii", NULL, NULL, "1991",
	"Tenchi wo Kurau II - Shokatsu Koumei Den (Japan)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_tenchwokuriijRomInfo, nes_tenchwokuriijRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tenchi wo Kurau II - Shokatsu Koumei Den (Hack, English v1.12)
// https://www.romhacking.net/translations/116/
static struct BurnRomInfo nes_tenchwokuriiRomDesc[] = {
	{ "Tenchi wo Kurau II - Shokatsu Koumei Den (T-Eng).nes",          524304, 0x6dcfda9e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tenchwokurii)
STD_ROM_FN(nes_tenchwokurii)

struct BurnDriver BurnDrvnes_tenchwokurii = {
	"nes_tenchwokurii", NULL, NULL, NULL, "2010",
	"Tenchi wo Kurau II - Shokatsu Koumei Den (Hack, English v1.12)\0", NULL, "Jair, Taskforce, Dark Force, Dynamic-Designs", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_tenchwokuriiRomInfo, nes_tenchwokuriiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tenka no Goikenban - Mito Koumon (Japan)
static struct BurnRomInfo nes_tenkanogoiRomDesc[] = {
	{ "Tenka no Goikenban - Mito Koumon (Japan).nes",          262160, 0x55fca5fc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tenkanogoi)
STD_ROM_FN(nes_tenkanogoi)

struct BurnDriver BurnDrvnes_tenkanogoi = {
	"nes_tenkanogoi", NULL, NULL, NULL, "1987",
	"Tenka no Goikenban - Mito Koumon (Japan)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_RPG, 0,
	NESGetZipName, nes_tenkanogoiRomInfo, nes_tenkanogoiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tenkaichi Bushi - Keru Naguuru (Japan)
static struct BurnRomInfo nes_tenkabusRomDesc[] = {
	{ "Tenkaichi Bushi - Keru Naguuru (Japan).nes",          196624, 0x1722c362, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tenkabus)
STD_ROM_FN(nes_tenkabus)

struct BurnDriver BurnDrvnes_tenkabus = {
	"nes_tenkabus", NULL, NULL, NULL, "1989",
	"Tenkaichi Bushi - Keru Naguuru (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VSFIGHT | GBF_RPG, 0,
	NESGetZipName, nes_tenkabusRomInfo, nes_tenkabusRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tennis (USA)
static struct BurnRomInfo nes_tennisRomDesc[] = {
	{ "Tennis (USA).nes",          24592, 0x5f457c00, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tennis)
STD_ROM_FN(nes_tennis)

struct BurnDriver BurnDrvnes_tennis = {
	"nes_tennis", NULL, NULL, NULL, "1984",
	"Tennis (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_tennisRomInfo, nes_tennisRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Terao no Dosukoi Oozumou (Japan)
static struct BurnRomInfo nes_teraonodosoozRomDesc[] = {
	{ "Terao no Dosukoi Oozumou (Japan).nes",          262160, 0x1bb4e1e6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_teraonodosooz)
STD_ROM_FN(nes_teraonodosooz)

struct BurnDriver BurnDrvnes_teraonodosooz = {
	"nes_teraonodosooz", NULL, NULL, NULL, "1989",
	"Terao no Dosukoi Oozumou (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_teraonodosoozRomInfo, nes_teraonodosoozRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Terminator 2 - Judgment Day (USA)
static struct BurnRomInfo nes_termi2RomDesc[] = {
	{ "Terminator 2 - Judgment Day (USA).nes",          262160, 0xc0b4bce5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_termi2)
STD_ROM_FN(nes_termi2)

struct BurnDriver BurnDrvnes_termi2 = {
	"nes_termi2", NULL, NULL, NULL, "1992",
	"Terminator 2 - Judgment Day (USA)\0", NULL, "Ljn", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_SCRFIGHT, 0,
	NESGetZipName, nes_termi2RomInfo, nes_termi2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Terminator, The (USA)
static struct BurnRomInfo nes_terminatortheRomDesc[] = {
	{ "Terminator, The (USA).nes",          262160, 0x48e1cddb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_terminatorthe)
STD_ROM_FN(nes_terminatorthe)

struct BurnDriver BurnDrvnes_terminatorthe = {
	"nes_terminatorthe", NULL, NULL, NULL, "1992",
	"Terminator, The (USA)\0", NULL, "Mindscape", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_terminatortheRomInfo, nes_terminatortheRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Terra Cresta (USA)
static struct BurnRomInfo nes_terracrestaRomDesc[] = {
	{ "Terra Cresta (USA).nes",          131088, 0xe9b1dfad, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_terracresta)
STD_ROM_FN(nes_terracresta)

struct BurnDriver BurnDrvnes_terracresta = {
	"nes_terracresta", NULL, NULL, NULL, "1990",
	"Terra Cresta (USA)\0", NULL, "Vic Tokai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_terracrestaRomInfo, nes_terracrestaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tetrastar - The Fighter (Japan)
static struct BurnRomInfo nes_tetraRomDesc[] = {
	{ "Tetrastar - The Fighter (Japan).nes",          524304, 0x16745bf4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tetra)
STD_ROM_FN(nes_tetra)

struct BurnDriver BurnDrvnes_tetra = {
	"nes_tetra", NULL, NULL, NULL, "1991",
	"Tetrastar - The Fighter (Japan)\0", NULL, "Taito Corp.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_tetraRomInfo, nes_tetraRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tetris (BPS) (Japan)
static struct BurnRomInfo nes_tetrisjRomDesc[] = {
	{ "Tetris (BPS) (Japan).nes",          49168, 0x6cb86f4e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tetrisj)
STD_ROM_FN(nes_tetrisj)

struct BurnDriver BurnDrvnes_tetrisj = {
	"nes_tetrisj", "nes_tetris", NULL, NULL, "1988",
	"Tetris (BPS) (Japan)\0", NULL, "Bullet-Proof Software", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_tetrisjRomInfo, nes_tetrisjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tetris (BPS) - Conventional-Controls Edition (Hack)
// https://www.romhacking.net/hacks/7914/
static struct BurnRomInfo nes_tetrisjccRomDesc[] = {
	{ "Tetris (BPS) - CC Edition (2023)(climax).nes",          49168, 0xe0ea2f20, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tetrisjcc)
STD_ROM_FN(nes_tetrisjcc)

struct BurnDriver BurnDrvnes_tetrisjcc = {
	"nes_tetrisjcc", "nes_tetris", NULL, NULL, "2023",
	"Tetris (BPS) - Conventional-Controls Edition (Hack)\0", NULL, "climax", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_tetrisjccRomInfo, nes_tetrisjccRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tetris (Tengen) (USA)
static struct BurnRomInfo nes_tetrisuRomDesc[] = {
	{ "Tetris (Tengen) (USA).nes",          49168, 0x88f071c3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tetrisu)
STD_ROM_FN(nes_tetrisu)

struct BurnDriver BurnDrvnes_tetrisu = {
	"nes_tetrisu", "nes_tetris", NULL, NULL, "1989",
	"Tetris (Tengen) (USA)\0", NULL, "Tengen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_tetrisuRomInfo, nes_tetrisuRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tetris (USA)
static struct BurnRomInfo nes_tetrisRomDesc[] = {
	{ "Tetris (USA).nes",          49168, 0x6d72c53a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tetris)
STD_ROM_FN(nes_tetris)

struct BurnDriver BurnDrvnes_tetris = {
	"nes_tetris", NULL, NULL, NULL, "1989",
	"Tetris (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_tetrisRomInfo, nes_tetrisRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tetris 2 (USA)
static struct BurnRomInfo nes_tetris2RomDesc[] = {
	{ "Tetris 2 (USA).nes",          262160, 0xb6c0718b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tetris2)
STD_ROM_FN(nes_tetris2)

struct BurnDriver BurnDrvnes_tetris2 = {
	"nes_tetris2", NULL, NULL, NULL, "1993",
	"Tetris 2 (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_tetris2RomInfo, nes_tetris2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tetris 2 + Bombliss (Japan)
static struct BurnRomInfo nes_tetri2bomRomDesc[] = {
	{ "Tetris 2 + Bombliss (Japan).nes",          131088, 0xd7b8aea3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tetri2bom)
STD_ROM_FN(nes_tetri2bom)

struct BurnDriver BurnDrvnes_tetri2bom = {
	"nes_tetri2bom", NULL, NULL, NULL, "1991",
	"Tetris 2 + Bombliss (Japan)\0", NULL, "Bullet-Proof Software", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_tetri2bomRomInfo, nes_tetri2bomRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tetsuwan Atom (Japan)
static struct BurnRomInfo nes_tetsuwanatomRomDesc[] = {
	{ "Tetsuwan Atom (Japan).nes",          262160, 0x6673e5da, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tetsuwanatom)
STD_ROM_FN(nes_tetsuwanatom)

struct BurnDriver BurnDrvnes_tetsuwanatom = {
	"nes_tetsuwanatom", "nes_astroboy", NULL, NULL, "1988",
	"Tetsuwan Atom (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_tetsuwanatomRomInfo, nes_tetsuwanatomRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Thexder (Japan)
static struct BurnRomInfo nes_thexderRomDesc[] = {
	{ "Thexder (Japan).nes",          40976, 0xf82c7789, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_thexder)
STD_ROM_FN(nes_thexder)

struct BurnDriver BurnDrvnes_thexder = {
	"nes_thexder", NULL, NULL, NULL, "1985",
	"Thexder (Japan)\0", NULL, "Square", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_thexderRomInfo, nes_thexderRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Three Stooges (USA)
static struct BurnRomInfo nes_threestoogesRomDesc[] = {
	{ "Three Stooges (USA).nes",          262160, 0x3e3ff3c4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_threestooges)
STD_ROM_FN(nes_threestooges)

struct BurnDriver BurnDrvnes_threestooges = {
	"nes_threestooges", NULL, NULL, NULL, "1989",
	"Three Stooges (USA)\0", NULL, "Activision", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_MINIGAMES, 0,
	NESGetZipName, nes_threestoogesRomInfo, nes_threestoogesRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Thunder & Lightning (USA)
static struct BurnRomInfo nes_thundligRomDesc[] = {
	{ "Thunder & Lightning (USA).nes",          163856, 0x0b80795e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_thundlig)
STD_ROM_FN(nes_thundlig)

struct BurnDriver BurnDrvnes_thundlig = {
	"nes_thundlig", NULL, NULL, NULL, "1990",
	"Thunder & Lightning (USA)\0", NULL, "Romstar", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_BREAKOUT, 0,
	NESGetZipName, nes_thundligRomInfo, nes_thundligRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Thunder Warrior (Asia) (Unl)
static struct BurnRomInfo nes_thunderwarriorRomDesc[] = {
	{ "Thunder Warrior (Asia) (Unl).nes",          262160, 0x81600926, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_thunderwarrior)
STD_ROM_FN(nes_thunderwarrior)

struct BurnDriver BurnDrvnes_thunderwarrior = {
	"nes_thunderwarrior", NULL, NULL, NULL, "1992",
	"Thunder Warrior (Asia) (Unl)\0", NULL, "Micro Genius", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_thunderwarriorRomInfo, nes_thunderwarriorRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Thunderbirds (USA)
static struct BurnRomInfo nes_thunderbirdsRomDesc[] = {
	{ "Thunderbirds (USA).nes",          262160, 0x406f0ced, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_thunderbirds)
STD_ROM_FN(nes_thunderbirds)

struct BurnDriver BurnDrvnes_thunderbirds = {
	"nes_thunderbirds", NULL, NULL, NULL, "1990",
	"Thunderbirds (USA)\0", NULL, "Activision", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_thunderbirdsRomInfo, nes_thunderbirdsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Thunderbolt 2 (China)
static struct BurnRomInfo nes_thunderbolt2RomDesc[] = {
	{ "Thunderbolt 2 (Ch).nes",          262160, 0xce1813c9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_thunderbolt2)
STD_ROM_FN(nes_thunderbolt2)

struct BurnDriver BurnDrvnes_thunderbolt2 = {
	"nes_thunderbolt2", NULL, NULL, NULL, "1993",
	"Thunderbolt 2 (China)\0", NULL, "Gamtec", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_thunderbolt2RomInfo, nes_thunderbolt2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Thundercade (USA)
static struct BurnRomInfo nes_thundercadeRomDesc[] = {
	{ "Thundercade (USA).nes",          131088, 0x6c430704, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_thundercade)
STD_ROM_FN(nes_thundercade)

struct BurnDriver BurnDrvnes_thundercade = {
	"nes_thundercade", NULL, NULL, NULL, "1989",
	"Thundercade (USA)\0", NULL, "Sammy", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_thundercadeRomInfo, nes_thundercadeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tiger-Heli (USA)
static struct BurnRomInfo nes_tigerheliRomDesc[] = {
	{ "Tiger-Heli (USA).nes",          65552, 0x1ad8d039, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tigerheli)
STD_ROM_FN(nes_tigerheli)

struct BurnDriver BurnDrvnes_tigerheli = {
	"nes_tigerheli", NULL, NULL, NULL, "1987",
	"Tiger-Heli (USA)\0", NULL, "Acclaim", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_tigerheliRomInfo, nes_tigerheliRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Time Diver Eon Man (USA)
static struct BurnRomInfo nes_timediveonmanRomDesc[] = {
	{ "Time Diver Eon Man (USA).nes",          262160, 0x9562d0d5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_timediveonman)
STD_ROM_FN(nes_timediveonman)

struct BurnDriver BurnDrvnes_timediveonman = {
	"nes_timediveonman", NULL, NULL, NULL, "1993",
	"Time Diver Eon Man (USA)\0", NULL, "Taito Corp.", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, nes_timediveonmanRomInfo, nes_timediveonmanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Time Lord (USA)
static struct BurnRomInfo nes_timelordRomDesc[] = {
	{ "Time Lord (USA).nes",          131088, 0xe37ad9fb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_timelord)
STD_ROM_FN(nes_timelord)

struct BurnDriver BurnDrvnes_timelord = {
	"nes_timelord", NULL, NULL, NULL, "1990",
	"Time Lord (USA)\0", NULL, "Milton Bradley", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, nes_timelordRomInfo, nes_timelordRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Time Zone (Japan)
static struct BurnRomInfo nes_timezonejRomDesc[] = {
	{ "Time Zone (Japan)(1991)(Sigma).nes",          262160, 0xc99628bc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_timezonej)
STD_ROM_FN(nes_timezonej)

struct BurnDriver BurnDrvnes_timezonej = {
	"nes_timezonej", "nes_timezone", NULL, NULL, "1991",
	"Time Zone (Japan)\0", NULL, "Sigma Enterprises", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_timezonejRomInfo, nes_timezonejRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Time Zone (Hack, English v1.3)
// https://www.romhacking.net/translations/228/
static struct BurnRomInfo nes_timezoneRomDesc[] = {
	{ "Time Zone T-Eng v1.3 (2013)(KingMike's Translations).nes",          262160, 0x4ffe1ceb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_timezone)
STD_ROM_FN(nes_timezone)

struct BurnDriver BurnDrvnes_timezone = {
	"nes_timezone", NULL, NULL, NULL, "2014",
	"Time Zone (Hack, English v1.3)\0", NULL, "KingMike's Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_timezoneRomInfo, nes_timezoneRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tiny Toon Adventures (USA)
static struct BurnRomInfo nes_tinytooadvRomDesc[] = {
	{ "Tiny Toon Adventures (USA).nes",          262160, 0xb34ed396, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tinytooadv)
STD_ROM_FN(nes_tinytooadv)

struct BurnDriver BurnDrvnes_tinytooadv = {
	"nes_tinytooadv", NULL, NULL, NULL, "1991",
	"Tiny Toon Adventures (USA)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_tinytooadvRomInfo, nes_tinytooadvRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tiny Toon Adventures 2 - Montana Land he Youkoso (Japan)
static struct BurnRomInfo nes_tinytooadv2molaheyoRomDesc[] = {
	{ "Tiny Toon Adventures 2 - Montana Land he Youkoso (Japan).nes",          262160, 0x2506e382, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tinytooadv2molaheyo)
STD_ROM_FN(nes_tinytooadv2molaheyo)

struct BurnDriver BurnDrvnes_tinytooadv2molaheyo = {
	"nes_tinytooadv2molaheyo", "nes_tinytooadv2trinwa", NULL, NULL, "1992",
	"Tiny Toon Adventures 2 - Montana Land he Youkoso (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_tinytooadv2molaheyoRomInfo, nes_tinytooadv2molaheyoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tiny Toon Adventures 2 - Trouble in Wackyland (USA)
static struct BurnRomInfo nes_tinytooadv2trinwaRomDesc[] = {
	{ "Tiny Toon Adventures 2 - Trouble in Wackyland (USA).nes",          262160, 0xab36e3f7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tinytooadv2trinwa)
STD_ROM_FN(nes_tinytooadv2trinwa)

struct BurnDriver BurnDrvnes_tinytooadv2trinwa = {
	"nes_tinytooadv2trinwa", NULL, NULL, NULL, "1993",
	"Tiny Toon Adventures 2 - Trouble in Wackyland (USA)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_tinytooadv2trinwaRomInfo, nes_tinytooadv2trinwaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Titan (Japan)
static struct BurnRomInfo nes_titanRomDesc[] = {
	{ "Titan (Japan).nes",          131088, 0xa7508fb1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_titan)
STD_ROM_FN(nes_titan)

struct BurnDriver BurnDrvnes_titan = {
	"nes_titan", NULL, NULL, NULL, "1990",
	"Titan (Japan)\0", NULL, "Sofel", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_BREAKOUT | GBF_PUZZLE, 0,
	NESGetZipName, nes_titanRomInfo, nes_titanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Titan Warriors (USA) (Prototype)
static struct BurnRomInfo nes_titanwarriorsRomDesc[] = {
	{ "Titan Warriors (USA) (Proto).nes",          131088, 0xb06f1c46, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_titanwarriors)
STD_ROM_FN(nes_titanwarriors)

struct BurnDriver BurnDrvnes_titanwarriors = {
	"nes_titanwarriors", NULL, NULL, NULL, "1988",
	"Titan Warriors (USA) (Prototype)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_PROTOTYPE, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_titanwarriorsRomInfo, nes_titanwarriorsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

//Tombs & Treasure (USA)
static struct BurnRomInfo nes_tmbtreasureRomDesc[] = {
	{ "Tombs & Treasure (U)(1989)(Infocom).nes",          262160, 0x013bd19f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tmbtreasure)
STD_ROM_FN(nes_tmbtreasure)

struct BurnDriver BurnDrvnes_tmbtreasure = {
	"nes_tmbtreasure", NULL, NULL, NULL, "1989",
	"Tombs & Treasure (USA)\0", NULL, "Infocom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG | GBF_ADV, 0,
	NESGetZipName, nes_tmbtreasureRomInfo, nes_tmbtreasureRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// To The Earth (USA)
static struct BurnRomInfo nes_totheearthRomDesc[] = {
	{ "To The Earth (USA).nes",          65552, 0x4137b9b3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_totheearth)
STD_ROM_FN(nes_totheearth)

struct BurnDriver BurnDrvnes_totheearth = {
	"nes_totheearth", NULL, NULL, NULL, "1989",
	"To The Earth (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_totheearthRomInfo, nes_totheearthRomName, NULL, NULL, NULL, NULL, NESZapperInputInfo, NESZapperDIPInfo,
	NESZapperInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Toki (USA)
static struct BurnRomInfo nes_tokiRomDesc[] = {
	{ "Toki (USA).nes",          393232, 0x5bd50be6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_toki)
STD_ROM_FN(nes_toki)

struct BurnDriver BurnDrvnes_toki = {
	"nes_toki", NULL, NULL, NULL, "1991",
	"Toki (USA)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_tokiRomInfo, nes_tokiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tokkyuu Shirei Solbrain (Japan)
static struct BurnRomInfo nes_tokkyshisoljRomDesc[] = {
	{ "Tokkyuu Shirei Solbrain (Japan).nes",          262160, 0x6a09e2bb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tokkyshisolj)
STD_ROM_FN(nes_tokkyshisolj)

struct BurnDriver BurnDrvnes_tokkyshisolj = {
	"nes_tokkyshisolj", "nes_shatterhand", NULL, NULL, "1991",
	"Tokkyuu Shirei Solbrain (Japan)\0", NULL, "Angel Studio", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_tokkyshisoljRomInfo, nes_tokkyshisoljRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tokkyuu Shirei Solbrain (Hack, English)
static struct BurnRomInfo nes_tokkyshisolRomDesc[] = {
	{ "Tokkyuu Shirei Solbrain (T-Eng).nes",          262160, 0xf84e3211, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tokkyshisol)
STD_ROM_FN(nes_tokkyshisol)

struct BurnDriver BurnDrvnes_tokkyshisol = {
	"nes_tokkyshisol", "nes_shatterhand", NULL, NULL, "2019",
	"Tokkyuu Shirei Solbrain (Hack, English)\0", NULL, "chronix", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_tokkyshisolRomInfo, nes_tokkyshisolRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tokoro-san no Mamoru mo Semeru mo (Japan)
static struct BurnRomInfo nes_tokorsannomammosemoRomDesc[] = {
	{ "Tokoro-san no Mamoru mo Semeru mo (Japan).nes",          65552, 0x285db36b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tokorsannomammosemo)
STD_ROM_FN(nes_tokorsannomammosemo)

struct BurnDriver BurnDrvnes_tokorsannomammosemo = {
	"nes_tokorsannomammosemo", NULL, NULL, NULL, "1987",
	"Tokoro-san no Mamoru mo Semeru mo (Japan)\0", NULL, "Epic/Sony Records", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_tokorsannomammosemoRomInfo, nes_tokorsannomammosemoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tom & Jerry - The Ultimate Game of Cat and Mouse! (USA)
static struct BurnRomInfo nes_tomjerultgamcatandmRomDesc[] = {
	{ "Tom & Jerry - The Ultimate Game of Cat and Mouse! (USA).nes",          262160, 0xfca83867, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tomjerultgamcatandm)
STD_ROM_FN(nes_tomjerultgamcatandm)

struct BurnDriver BurnDrvnes_tomjerultgamcatandm = {
	"nes_tomjerultgamcatandm", NULL, NULL, NULL, "1991",
	"Tom & Jerry - The Ultimate Game of Cat and Mouse! (USA)\0", NULL, "Hi Tech Expressions", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_tomjerultgamcatandmRomInfo, nes_tomjerultgamcatandmRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Toobin' (USA)
static struct BurnRomInfo nes_toobinRomDesc[] = {
	{ "Toobin' (USA).nes",          196624, 0x1cb59544, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_toobin)
STD_ROM_FN(nes_toobin)

struct BurnDriver BurnDrvnes_toobin = {
	"nes_toobin", NULL, NULL, NULL, "1989",
	"Toobin' (USA)\0", NULL, "Tengen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_toobinRomInfo, nes_toobinRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Top Gun (USA) (Rev A)
static struct BurnRomInfo nes_topgunRomDesc[] = {
	{ "Top Gun (USA) (Rev A).nes",          131088, 0x0c9a67a8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_topgun)
STD_ROM_FN(nes_topgun)

struct BurnDriver BurnDrvnes_topgun = {
	"nes_topgun", NULL, NULL, NULL, "1987",
	"Top Gun (USA) (Rev A)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SIM | GBF_SHOOT, 0,
	NESGetZipName, nes_topgunRomInfo, nes_topgunRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Top Gun - The Second Mission (USA)
static struct BurnRomInfo nes_topgunsecmisRomDesc[] = {
	{ "Top Gun - The Second Mission (USA).nes",          262160, 0x4519fb7a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_topgunsecmis)
STD_ROM_FN(nes_topgunsecmis)

struct BurnDriver BurnDrvnes_topgunsecmis = {
	"nes_topgunsecmis", NULL, NULL, NULL, "1990",
	"Top Gun - The Second Mission (USA)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SIM | GBF_SHOOT, 0,
	NESGetZipName, nes_topgunsecmisRomInfo, nes_topgunsecmisRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Top Rider (Japan)
static struct BurnRomInfo nes_topriderRomDesc[] = {
	{ "Top Rider (Japan).nes",          163856, 0xca1a395a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_toprider)
STD_ROM_FN(nes_toprider)

struct BurnDriver BurnDrvnes_toprider = {
	"nes_toprider", NULL, NULL, NULL, "1988",
	"Top Rider (Japan)\0", NULL, "Varie", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_topriderRomInfo, nes_topriderRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	topriderInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Top Striker (Japan)
static struct BurnRomInfo nes_topstrikerRomDesc[] = {
	{ "Top Striker (Japan).nes",          262160, 0xb1e92643, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_topstriker)
STD_ROM_FN(nes_topstriker)

struct BurnDriver BurnDrvnes_topstriker = {
	"nes_topstriker", NULL, NULL, NULL, "1992",
	"Top Striker (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSFOOTBALL, 0,
	NESGetZipName, nes_topstrikerRomInfo, nes_topstrikerRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Total Recall (USA)
static struct BurnRomInfo nes_totalrecallRomDesc[] = {
	{ "Total Recall (USA).nes",          131088, 0x178cb593, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_totalrecall)
STD_ROM_FN(nes_totalrecall)

struct BurnDriver BurnDrvnes_totalrecall = {
	"nes_totalrecall", NULL, NULL, NULL, "1990",
	"Total Recall (USA)\0", NULL, "Acclaim", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_totalrecallRomInfo, nes_totalrecallRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Totally Rad (USA)
static struct BurnRomInfo nes_totallyradRomDesc[] = {
	{ "Totally Rad (USA).nes",          262160, 0x9cbaddc7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_totallyrad)
STD_ROM_FN(nes_totallyrad)

struct BurnDriver BurnDrvnes_totallyrad = {
	"nes_totallyrad", NULL, NULL, NULL, "1991",
	"Totally Rad (USA)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_totallyradRomInfo, nes_totallyradRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Totsuzen! Machoman (Japan)
static struct BurnRomInfo nes_totsumacRomDesc[] = {
	{ "Totsuzen! Machoman (Japan).nes",          131088, 0xd1442067, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_totsumac)
STD_ROM_FN(nes_totsumac)

struct BurnDriver BurnDrvnes_totsumac = {
	"nes_totsumac", "nes_amagon", NULL, NULL, "1988",
	"Totsuzen! Machoman (Japan)\0", NULL, "Sammy", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_totsumacRomInfo, nes_totsumacRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Toukon Club (Japan)
static struct BurnRomInfo nes_toukonclubRomDesc[] = {
	{ "Toukon Club (Japan).nes",          393232, 0x33963d30, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_toukonclub)
STD_ROM_FN(nes_toukonclub)

struct BurnDriver BurnDrvnes_toukonclub = {
	"nes_toukonclub", NULL, NULL, NULL, "1992",
	"Toukon Club (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_toukonclubRomInfo, nes_toukonclubRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tower of Druaga, The (Japan)
static struct BurnRomInfo nes_towerdruRomDesc[] = {
	{ "Tower of Druaga, The (Japan).nes",          40976, 0x0c045fb9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_towerdru)
STD_ROM_FN(nes_towerdru)

struct BurnDriver BurnDrvnes_towerdru = {
	"nes_towerdru", NULL, NULL, NULL, "1985",
	"Tower of Druaga, The (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_MAZE | GBF_ACTION, 0,
	NESGetZipName, nes_towerdruRomInfo, nes_towerdruRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Toxic Crusaders (USA)
static struct BurnRomInfo nes_toxiccrusadersRomDesc[] = {
	{ "Toxic Crusaders (USA).nes",          262160, 0xda9ad540, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_toxiccrusaders)
STD_ROM_FN(nes_toxiccrusaders)

struct BurnDriver BurnDrvnes_toxiccrusaders = {
	"nes_toxiccrusaders", NULL, NULL, NULL, "1992",
	"Toxic Crusaders (USA)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_toxiccrusadersRomInfo, nes_toxiccrusadersRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Track & Field (USA)
static struct BurnRomInfo nes_trackfieldRomDesc[] = {
	{ "Track & Field (USA)(1987)(Konami).nes",          65552, 0xd3b42f6d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_trackfield)
STD_ROM_FN(nes_trackfield)

struct BurnDriver BurnDrvnes_trackfield = {
	"nes_trackfield", NULL, NULL, NULL, "1987",
	"Track & Field (USA)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_trackfieldRomInfo, nes_trackfieldRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Track & Field II (USA, Rev A)
static struct BurnRomInfo nes_trackfieldiiRomDesc[] = {
	{ "Track & Field II (USA)(Rev A)(1989)(Konami).nes",          262160, 0x1212b0c9, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_trackfieldii)
STD_ROM_FN(nes_trackfieldii)

struct BurnDriver BurnDrvnes_trackfieldii = {
	"nes_trackfieldii", NULL, NULL, NULL, "1989",
	"Track & Field II (USA, Rev A)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_trackfieldiiRomInfo, nes_trackfieldiiRomName, NULL, NULL, NULL, NULL, NESZapperInputInfo, NESZapperDIPInfo,
	NESZapperInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Transformers - The Mystery of Optimus Prime (Hack, English)
// https://www.romhacking.net/translations/7328/
static struct BurnRomInfo nes_transformersRomDesc[] = {
	{ "Transformers - The Mystery of Optimus Prime T-Eng (2024)(BlackPaladin).nes",          65552, 0x156d8b2d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_transformers)
STD_ROM_FN(nes_transformers)

struct BurnDriver BurnDrvnes_transformers = {
	"nes_transformers", NULL, NULL, NULL, "2024",
	"Transformers - The Mystery of Optimus Prime (Hack, English)\0", NULL, "BlackPaladin", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_transformersRomInfo, nes_transformersRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Treasure Master (USA)
static struct BurnRomInfo nes_treasuremasterRomDesc[] = {
	{ "Treasure Master (USA)(1991)(American Softworks).nes",          262160, 0xd4ab7922, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_treasuremaster)
STD_ROM_FN(nes_treasuremaster)

struct BurnDriver BurnDrvnes_treasuremaster = {
	"nes_treasuremaster", NULL, NULL, NULL, "1991",
	"Treasure Master (USA)\0", NULL, "American Softworks", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_treasuremasterRomInfo, nes_treasuremasterRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Trog (USA)
static struct BurnRomInfo nes_trogRomDesc[] = {
	{ "Trog (USA)(1991)(Acclaim).nes",          131088, 0xdd6141df, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_trog)
STD_ROM_FN(nes_trog)

struct BurnDriver BurnDrvnes_trog = {
	"nes_trog", NULL, NULL, NULL, "1991",
	"Trog (USA)\0", NULL, "Acclaim Entertainment", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_MAZE | GBF_ACTION, 0,
	NESGetZipName, nes_trogRomInfo, nes_trogRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Trojan (USA).nes
static struct BurnRomInfo nes_trojanRomDesc[] = {
	{ "Trojan (USA)(1987)(Capcom).nes",          131088, 0xcf378fb2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_trojan)
STD_ROM_FN(nes_trojan)

struct BurnDriver BurnDrvnes_trojan = {
	"nes_trojan", NULL, NULL, NULL, "1987",
	"Trojan (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SCRFIGHT, 0,
	NESGetZipName, nes_trojanRomInfo, nes_trojanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tsuppari Oozumou (Japan)
static struct BurnRomInfo nes_tsupparioozumouRomDesc[] = {
	{ "Tsuppari Oozumou (Japan)(1987)(Tecmo).nes",          65552, 0xdfc7c0c2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tsupparioozumou)
STD_ROM_FN(nes_tsupparioozumou)

struct BurnDriver BurnDrvnes_tsupparioozumou = {
	"nes_tsupparioozumou", NULL, NULL, NULL, "1987",
	"Tsuppari Oozumou (Japan)\0", NULL, "Tecmo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_tsupparioozumouRomInfo, nes_tsupparioozumouRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tsuri Kichi Sanpei - Blue Marlin Hen (Japan)
static struct BurnRomInfo nes_tsurikicsanjRomDesc[] = {
	{ "Tsuri Kichi Sanpei - Blue Marlin Hen (Japan)(1988)(Victor).nes",          131088, 0x99ef9cc3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tsurikicsanj)
STD_ROM_FN(nes_tsurikicsanj)

struct BurnDriver BurnDrvnes_tsurikicsanj = {
	"nes_tsurikicsanj", "nes_tsurikicsan", NULL, NULL, "1988",
	"Tsuri Kichi Sanpei - Blue Marlin Hen (Japan)\0", NULL, "Victor", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_SPORTSMISC | GBF_ADV, 0,
	NESGetZipName, nes_tsurikicsanjRomInfo, nes_tsurikicsanjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Tsuri Kichi Sanpei - Blue Marlin Hen (Hack, English v0.94b)
// https://www.romhacking.net/translations/2533/
static struct BurnRomInfo nes_tsurikicsanRomDesc[] = {
	{ "Tsuri Kichi Sanpei - Blue Marlin Hen T-Eng v0.94b (2015)(MrRichard999).nes",          131088, 0xa3479469, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_tsurikicsan)
STD_ROM_FN(nes_tsurikicsan)

struct BurnDriver BurnDrvnes_tsurikicsan = {
	"nes_tsurikicsan", NULL, NULL, NULL, "2015",
	"Tsuri Kichi Sanpei - Blue Marlin Hen (Hack, English v0.94b)\0", NULL, "MrRichard999", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_SPORTSMISC | GBF_ADV, 0,
	NESGetZipName, nes_tsurikicsanRomInfo, nes_tsurikicsanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Twin Cobra (USA)
static struct BurnRomInfo nes_twincobraRomDesc[] = {
	{ "Twin Cobra (USA)(1990)(Sammy).nes",          262160, 0x24643875, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_twincobra)
STD_ROM_FN(nes_twincobra)

struct BurnDriver BurnDrvnes_twincobra = {
	"nes_twincobra", NULL, NULL, NULL, "1990",
	"Twin Cobra (USA)\0", NULL, "Sammy", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_twincobraRomInfo, nes_twincobraRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Twin Eagle (USA)
static struct BurnRomInfo nes_twineagleRomDesc[] = {
	{ "Twin Eagle (USA)(1989)(Romstar).nes",          131088, 0xfc2f727d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_twineagle)
STD_ROM_FN(nes_twineagle)

struct BurnDriver BurnDrvnes_twineagle = {
	"nes_twineagle", NULL, NULL, NULL, "1989",
	"Twin Eagle (USA)\0", NULL, "Romstar", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_twineagleRomInfo, nes_twineagleRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// TwinBee (Japan)
static struct BurnRomInfo nes_twinbeeRomDesc[] = {
	{ "TwinBee (Japan).nes",          49168, 0x4433ba0a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_twinbee)
STD_ROM_FN(nes_twinbee)

struct BurnDriver BurnDrvnes_twinbee = {
	"nes_twinbee", NULL, NULL, NULL, "1986",
	"TwinBee (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_twinbeeRomInfo, nes_twinbeeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// TwinBee 3 - Poko Poko Daimaou (Japan)
static struct BurnRomInfo nes_twinb3jRomDesc[] = {
	{ "TwinBee 3 - Poko Poko Daimaou (Japan).nes",          262160, 0x96529c68, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_twinb3j)
STD_ROM_FN(nes_twinb3j)

struct BurnDriver BurnDrvnes_twinb3j = {
	"nes_twinb3j", "nes_twinb3", NULL, NULL, "1989",
	"TwinBee 3 - Poko Poko Daimaou (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_twinb3jRomInfo, nes_twinb3jRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// TwinBee 3 - The Terror Trunk (Hack, English v1.02)
// https://www.gamingalexandria.com/wp/2024/02/twinbee-3-poko-poko-dai-maou-nes-translation/
static struct BurnRomInfo nes_twinb3RomDesc[] = {
	{ "TwinBee 3 - The Terror Trunk T-Eng v1.02 (2024)(Pennywise).nes",          262160, 0x427e3892, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_twinb3)
STD_ROM_FN(nes_twinb3)

struct BurnDriver BurnDrvnes_twinb3 = {
	"nes_twinb3", NULL, NULL, NULL, "2024",
	"TwinBee 3 - The Terror Trunk (Hack, English v1.02)\0", NULL, "Pennywise", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_twinb3RomInfo, nes_twinb3RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// U.S. Championship V'Ball (Japan)
static struct BurnRomInfo nes_uschavbaRomDesc[] = {
	{ "U.S. Championship V'Ball (Japan).nes",          262160, 0x0bafbb69, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_uschavba)
STD_ROM_FN(nes_uschavba)

struct BurnDriver BurnDrvnes_uschavba = {
	"nes_uschavba", NULL, NULL, NULL, "1989",
	"U.S. Championship V'Ball (Japan)\0", NULL, "Technos", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_uschavbaRomInfo, nes_uschavbaRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NESHori4pInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Uchuu Keibitai SDF (Japan)
static struct BurnRomInfo nes_uchuukeisdfRomDesc[] = {
	{ "Uchuu Keibitai SDF (Japan).nes",          262160, 0xe8a98391, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_uchuukeisdf)
STD_ROM_FN(nes_uchuukeisdf)

struct BurnDriver BurnDrvnes_uchuukeisdf = {
	"nes_uchuukeisdf", NULL, NULL, NULL, "1990",
	"Uchuu Keibitai SDF (Japan)\0", NULL, "HAL Laboratory", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_uchuukeisdfRomInfo, nes_uchuukeisdfRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Uchuusen Cosmo Carrier (Japan)
static struct BurnRomInfo nes_uchuucoscarRomDesc[] = {
	{ "Uchuusen Cosmo Carrier (Japan).nes",          262160, 0x9298943a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_uchuucoscar)
STD_ROM_FN(nes_uchuucoscar)

struct BurnDriver BurnDrvnes_uchuucoscar = {
	"nes_uchuucoscar", NULL, NULL, NULL, "1987",
	"Uchuusen Cosmo Carrier (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_uchuucoscarRomInfo, nes_uchuucoscarRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ufouria - The Saga (Euro)
static struct BurnRomInfo nes_ufouriaRomDesc[] = {
	{ "Ufouria - The Saga (Europe).nes",          262160, 0x6453f65e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ufouria)
STD_ROM_FN(nes_ufouria)

struct BurnDriver BurnDrvnes_ufouria = {
	"nes_ufouria", NULL, NULL, NULL, "1992",
	"Ufouria - The Saga (Euro)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_ufouriaRomInfo, nes_ufouriaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT_PAL, SCREEN_WIDTH, SCREEN_HEIGHT_PAL
};

// Ultima - Exodus (USA)
static struct BurnRomInfo nes_ultimaexodusRomDesc[] = {
	{ "Ultima - Exodus (USA).nes",          262160, 0xc1a9e6c0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ultimaexodus)
STD_ROM_FN(nes_ultimaexodus)

struct BurnDriver BurnDrvnes_ultimaexodus = {
	"nes_ultimaexodus", NULL, NULL, NULL, "1989",
	"Ultima - Exodus (USA)\0", NULL, "FCI", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_ultimaexodusRomInfo, nes_ultimaexodusRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ultima - Exodus Remastered (Hack)
static struct BurnRomInfo nes_ultimexoremRomDesc[] = {
	{ "Ultima - Exodus Remastered (USA)(Hack).nes",          262160, 0x8afe467a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ultimexorem)
STD_ROM_FN(nes_ultimexorem)

struct BurnDriver BurnDrvnes_ultimexorem = {
	"nes_ultimexorem", "nes_ultimaexodus", NULL, NULL, "2020",
	"Ultima - Exodus Remastered (Hack)\0", NULL, "Fox Cunning", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_ultimexoremRomInfo, nes_ultimexoremRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ultima - Quest of the Avatar (USA)
static struct BurnRomInfo nes_ultimqueavaRomDesc[] = {
	{ "Ultima - Quest of the Avatar (USA).nes",          262160, 0xc7f5b3d8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ultimqueava)
STD_ROM_FN(nes_ultimqueava)

struct BurnDriver BurnDrvnes_ultimqueava = {
	"nes_ultimqueava", NULL, NULL, NULL, "1990",
	"Ultima - Quest of the Avatar (USA)\0", NULL, "FCI", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_ultimqueavaRomInfo, nes_ultimqueavaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ultima - Warriors of Destiny (USA)
static struct BurnRomInfo nes_ultimwardesRomDesc[] = {
	{ "Ultima - Warriors of Destiny (USA).nes",          262160, 0x2d8c2829, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ultimwardes)
STD_ROM_FN(nes_ultimwardes)

struct BurnDriver BurnDrvnes_ultimwardes = {
	"nes_ultimwardes", NULL, NULL, NULL, "1993",
	"Ultima - Warriors of Destiny (USA)\0", NULL, "FCI", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_ultimwardesRomInfo, nes_ultimwardesRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ultimate League Soccer (Italy)
static struct BurnRomInfo nes_ultimleasociRomDesc[] = {
	{ "Ultimate League Soccer (Italy).nes",          98320, 0x44197811, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ultimleasoci)
STD_ROM_FN(nes_ultimleasoci)

struct BurnDriver BurnDrvnes_ultimleasoci = {
	"nes_ultimleasoci", "nes_ultimleasoc", NULL, NULL, "1991",
	"Ultimate League Soccer (Italy)\0", NULL, "American Video Entertainment", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_SPORTSFOOTBALL, 0,
	NESGetZipName, nes_ultimleasociRomInfo, nes_ultimleasociRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ultimate League Soccer (USA)
static struct BurnRomInfo nes_ultimleasocRomDesc[] = {
	{ "Ultimate League Soccer (USA).nes",          98320, 0x38fb271b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ultimleasoc)
STD_ROM_FN(nes_ultimleasoc)

struct BurnDriver BurnDrvnes_ultimleasoc = {
	"nes_ultimleasoc", NULL, NULL, NULL, "1991",
	"Ultimate League Soccer (USA)\0", NULL, "American Video Entertainment", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSFOOTBALL, 0,
	NESGetZipName, nes_ultimleasocRomInfo, nes_ultimleasocRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ultimate Stuntman, The (USA)
static struct BurnRomInfo nes_ultimstuRomDesc[] = {
	{ "Ultimate Stuntman, The (USA) (Unl).nes",          262160, 0xe8ee7ddc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ultimstu)
STD_ROM_FN(nes_ultimstu)

struct BurnDriver BurnDrvnes_ultimstu = {
	"nes_ultimstu", NULL, NULL, NULL, "1991",
	"Ultimate Stuntman, The (USA)\0", NULL, "Camerica", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RACING | GBF_VERSHOOT, 0,
	NESGetZipName, nes_ultimstuRomInfo, nes_ultimstuRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ultraman Club - Kaijuu Daikessen!! (Japan)
static struct BurnRomInfo nes_ultraclubgkbjRomDesc[] = {
	{ "Ultraman Club - Kaijuu Daikessen!! (Japan)(1992)(Angel - Bandai).nes",          393232, 0x45fdb281, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ultraclubgkbj)
STD_ROM_FN(nes_ultraclubgkbj)

struct BurnDriver BurnDrvnes_ultraclubgkbj = {
	"nes_ultraclubgkbj", "nes_ultraclubgkb", NULL, NULL, "1992",
	"Ultraman Club - Kaijuu Daikessen!! (Japan)\0", NULL, "Angel - Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_ultraclubgkbjRomInfo, nes_ultraclubgkbjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ultraman Club - Great Kaiju Battle (Hack, English)
// https://www.romhacking.net/translations/3281/
static struct BurnRomInfo nes_ultraclubgkbRomDesc[] = {
	{ "Ultraman Club - Great Kaiju Battle T-Eng (2017)(Eric Engel, cccmar).nes",          393232, 0xf97911b7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ultraclubgkb)
STD_ROM_FN(nes_ultraclubgkb)

struct BurnDriver BurnDrvnes_ultraclubgkb = {
	"nes_ultraclubgkb", NULL, NULL, NULL, "2017",
	"Ultraman Club - Great Kaiju Battle (Hack, English)\0", NULL, "Eric Engel, cccmar", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_ultraclubgkbRomInfo, nes_ultraclubgkbRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Uncanny X-Men, The (USA)
static struct BurnRomInfo nes_uncanxmenRomDesc[] = {
	{ "Uncanny X-Men, The (USA).nes",          131088, 0x1e483ca6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_uncanxmen)
STD_ROM_FN(nes_uncanxmen)

struct BurnDriver BurnDrvnes_uncanxmen = {
	"nes_uncanxmen", NULL, NULL, NULL, "1989",
	"Uncanny X-Men, The (USA)\0", NULL, "Ljn", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_uncanxmenRomInfo, nes_uncanxmenRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Uncharted Waters (USA)
static struct BurnRomInfo nes_unchartedwatersRomDesc[] = {
	{ "Uncharted Waters (USA).nes",          655376, 0xd6a0ce38, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_unchartedwaters)
STD_ROM_FN(nes_unchartedwaters)

struct BurnDriver BurnDrvnes_unchartedwaters = {
	"nes_unchartedwaters", NULL, NULL, NULL, "1991",
	"Uncharted Waters (USA)\0", NULL, "Koei", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_unchartedwatersRomInfo, nes_unchartedwatersRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Uninvited (USA)
static struct BurnRomInfo nes_uninvitedRomDesc[] = {
	{ "Uninvited (USA).nes",          262160, 0x8579fa86, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_uninvited)
STD_ROM_FN(nes_uninvited)

struct BurnDriver BurnDrvnes_uninvited = {
	"nes_uninvited", NULL, NULL, NULL, "1991",
	"Uninvited (USA)\0", NULL, "Kemco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_uninvitedRomInfo, nes_uninvitedRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Uninvited Uncensored (Hack, v1.0f)
static struct BurnRomInfo nes_uninviteduRomDesc[] = {
	{ "Uninvited Uncensored v1.0f (2022)(Safaribans).nes",          262160, 0x7226c684, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_uninvitedu)
STD_ROM_FN(nes_uninvitedu)

struct BurnDriver BurnDrvnes_uninvitedu = {
	"nes_uninvitedu", "nes_uninvited", NULL, NULL, "2022",
	"Uninvited Uncensored (Hack, v1.0f)\0", NULL, "Safaribans", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_uninviteduRomInfo, nes_uninviteduRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Akuma no Shoutaijou (Japan)
static struct BurnRomInfo nes_uninvitedjRomDesc[] = {
	{ "Akuma no Shoutaijou (J)(1989)(Kemco).nes",          262160, 0x0c9dbb04, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_uninvitedj)
STD_ROM_FN(nes_uninvitedj)

struct BurnDriver BurnDrvnes_uninvitedj = {
	"nes_uninvitedj", "nes_uninvited", NULL, NULL, "1989",
	"Akuma no Shoutaijou (Japan)\0", NULL, "Kemco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_uninvitedjRomInfo, nes_uninvitedjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Universe Soldiers, The (China)
static struct BurnRomInfo nes_univesolRomDesc[] = {
	{ "Universe Soldiers, The (Ch).nes",          65552, 0x74bbcb02, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_univesol)
STD_ROM_FN(nes_univesol)

struct BurnDriver BurnDrvnes_univesol = {
	"nes_univesol", NULL, NULL, NULL, "1993",
	"Universe Soldiers, The (China)\0", NULL, "Whirlwind Manu", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_MAZE | GBF_ACTION, 0,
	NESGetZipName, nes_univesolRomInfo, nes_univesolRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Urban Champion (World)
static struct BurnRomInfo nes_urbanchampionRomDesc[] = {
	{ "Urban Champion (World).nes",          24592, 0x0770cdaa, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_urbanchampion)
STD_ROM_FN(nes_urbanchampion)

struct BurnDriver BurnDrvnes_urbanchampion = {
	"nes_urbanchampion", NULL, NULL, NULL, "1984",
	"Urban Champion (World)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_urbanchampionRomInfo, nes_urbanchampionRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Urusei Yatsura - Lum no Wedding Bell (Japan)
static struct BurnRomInfo nes_uruseyatRomDesc[] = {
	{ "Urusei Yatsura - Lum no Wedding Bell (Japan).nes",          65552, 0x7516a5b4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_uruseyat)
STD_ROM_FN(nes_uruseyat)

struct BurnDriver BurnDrvnes_uruseyat = {
	"nes_uruseyat", NULL, NULL, NULL, "1986",
	"Urusei Yatsura - Lum no Wedding Bell (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_uruseyatRomInfo, nes_uruseyatRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

//Ushio to Tora - Shinen no Taiyou (Japan)
static struct BurnRomInfo nes_ushiotorajRomDesc[] = {
	{ "Ushio to Tora - Shinen no Taiyou (J)(1993)(Yutaka).nes",          393232, 0x7aa8f7d0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ushiotoraj)
STD_ROM_FN(nes_ushiotoraj)

struct BurnDriver BurnDrvnes_ushiotoraj = {
	"nes_ushiotoraj", "nes_ushiotora", NULL, NULL, "1993",
	"Ushio to Tora - Shinen no Taiyou (Japan)\0", NULL, "Yutaka", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_ushiotorajRomInfo, nes_ushiotorajRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

//Ushio to Tora - Shinen no Taiyou (Hack, English)
static struct BurnRomInfo nes_ushiotoraRomDesc[] = {
	{ "Ushio to Tora - Shinen no Taiyou T-Eng (2022)(BlackPaladin).nes",          393232, 0x9472f0af, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ushiotora)
STD_ROM_FN(nes_ushiotora)

struct BurnDriver BurnDrvnes_ushiotora = {
	"nes_ushiotora", NULL, NULL, NULL, "2022",
	"Ushio to Tora - Shinen no Taiyou (Hack, English)\0", NULL, "BlackPaladin", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_ushiotoraRomInfo, nes_ushiotoraRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Utsurun Desu (Japan)
static struct BurnRomInfo nes_utsurundesuRomDesc[] = {
	{ "Utsurun Desu (Japan).nes",          262160, 0x0a56d915, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_utsurundesu)
STD_ROM_FN(nes_utsurundesu)

struct BurnDriver BurnDrvnes_utsurundesu = {
	"nes_utsurundesu", NULL, NULL, NULL, "1991",
	"Utsurun Desu (Japan)\0", NULL, "Takara", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_utsurundesuRomInfo, nes_utsurundesuRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Valis - The Fantastic Soldier (Hack, English v1.1)
// https://www.romhacking.net/translations/1145/
static struct BurnRomInfo nes_valisRomDesc[] = {
	{ "Valis - The Fantasm Soldier T-Eng v1.1 (2021)(Sliver X, satsu).nes",          131088, 0x7970a635, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_valis)
STD_ROM_FN(nes_valis)

struct BurnDriver BurnDrvnes_valis = {
	"nes_valis", NULL, NULL, NULL, "2021",
	"Valis - The Fantastic Soldier (Hack, English v1.1)\0", NULL, "Sliver X, satsu", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_valisRomInfo, nes_valisRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Mugen Senshi Valis (Japan)
static struct BurnRomInfo nes_valisjRomDesc[] = {
	{ "Mugen Senshi Valis (Japan)(1987)(Tokuma Shoten).nes",          131088, 0xf4637ec0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_valisj)
STD_ROM_FN(nes_valisj)

struct BurnDriver BurnDrvnes_valisj = {
	"nes_valisj", "nes_valis", NULL, NULL, "1987",
	"Mugen Senshi Valis (Japan)\0", NULL, "Tokuma Shoten", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_valisjRomInfo, nes_valisjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Valkyrie no Bouken - Toki no Kagi Densetsu (Japan)
static struct BurnRomInfo nes_valkynoboujRomDesc[] = {
	{ "Valkyrie no Bouken - Toki no Kagi Densetsu (Japan)(1986)(Namco).nes",          65552, 0x5915b843, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_valkynobouj)
STD_ROM_FN(nes_valkynobouj)

struct BurnDriver BurnDrvnes_valkynobouj = {
	"nes_valkynobouj", "nes_valkynobou", NULL, NULL, "1986",
	"Valkyrie no Bouken - Toki no Kagi Densetsu (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_valkynoboujRomInfo, nes_valkynoboujRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Valkyrie no Bouken - Toki no Kagi Densetsu (Hack, English)
// https://www.romhacking.net/translations/88/
static struct BurnRomInfo nes_valkynobouRomDesc[] = {
	{ "Valkyrie no Bouken - Toki no Kagi Densetsu T-Eng (2001)(Some Good Shit Trans.).nes",          65552, 0xe901fdd7, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_valkynobou)
STD_ROM_FN(nes_valkynobou)

struct BurnDriver BurnDrvnes_valkynobou = {
	"nes_valkynobou", NULL, NULL, NULL, "2001",
	"Valkyrie no Bouken - Toki no Kagi Densetsu (Hack, English)\0", NULL, "Some Good Shit Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_valkynobouRomInfo, nes_valkynobouRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Venice Beach Volleyball (Unl)
static struct BurnRomInfo nes_venicbeavolRomDesc[] = {
	{ "Venice Beach Volleyball (Unl).nes",          65552, 0x4a267783, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_venicbeavol)
STD_ROM_FN(nes_venicbeavol)

struct BurnDriver BurnDrvnes_venicbeavol = {
	"nes_venicbeavol", NULL, NULL, NULL, "1991",
	"Venice Beach Volleyball (Unl)\0", NULL, "American Video Entertainment", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_venicbeavolRomInfo, nes_venicbeavolRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Vice - Project Doom (USA)
static struct BurnRomInfo nes_viceRomDesc[] = {
	{ "Vice - Project Doom (USA).nes",          262160, 0x5fa46034, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vice)
STD_ROM_FN(nes_vice)

struct BurnDriver BurnDrvnes_vice = {
	"nes_vice", NULL, NULL, NULL, "1991",
	"Vice - Project Doom (USA)\0", NULL, "Sammy", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT | GBF_PLATFORM, 0,
	NESGetZipName, nes_viceRomInfo, nes_viceRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Vindicators (USA) (Prototype)
static struct BurnRomInfo nes_vindicatorsRomDesc[] = {
	{ "Vindicators (U)(Proto)(1988)(Tengen).nes",          98320, 0xcb2ef149, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vindicators)
STD_ROM_FN(nes_vindicators)

struct BurnDriver BurnDrvnes_vindicators = {
	"nes_vindicators", NULL, NULL, NULL, "1988",
	"Vindicators (USA) (Prototype)\0", NULL, "Tengen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_PROTOTYPE, 2, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_vindicatorsRomInfo, nes_vindicatorsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Virus (USA) (Prototype)
static struct BurnRomInfo nes_virusRomDesc[] = {
	{ "Virus (U)(Proto)(1990)(Nintendo).nes",          49168, 0x409c55f5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_virus)
STD_ROM_FN(nes_virus)

struct BurnDriver BurnDrvnes_virus = {
	"nes_virus", "nes_drmario", NULL, NULL, "1990",
	"Virus (USA) (Prototype)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_PROTOTYPE, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_virusRomInfo, nes_virusRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Volguard II (Japan)
static struct BurnRomInfo nes_volguardiiRomDesc[] = {
	{ "Volguard II (Japan).nes",          40976, 0x1a935610, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_volguardii)
STD_ROM_FN(nes_volguardii)

struct BurnDriver BurnDrvnes_volguardii = {
	"nes_volguardii", NULL, NULL, NULL, "1985",
	"Volguard II (Japan)\0", NULL, "dB-SOFT", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_volguardiiRomInfo, nes_volguardiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Volleyball (USA)
static struct BurnRomInfo nes_volleyballRomDesc[] = {
	{ "Volleyball (USA).nes",          40976, 0xc0056ceb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_volleyball)
STD_ROM_FN(nes_volleyball)

struct BurnDriver BurnDrvnes_volleyball = {
	"nes_volleyball", NULL, NULL, NULL, "1987",
	"Volleyball (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_volleyballRomInfo, nes_volleyballRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// VS. Super Mario Bros. Home Edition (Hack)
static struct BurnRomInfo nes_vssmbhomediRomDesc[] = {
	{ "VS. Super Mario Bros. Home Edition (Hack).nes",          65552, 0x13c77383, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_vssmbhomedi)
STD_ROM_FN(nes_vssmbhomedi)

struct BurnDriver BurnDrvnes_vssmbhomedi = {
	"nes_vssmbhomedi", "nes_smb", NULL, NULL, "2021",
	"VS. Super Mario Bros. Home Edition (Hack)\0", NULL, "BMF54123", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_vssmbhomediRomInfo, nes_vssmbhomediRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wacky Races (USA)
static struct BurnRomInfo nes_wackyracesRomDesc[] = {
	{ "Wacky Races (USA).nes",          262160, 0x6a862965, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_wackyraces)
STD_ROM_FN(nes_wackyraces)

struct BurnDriver BurnDrvnes_wackyraces = {
	"nes_wackyraces", NULL, NULL, NULL, "1992",
	"Wacky Races (USA)\0", NULL, "Atlus", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_wackyracesRomInfo, nes_wackyracesRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wagyan Land (Japan)
static struct BurnRomInfo nes_wagyanlandRomDesc[] = {
	{ "Wagyan Land (Japan).nes",          196624, 0x0797e1ae, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_wagyanland)
STD_ROM_FN(nes_wagyanland)

struct BurnDriver BurnDrvnes_wagyanland = {
	"nes_wagyanland", NULL, NULL, NULL, "1989",
	"Wagyan Land (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_wagyanlandRomInfo, nes_wagyanlandRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wagyan Land 2 (Japan)
static struct BurnRomInfo nes_wagyanland2RomDesc[] = {
	{ "Wagyan Land 2 (Japan).nes",          393232, 0x8aa76b0b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_wagyanland2)
STD_ROM_FN(nes_wagyanland2)

struct BurnDriver BurnDrvnes_wagyanland2 = {
	"nes_wagyanland2", NULL, NULL, NULL, "1990",
	"Wagyan Land 2 (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_wagyanland2RomInfo, nes_wagyanland2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wagyan Land 3 (Japan)
static struct BurnRomInfo nes_wagyanland3RomDesc[] = {
	{ "Wagyan Land 3 (Japan).nes",          524304, 0x7aff2388, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_wagyanland3)
STD_ROM_FN(nes_wagyanland3)

struct BurnDriver BurnDrvnes_wagyanland3 = {
	"nes_wagyanland3", NULL, NULL, NULL, "1992",
	"Wagyan Land 3 (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_wagyanland3RomInfo, nes_wagyanland3RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wai Wai World (Japan)
static struct BurnRomInfo nes_waiwaiworldjRomDesc[] = {
	{ "Wai Wai World (Japan).nes",          262160, 0xb27bcf3d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_waiwaiworldj)
STD_ROM_FN(nes_waiwaiworldj)

struct BurnDriver BurnDrvnes_waiwaiworldj = {
	"nes_waiwaiworldj", "nes_waiwaiworld", NULL, NULL, "1988",
	"Wai Wai World (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_waiwaiworldjRomInfo, nes_waiwaiworldjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wai Wai World (Hack, English)
static struct BurnRomInfo nes_waiwaiworldRomDesc[] = {
	{ "Wai Wai World (T-Eng).nes",          262160, 0xf668103d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_waiwaiworld)
STD_ROM_FN(nes_waiwaiworld)

struct BurnDriver BurnDrvnes_waiwaiworld = {
	"nes_waiwaiworld", NULL, NULL, NULL, "2019",
	"Wai Wai World (Hack, English)\0", NULL, "Zynk Oxhyde", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_waiwaiworldRomInfo, nes_waiwaiworldRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wai Wai World 2 - SOS!! Paseri Jou (Japan)
static struct BurnRomInfo nes_waiwaiwor2jRomDesc[] = {
	{ "Wai Wai World 2 - SOS!! Paseri Jou (Japan).nes",          393232, 0xebd96a66, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_waiwaiwor2j)
STD_ROM_FN(nes_waiwaiwor2j)

struct BurnDriver BurnDrvnes_waiwaiwor2j = {
	"nes_waiwaiwor2j", "nes_waiwaiwor2", NULL, NULL, "1991",
	"Wai Wai World 2 - SOS!! Paseri Jou (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_waiwaiwor2jRomInfo, nes_waiwaiwor2jRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wai Wai World 2 - SOS!! Paseri Jou (Hack, English)
static struct BurnRomInfo nes_waiwaiwor2RomDesc[] = {
	{ "Wai Wai World 2 - SOS!! Paseri Jou (T-Eng).nes",          393232, 0x45fadda1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_waiwaiwor2)
STD_ROM_FN(nes_waiwaiwor2)

struct BurnDriver BurnDrvnes_waiwaiwor2 = {
	"nes_waiwaiwor2", NULL, NULL, NULL, "2018",
	"Wai Wai World 2 - SOS!! Paseri Jou (Hack, English)\0", NULL, "chronix", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_waiwaiwor2RomInfo, nes_waiwaiwor2RomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wall Street Kid (USA)
static struct BurnRomInfo nes_wallstreetkidRomDesc[] = {
	{ "Wall Street Kid (USA).nes",          131088, 0x75917108, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_wallstreetkid)
STD_ROM_FN(nes_wallstreetkid)

struct BurnDriver BurnDrvnes_wallstreetkid = {
	"nes_wallstreetkid", NULL, NULL, NULL, "1990",
	"Wall Street Kid (USA)\0", NULL, "Sofel", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_STRATEGY, 0,
	NESGetZipName, nes_wallstreetkidRomInfo, nes_wallstreetkidRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wally Bear & the No Gang (Unl)
static struct BurnRomInfo nes_wallybeanoganRomDesc[] = {
	{ "Wally Bear & the No Gang (Unl).nes",          131088, 0xc562f258, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_wallybeanogan)
STD_ROM_FN(nes_wallybeanogan)

struct BurnDriver BurnDrvnes_wallybeanogan = {
	"nes_wallybeanogan", NULL, NULL, NULL, "1990",
	"Wally Bear & the No Gang (Unl)\0", NULL, "American Video Entertainment", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_wallybeanoganRomInfo, nes_wallybeanoganRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// War in the Gulf (Unl)
static struct BurnRomInfo nes_warinthegulfRomDesc[] = {
	{ "War in the Gulf (Unl).nes",          262160, 0xe45d5d88, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_warinthegulf)
STD_ROM_FN(nes_warinthegulf)

struct BurnDriver BurnDrvnes_warinthegulf = {
	"nes_warinthegulf", NULL, NULL, NULL, "1991",
	"War in the Gulf (Unl)\0", NULL, "Gluk Video - Mega Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_warinthegulfRomInfo, nes_warinthegulfRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wario's Woods (USA)
static struct BurnRomInfo nes_warioswoodsRomDesc[] = {
	{ "Wario's Woods (USA).nes",          524304, 0x9744b0ae, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_warioswoods)
STD_ROM_FN(nes_warioswoods)

struct BurnDriver BurnDrvnes_warioswoods = {
	"nes_warioswoods", NULL, NULL, NULL, "1994",
	"Wario's Woods (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_warioswoodsRomInfo, nes_warioswoodsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Warpman (Japan)
static struct BurnRomInfo nes_warpmanRomDesc[] = {
	{ "Warpman (Japan).nes",          24592, 0xef27556d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_warpman)
STD_ROM_FN(nes_warpman)

struct BurnDriver BurnDrvnes_warpman = {
	"nes_warpman", NULL, NULL, NULL, "1985",
	"Warpman (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_warpmanRomInfo, nes_warpmanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wayne's World (USA)
static struct BurnRomInfo nes_waynesworldRomDesc[] = {
	{ "Wayne's World (USA).nes",          262160, 0x9a5e089d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_waynesworld)
STD_ROM_FN(nes_waynesworld)

struct BurnDriver BurnDrvnes_waynesworld = {
	"nes_waynesworld", NULL, NULL, NULL, "1993",
	"Wayne's World (USA)\0", NULL, "THQ", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_waynesworldRomInfo, nes_waynesworldRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// WCW World Championship Wrestling (USA)
static struct BurnRomInfo nes_wcwworchawreRomDesc[] = {
	{ "WCW World Championship Wrestling (USA).nes",          262160, 0x7434dc82, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_wcwworchawre)
STD_ROM_FN(nes_wcwworchawre)

struct BurnDriver BurnDrvnes_wcwworchawre = {
	"nes_wcwworchawre", NULL, NULL, NULL, "1990",
	"WCW World Championship Wrestling (USA)\0", NULL, "FCI", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_wcwworchawreRomInfo, nes_wcwworchawreRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Werewolf - The Last Warrior (USA)
static struct BurnRomInfo nes_werewRomDesc[] = {
	{ "Werewolf - The Last Warrior (USA).nes",          262160, 0x19af4032, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_werew)
STD_ROM_FN(nes_werew)

struct BurnDriver BurnDrvnes_werew = {
	"nes_werew", NULL, NULL, NULL, "1990",
	"Werewolf - The Last Warrior (USA)\0", NULL, "Data East", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, nes_werewRomInfo, nes_werewRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Where in Time is Carmen Sandiego (USA)
static struct BurnRomInfo nes_whereintimiscasaRomDesc[] = {
	{ "Where in Time is Carmen Sandiego (USA).nes",          393232, 0xb515317d, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_whereintimiscasa)
STD_ROM_FN(nes_whereintimiscasa)

struct BurnDriver BurnDrvnes_whereintimiscasa = {
	"nes_whereintimiscasa", NULL, NULL, NULL, "1991",
	"Where in Time is Carmen Sandiego (USA)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_whereintimiscasaRomInfo, nes_whereintimiscasaRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Where's Waldo (USA)
static struct BurnRomInfo nes_whereswaldoRomDesc[] = {
	{ "Where's Waldo (USA).nes",          262160, 0xe9d532af, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_whereswaldo)
STD_ROM_FN(nes_whereswaldo)

struct BurnDriver BurnDrvnes_whereswaldo = {
	"nes_whereswaldo", NULL, NULL, NULL, "1991",
	"Where's Waldo (USA)\0", NULL, "THQ", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_whereswaldoRomInfo, nes_whereswaldoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Who Framed Roger Rabbit (USA)
static struct BurnRomInfo nes_whofrarograbRomDesc[] = {
	{ "Who Framed Roger Rabbit (USA).nes",          131088, 0xe21dab3e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_whofrarograb)
STD_ROM_FN(nes_whofrarograb)

struct BurnDriver BurnDrvnes_whofrarograb = {
	"nes_whofrarograb", NULL, NULL, NULL, "1989",
	"Who Framed Roger Rabbit (USA)\0", NULL, "Ljn", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_ADV, 0,
	NESGetZipName, nes_whofrarograbRomInfo, nes_whofrarograbRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Whomp 'Em (USA)
static struct BurnRomInfo nes_whompemRomDesc[] = {
	{ "Whomp 'Em (USA).nes",          262160, 0x4546aae3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_whompem)
STD_ROM_FN(nes_whompem)

struct BurnDriver BurnDrvnes_whompem = {
	"nes_whompem", NULL, NULL, NULL, "1991",
	"Whomp 'Em (USA)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_whompemRomInfo, nes_whompemRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Widget (USA)
static struct BurnRomInfo nes_widgetRomDesc[] = {
	{ "Widget (USA).nes",          262160, 0xcd5a8930, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_widget)
STD_ROM_FN(nes_widget)

struct BurnDriver BurnDrvnes_widget = {
	"nes_widget", NULL, NULL, NULL, "1992",
	"Widget (USA)\0", NULL, "Atlus", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_widgetRomInfo, nes_widgetRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wild Gunman (World) (Rev A)
static struct BurnRomInfo nes_wildgunmanRomDesc[] = {
	{ "Wild Gunman (World) (Rev A).nes",          24592, 0x330f53ee, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_wildgunman)
STD_ROM_FN(nes_wildgunman)

struct BurnDriver BurnDrvnes_wildgunman = {
	"nes_wildgunman", NULL, NULL, NULL, "1984",
	"Wild Gunman (World) (Rev A)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SHOOT, 0,
	NESGetZipName, nes_wildgunmanRomInfo, nes_wildgunmanRomName, NULL, NULL, NULL, NULL, NESZapperInputInfo, NESZapperDIPInfo,
	NESZapperInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Willow (USA)
static struct BurnRomInfo nes_willowRomDesc[] = {
	{ "Willow (USA).nes",          262160, 0x5f86a065, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_willow)
STD_ROM_FN(nes_willow)

struct BurnDriver BurnDrvnes_willow = {
	"nes_willow", NULL, NULL, NULL, "1989",
	"Willow (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_willowRomInfo, nes_willowRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Willow (Japan)
static struct BurnRomInfo nes_willowjRomDesc[] = {
	{ "Willow (Japan).nes",          262160, 0x189462c2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_willowj)
STD_ROM_FN(nes_willowj)

struct BurnDriver BurnDrvnes_willowj = {
	"nes_willowj", "nes_willow", NULL, NULL, "1989",
	"Willow (Japan)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_willowjRomInfo, nes_willowjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Willow (No Flash ed.) (Hack, v1.1)
// https://www.romhacking.net/hacks/4992/
static struct BurnRomInfo nes_willownfhRomDesc[] = {
	{ "Willow (Hack, No Flash).nes",          262160, 0x956ea1a6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_willownfh)
STD_ROM_FN(nes_willownfh)

struct BurnDriver BurnDrvnes_willownfh = {
	"nes_willownfh", "nes_willow", NULL, NULL, "2020",
	"Willow (No Flash ed.) (Hack, v1.1)\0", NULL, "Jigglysaint", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_willownfhRomInfo, nes_willownfhRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Win, Lose or Draw (USA)
static struct BurnRomInfo nes_winlosordraRomDesc[] = {
	{ "Win, Lose or Draw (USA).nes",          131088, 0x258d6838, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_winlosordra)
STD_ROM_FN(nes_winlosordra)

struct BurnDriver BurnDrvnes_winlosordra = {
	"nes_winlosordra", NULL, NULL, NULL, "1990",
	"Win, Lose or Draw (USA)\0", NULL, "Hi Tech Expressions", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_QUIZ, 0,
	NESGetZipName, nes_winlosordraRomInfo, nes_winlosordraRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wing of Madoola, The (Japan)
static struct BurnRomInfo nes_wingmadRomDesc[] = {
	{ "Wing of Madoola, The (Japan).nes",          65552, 0x929899d8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_wingmad)
STD_ROM_FN(nes_wingmad)

struct BurnDriver BurnDrvnes_wingmad = {
	"nes_wingmad", NULL, NULL, NULL, "1986",
	"Wing of Madoola, The (Japan)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_wingmadRomInfo, nes_wingmadRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Winter Games (USA)
static struct BurnRomInfo nes_wintergamesRomDesc[] = {
	{ "Winter Games (USA).nes",          131088, 0x55699336, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_wintergames)
STD_ROM_FN(nes_wintergames)

struct BurnDriver BurnDrvnes_wintergames = {
	"nes_wintergames", NULL, NULL, NULL, "1987",
	"Winter Games (USA)\0", NULL, "Acclaim", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_SPORTSMISC, 0,
	NESGetZipName, nes_wintergamesRomInfo, nes_wintergamesRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wit's (Japan)
static struct BurnRomInfo nes_witsRomDesc[] = {
	{ "Wit's (Japan).nes",          131088, 0x82b8b8be, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_wits)
STD_ROM_FN(nes_wits)

struct BurnDriver BurnDrvnes_wits = {
	"nes_wits", NULL, NULL, NULL, "1990",
	"Wit's (Japan)\0", NULL, "Athena", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 4, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_witsRomInfo, nes_witsRomName, NULL, NULL, NULL, NULL, NES4ScoreInputInfo, NES4ScoreDIPInfo,
	NESHori4pInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wizards & Warriors (USA)
static struct BurnRomInfo nes_wizarwarRomDesc[] = {
	{ "Wizards & Warriors (USA).nes",          131088, 0xd6fc36aa, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_wizarwar)
STD_ROM_FN(nes_wizarwar)

struct BurnDriver BurnDrvnes_wizarwar = {
	"nes_wizarwar", NULL, NULL, NULL, "1987",
	"Wizards & Warriors (USA)\0", NULL, "Acclaim", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_wizarwarRomInfo, nes_wizarwarRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wizards & Warriors III - Kuros - Visions of Power (USA)
static struct BurnRomInfo nes_wizarwariiiRomDesc[] = {
	{ "Wizards & Warriors III - Kuros - Visions of Power (USA).nes",          262160, 0x4f505449, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_wizarwariii)
STD_ROM_FN(nes_wizarwariii)

struct BurnDriver BurnDrvnes_wizarwariii = {
	"nes_wizarwariii", NULL, NULL, NULL, "1992",
	"Wizards & Warriors III - Kuros - Visions of Power (USA)\0", NULL, "Acclaim", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_wizarwariiiRomInfo, nes_wizarwariiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wolverine (USA)
static struct BurnRomInfo nes_wolverineRomDesc[] = {
	{ "Wolverine (USA).nes",          262160, 0x1fd46615, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_wolverine)
STD_ROM_FN(nes_wolverine)

struct BurnDriver BurnDrvnes_wolverine = {
	"nes_wolverine", NULL, NULL, NULL, "1991",
	"Wolverine (USA)\0", NULL, "Ljn", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_wolverineRomInfo, nes_wolverineRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Woody Poko (Japan)
static struct BurnRomInfo nes_woodypokoRomDesc[] = {
	{ "Woody Poko (Japan).nes",          131088, 0x9eb1c3cc, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_woodypoko)
STD_ROM_FN(nes_woodypoko)

struct BurnDriver BurnDrvnes_woodypoko = {
	"nes_woodypoko", NULL, NULL, NULL, "1987",
	"Woody Poko (Japan)\0", NULL, "dB-SOFT", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_woodypokoRomInfo, nes_woodypokoRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// World Champ (USA)
static struct BurnRomInfo nes_worldchampRomDesc[] = {
	{ "World Champ (USA).nes",          262160, 0xaf00ed3f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_worldchamp)
STD_ROM_FN(nes_worldchamp)

struct BurnDriver BurnDrvnes_worldchamp = {
	"nes_worldchamp", NULL, NULL, NULL, "1991",
	"World Champ (USA)\0", NULL, "Romstar", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_worldchampRomInfo, nes_worldchampRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wrath of the Black Manta (USA) (Rev A)
static struct BurnRomInfo nes_wrathblamanRomDesc[] = {
	{ "Wrath of the Black Manta (USA) (Rev A).nes",          262160, 0x57340297, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_wrathblaman)
STD_ROM_FN(nes_wrathblaman)

struct BurnDriver BurnDrvnes_wrathblaman = {
	"nes_wrathblaman", NULL, NULL, NULL, "1990",
	"Wrath of the Black Manta (USA) (Rev A)\0", NULL, "Taito", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, nes_wrathblamanRomInfo, nes_wrathblamanRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wrecking Crew (World)
static struct BurnRomInfo nes_wreckingcrewRomDesc[] = {
	{ "Wrecking Crew (World).nes",          40976, 0x658d4fd4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_wreckingcrew)
STD_ROM_FN(nes_wreckingcrew)

struct BurnDriver BurnDrvnes_wreckingcrew = {
	"nes_wreckingcrew", NULL, NULL, NULL, "1985",
	"Wrecking Crew (World)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_wreckingcrewRomInfo, nes_wreckingcrewRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wrecking Crew HD (Hack)
// http://www.romhacking.net/hacks/5698/
static struct BurnRomInfo nes_wreckingcrewhdRomDesc[] = {
	{ "Wrecking Crew HD Hack (2021)(Scremer).nes",          40976, 0x8f732885, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_wreckingcrewhd)
STD_ROM_FN(nes_wreckingcrewhd)

struct BurnDriver BurnDrvnes_wreckingcrewhd = {
	"nes_wreckingcrewhd", "nes_wreckingcrew", NULL, NULL, "2021",
	"Wrecking Crew HD (Hack)\0", NULL, "Scremer", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 2, HARDWARE_NES, GBF_ACTION, 0,
	NESGetZipName, nes_wreckingcrewhdRomInfo, nes_wreckingcrewhdRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Wurm - Journey to the Center of the Earth! (USA)
static struct BurnRomInfo nes_wurmRomDesc[] = {
	{ "Wurm - Journey to the Center of the Earth! (USA).nes",          262160, 0xc1133e82, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_wurm)
STD_ROM_FN(nes_wurm)

struct BurnDriver BurnDrvnes_wurm = {
	"nes_wurm", NULL, NULL, NULL, "1991",
	"Wurm - Journey to the Center of the Earth! (USA)\0", NULL, "Asmik", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_wurmRomInfo, nes_wurmRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_xenophobeRomDesc[] = {
	{ "Xenophobe (USA).nes",          163856, 0xfc2188db, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_xenophobe)
STD_ROM_FN(nes_xenophobe)

struct BurnDriver BurnDrvnes_xenophobe = {
	"nes_xenophobe", NULL, NULL, NULL, "1988",
	"Xenophobe (USA)\0", NULL, "Sunsoft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_xenophobeRomInfo, nes_xenophobeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_xeviousRomDesc[] = {
	{ "Xevious - The Avenger (USA).nes",          40976, 0x210a2bbb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_xevious)
STD_ROM_FN(nes_xevious)

struct BurnDriver BurnDrvnes_xevious = {
	"nes_xevious", NULL, NULL, NULL, "1988",
	"Xevious - The Avenger (USA)\0", NULL, "Bandai", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_xeviousRomInfo, nes_xeviousRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

static struct BurnRomInfo nes_xexyzRomDesc[] = {
	{ "Xexyz (USA).nes",          262160, 0xdcd20ec8, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_xexyz)
STD_ROM_FN(nes_xexyz)

struct BurnDriver BurnDrvnes_xexyz = {
	"nes_xexyz", NULL, NULL, NULL, "1990",
	"Xexyz (USA)\0", NULL, "Hudson Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN | GBF_PLATFORM, 0,
	NESGetZipName, nes_xexyzRomInfo, nes_xexyzRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

//Xybots (USA) (Prototype)
static struct BurnRomInfo nes_xybotsRomDesc[] = {
	{ "Xybots (proto)(1990)(Tengen).nes",          196624, 0x59dae478, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_xybots)
STD_ROM_FN(nes_xybots)

struct BurnDriver BurnDrvnes_xybots = {
	"nes_xybots", NULL, NULL, NULL, "1990",
	"Xybots (USA) (Prototype)\0", NULL, "Tengen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_PROTOTYPE, 2, HARDWARE_NES, GBF_SHOOT | GBF_MAZE, 0,
	NESGetZipName, nes_xybotsRomInfo, nes_xybotsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Yie Ar Kung-Fu (Japan) (Rev 1.4)
static struct BurnRomInfo nes_yiearkungfuRomDesc[] = {
	{ "Yie Ar Kung-Fu (Japan) (Rev 1.4).nes",          24592, 0x0d526208, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_yiearkungfu)
STD_ROM_FN(nes_yiearkungfu)

struct BurnDriver BurnDrvnes_yiearkungfu = {
	"nes_yiearkungfu", NULL, NULL, NULL, "1985",
	"Yie Ar Kung-Fu (Japan) (Rev 1.4)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_yiearkungfuRomInfo, nes_yiearkungfuRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Yo! Noid (USA)
static struct BurnRomInfo nes_yonoidRomDesc[] = {
	{ "Yo! Noid (USA).nes",          262160, 0x3d6260d2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_yonoid)
STD_ROM_FN(nes_yonoid)

struct BurnDriver BurnDrvnes_yonoid = {
	"nes_yonoid", NULL, NULL, NULL, "1990",
	"Yo! Noid (USA)\0", NULL, "Capcom", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_yonoidRomInfo, nes_yonoidRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Yoshi (USA)
static struct BurnRomInfo nes_yoshiRomDesc[] = {
	{ "Yoshi (USA).nes",          163856, 0xf4951766, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_yoshi)
STD_ROM_FN(nes_yoshi)

struct BurnDriver BurnDrvnes_yoshi = {
	"nes_yoshi", NULL, NULL, NULL, "1992",
	"Yoshi (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_yoshiRomInfo, nes_yoshiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Yoshi's Cookie (USA)
static struct BurnRomInfo nes_yoshiscookieRomDesc[] = {
	{ "Yoshi's Cookie (USA).nes",          196624, 0x1600ac5b, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_yoshiscookie)
STD_ROM_FN(nes_yoshiscookie)

struct BurnDriver BurnDrvnes_yoshiscookie = {
	"nes_yoshiscookie", NULL, NULL, NULL, "1993",
	"Yoshi's Cookie (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_PUZZLE, 0,
	NESGetZipName, nes_yoshiscookieRomInfo, nes_yoshiscookieRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Youkai Club (Japan)
static struct BurnRomInfo nes_youkaiclubRomDesc[] = {
	{ "Youkai Club (Japan).nes",          163856, 0xd2ad7f8e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_youkaiclub)
STD_ROM_FN(nes_youkaiclub)

struct BurnDriver BurnDrvnes_youkaiclub = {
	"nes_youkaiclub", NULL, NULL, NULL, "1987",
	"Youkai Club (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_youkaiclubRomInfo, nes_youkaiclubRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Youkai Douchuuki (Japan)
static struct BurnRomInfo nes_youkaidouchuukiRomDesc[] = {
	{ "Youkai Douchuuki (Japan).nes",          262160, 0x390210b2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_youkaidouchuuki)
STD_ROM_FN(nes_youkaidouchuuki)

struct BurnDriver BurnDrvnes_youkaidouchuuki = {
	"nes_youkaidouchuuki", NULL, NULL, NULL, "1988",
	"Youkai Douchuuki (Japan)\0", NULL, "Namco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_youkaidouchuukiRomInfo, nes_youkaidouchuukiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Youkai Kurabu (Japan)
static struct BurnRomInfo nes_youkaikurabuRomDesc[] = {
	{ "Youkai Kurabu (Japan).nes",          163856, 0xd2ad7f8e, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_youkaikurabu)
STD_ROM_FN(nes_youkaikurabu)

struct BurnDriver BurnDrvnes_youkaikurabu = {
	"nes_youkaikurabu", NULL, NULL, NULL, "1987",
	"Youkai Kurabu (Japan)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM, 0,
	NESGetZipName, nes_youkaikurabuRomInfo, nes_youkaikurabuRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Young Indiana Jones Chronicles, The (USA)
static struct BurnRomInfo nes_youngindjonchrRomDesc[] = {
	{ "Young Indiana Jones Chronicles, The (USA).nes",          262160, 0x1f55fde6, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_youngindjonchr)
STD_ROM_FN(nes_youngindjonchr)

struct BurnDriver BurnDrvnes_youngindjonchr = {
	"nes_youngindjonchr", NULL, NULL, NULL, "1992",
	"Young Indiana Jones Chronicles, The (USA)\0", NULL, "Jaleco", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_SCRFIGHT | GBF_PLATFORM, 0,
	NESGetZipName, nes_youngindjonchrRomInfo, nes_youngindjonchrRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ys (Japan)
static struct BurnRomInfo nes_ysjRomDesc[] = {
	{ "Ys (Japan).nes",          262160, 0xf7fbb9cb, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ysj)
STD_ROM_FN(nes_ysj)

struct BurnDriver BurnDrvnes_ysj = {
	"nes_ysj", "nes_ys", NULL, NULL, "1988",
	"Ys (Japan)\0", NULL, "Victor", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_ysjRomInfo, nes_ysjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ys (Hack, English)
static struct BurnRomInfo nes_ysRomDesc[] = {
	{ "Ys (T-eng).nes",          262160, 0x9171e8b2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ys)
STD_ROM_FN(nes_ys)

struct BurnDriver BurnDrvnes_ys = {
	"nes_ys", NULL, NULL, NULL, "2000",
	"Ys (Hack, English)\0", NULL, "David Mullen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_ysRomInfo, nes_ysRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ys - Definitive Edition (Hack, English)
// https://www.romhacking.net/translations/7230/
static struct BurnRomInfo nes_ysdeRomDesc[] = {
	{ "Ys Definitive Edition (2024)(darthvaderx).nes",          262160, 0xb1bd75b0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ysde)
STD_ROM_FN(nes_ysde)

struct BurnDriver BurnDrvnes_ysde = {
	"nes_ysde", "nes_ys", NULL, NULL, "2024",
	"Ys - Definitive Edition (Hack, English)\0", NULL, "darthvaderx", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_ysdeRomInfo, nes_ysdeRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ys II - Ancient Ys Vanished - The Final Chapter (Japan)
static struct BurnRomInfo nes_ysiijRomDesc[] = {
	{ "Ys II - Ancient Ys Vanished - The Final Chapter (Japan).nes",          393232, 0x52e20fc4, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ysiij)
STD_ROM_FN(nes_ysiij)

struct BurnDriver BurnDrvnes_ysiij = {
	"nes_ysiij", "nes_ysii", NULL, NULL, "1990",
	"Ys II - Ancient Ys Vanished - The Final Chapter (Japan)\0", NULL, "Victor", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_ysiijRomInfo, nes_ysiijRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ys II - Ancient Ys Vanished - The Final Chapter (Hack, English)
static struct BurnRomInfo nes_ysiiRomDesc[] = {
	{ "Ys II - Ancient Ys Vanished - The Final Chapter (T-eng).nes",          393232, 0xab6b7ac1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ysii)
STD_ROM_FN(nes_ysii)

struct BurnDriver BurnDrvnes_ysii = {
	"nes_ysii", NULL, NULL, NULL, "2000",
	"Ys II - Ancient Ys Vanished - The Final Chapter (Hack, English)\0", NULL, "David Mullen", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_ysiiRomInfo, nes_ysiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ys II - Definitive Edition (Hack, English)
// https://www.romhacking.net/translations/7228/
static struct BurnRomInfo nes_ysiideRomDesc[] = {
	{ "Ys II Definitive Edition (2024)(darthvaderx).nes",          393232, 0xd8235dfa, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ysiide)
STD_ROM_FN(nes_ysiide)

struct BurnDriver BurnDrvnes_ysiide = {
	"nes_ysiide", "nes_ysii", NULL, NULL, "2024",
	"Ys II - Definitive Edition (Hack, English)\0", NULL, "darthvaderx", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_RPG, 0,
	NESGetZipName, nes_ysiideRomInfo, nes_ysiideRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ys III - Wanderers from Ys (Japan)
static struct BurnRomInfo nes_ysiiijRomDesc[] = {
	{ "Ys III - Wanderers from Ys (Japan).nes",          393232, 0xcc82eb83, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ysiiij)
STD_ROM_FN(nes_ysiiij)

struct BurnDriver BurnDrvnes_ysiiij = {
	"nes_ysiiij", "nes_ysiii", NULL, NULL, "1991",
	"Ys III - Wanderers from Ys (Japan)\0", NULL, "Victor", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM | GBF_RPG, 0,
	NESGetZipName, nes_ysiiijRomInfo, nes_ysiiijRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ys III - Wanderers from Ys (Hack, English)
static struct BurnRomInfo nes_ysiiiRomDesc[] = {
	{ "Ys III - Wanderers from Ys (T-eng).nes",          393232, 0x93328bf1, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ysiii)
STD_ROM_FN(nes_ysiii)

struct BurnDriver BurnDrvnes_ysiii = {
	"nes_ysiii", NULL, NULL, NULL, "2005",
	"Ys III - Wanderers from Ys (Hack, English)\0", NULL, "Vice Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_RPG, 0,
	NESGetZipName, nes_ysiiiRomInfo, nes_ysiiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Ys III - Definitive Edition (Hack, English)
// https://www.romhacking.net/translations/7229/
static struct BurnRomInfo nes_ysiiideRomDesc[] = {
	{ "Ys III Definitive Edition (2024)(darthvaderx).nes",          393232, 0xcbfaba05, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_ysiiide)
STD_ROM_FN(nes_ysiiide)

struct BurnDriver BurnDrvnes_ysiiide = {
	"nes_ysiiide", "nes_ysiii", NULL, NULL, "2024",
	"Ys III - Definitive Edition (Hack, English)\0", NULL, "darthvaderx", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_RPG, 0,
	NESGetZipName, nes_ysiiideRomInfo, nes_ysiiideRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Yume Penguin Monogatari (Japan)
static struct BurnRomInfo nes_yumepenmonjRomDesc[] = {
	{ "Yume Penguin Monogatari (Japan).nes",          262160, 0x16f3a6aa, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_yumepenmonj)
STD_ROM_FN(nes_yumepenmonj)

struct BurnDriver BurnDrvnes_yumepenmonj = {
	"nes_yumepenmonj", "nes_yumepenmon", NULL, NULL, "1991",
	"Yume Penguin Monogatari (Japan)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_PLATFORM | GBF_HORSHOOT, 0,
	NESGetZipName, nes_yumepenmonjRomInfo, nes_yumepenmonjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Yume Penguin Monogatari (Hack, English)
static struct BurnRomInfo nes_yumepenmonRomDesc[] = {
	{ "Yume Penguin Monogatari (T-eng).nes",          262160, 0xdf92c173, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_yumepenmon)
STD_ROM_FN(nes_yumepenmon)

struct BurnDriver BurnDrvnes_yumepenmon = {
	"nes_yumepenmon", NULL, NULL, NULL, "2006",
	"Yume Penguin Monogatari (Hack, English)\0", NULL, "Vice Translations", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_PLATFORM | GBF_HORSHOOT, 0,
	NESGetZipName, nes_yumepenmonRomInfo, nes_yumepenmonRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Yuu Yuu Hakusho Final - Makai Saikyou Retsuden (Japan)
static struct BurnRomInfo nes_yuuyuuhakfinRomDesc[] = {
	{ "Yuu Yuu Hakusho Final - Makai Saikyou Retsuden (Japan).nes",          393232, 0x93b37bb3, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_yuuyuuhakfin)
STD_ROM_FN(nes_yuuyuuhakfin)

struct BurnDriver BurnDrvnes_yuuyuuhakfin = {
	"nes_yuuyuuhakfin", NULL, NULL, NULL, "1996",
	"Yuu Yuu Hakusho Final - Makai Saikyou Retsuden (Japan)\0", NULL, "N.T", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_yuuyuuhakfinRomInfo, nes_yuuyuuhakfinRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Zanac (USA)
static struct BurnRomInfo nes_zanacRomDesc[] = {
	{ "Zanac (USA).nes",          131088, 0x2165c0c2, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_zanac)
STD_ROM_FN(nes_zanac)

struct BurnDriver BurnDrvnes_zanac = {
	"nes_zanac", NULL, NULL, NULL, "1987",
	"Zanac (USA)\0", NULL, "FCI", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_zanacRomInfo, nes_zanacRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Zelda II - The Adventure of Link (USA)
static struct BurnRomInfo nes_zeldaiiRomDesc[] = {
	{ "Zelda II - The Adventure of Link (USA).nes",          262160, 0xe3c788b0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_zeldaii)
STD_ROM_FN(nes_zeldaii)

struct BurnDriver BurnDrvnes_zeldaii = {
	"nes_zeldaii", NULL, NULL, NULL, "1988",
	"Zelda II - The Adventure of Link (USA)\0", NULL, "Nintendo", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM | GBF_ADV, 0,
	NESGetZipName, nes_zeldaiiRomInfo, nes_zeldaiiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Zen - Intergalactic Ninja (USA)
static struct BurnRomInfo nes_zenRomDesc[] = {
	{ "Zen - Intergalactic Ninja (USA).nes",          262160, 0xf2c4836f, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_zen)
STD_ROM_FN(nes_zen)

struct BurnDriver BurnDrvnes_zen = {
	"nes_zen", NULL, NULL, NULL, "1993",
	"Zen - Intergalactic Ninja (USA)\0", NULL, "Konami", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_RUNGUN, 0,
	NESGetZipName, nes_zenRomInfo, nes_zenRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Zhen Ben Xi You Ji (Asia) (Unl)
static struct BurnRomInfo nes_zhenbenxiyoujiRomDesc[] = {
	{ "Zhen Ben Xi You Ji (Asia) (Unl).nes",          393232, 0x301ce43a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_zhenbenxiyouji)
STD_ROM_FN(nes_zhenbenxiyouji)

struct BurnDriver BurnDrvnes_zhenbenxiyouji = {
	"nes_zhenbenxiyouji", NULL, NULL, NULL, "1994",
	"Zhen Ben Xi You Ji (Asia) (Unl)\0", NULL, "Asder Soft", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VSFIGHT, 0,
	NESGetZipName, nes_zhenbenxiyoujiRomInfo, nes_zhenbenxiyoujiRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Zippy Race (Japan)
static struct BurnRomInfo nes_zippyraceRomDesc[] = {
	{ "Zippy Race (Japan).nes",          24592, 0x6f0e4a40, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_zippyrace)
STD_ROM_FN(nes_zippyrace)

struct BurnDriver BurnDrvnes_zippyrace = {
	"nes_zippyrace", NULL, NULL, NULL, "1985",
	"Zippy Race (Japan)\0", NULL, "Irem", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_RACING, 0,
	NESGetZipName, nes_zippyraceRomInfo, nes_zippyraceRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Zoids - Chuuou Tairiku no Tatakai (Japan)
static struct BurnRomInfo nes_zoidsjRomDesc[] = {
	{ "Zoids - Chuuou Tairiku no Tatakai (J)(1987)(Toshiba-EMI).nes",          131088, 0xe3d6a15a, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_zoidsj)
STD_ROM_FN(nes_zoidsj)

struct BurnDriver BurnDrvnes_zoidsj = {
	"nes_zoidsj", "nes_zoids", NULL, NULL, "1987",
	"Zoids - Chuuou Tairiku no Tatakai (Japan)\0", NULL, "Toshiba-EMI", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_CLONE, 1, HARDWARE_NES, GBF_ACTION | GBF_RPG, 0,
	NESGetZipName, nes_zoidsjRomInfo, nes_zoidsjRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Zoids - Battle of Central Continent (Hack, English)
// https://www.romhacking.net/translations/6845/
static struct BurnRomInfo nes_zoidsRomDesc[] = {
	{ "Zoids - Chuuou Tairiku no Tatakai T-Eng (2023)(Life With Matthew).nes",          131088, 0x1528e6c0, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_zoids)
STD_ROM_FN(nes_zoids)

struct BurnDriver BurnDrvnes_zoids = {
	"nes_zoids", NULL, NULL, NULL, "2023",
	"Zoids - Battle of Central Continent (Hack, English)\0", NULL, "Life With Matthew", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING | BDF_HACK, 1, HARDWARE_NES, GBF_ACTION | GBF_RPG, 0,
	NESGetZipName, nes_zoidsRomInfo, nes_zoidsRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Zombie Hunter (Japan)
static struct BurnRomInfo nes_zombiehunterRomDesc[] = {
	{ "Zombie Hunter (Japan).nes",          163856, 0xcc5a32d5, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_zombiehunter)
STD_ROM_FN(nes_zombiehunter)

struct BurnDriver BurnDrvnes_zombiehunter = {
	"nes_zombiehunter", NULL, NULL, NULL, "1987",
	"Zombie Hunter (Japan)\0", NULL, "Hi-Score Software", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_PLATFORM | GBF_RPG, 0,
	NESGetZipName, nes_zombiehunterRomInfo, nes_zombiehunterRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Zombie Nation (USA)
static struct BurnRomInfo nes_zombienationRomDesc[] = {
	{ "Zombie Nation (USA).nes",          262160, 0x29685f24, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_zombienation)
STD_ROM_FN(nes_zombienation)

struct BurnDriver BurnDrvnes_zombienation = {
	"nes_zombienation", NULL, NULL, NULL, "1991",
	"Zombie Nation (USA)\0", NULL, "Meldac", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 1, HARDWARE_NES, GBF_HORSHOOT, 0,
	NESGetZipName, nes_zombienationRomInfo, nes_zombienationRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

// Zunou Senkan Galg (Japan)
static struct BurnRomInfo nes_zunousengalRomDesc[] = {
	{ "Zunou Senkan Galg (Japan).nes",          40976, 0x12d83258, BRF_ESS | BRF_PRG },
};

STD_ROM_PICK(nes_zunousengal)
STD_ROM_FN(nes_zunousengal)

struct BurnDriver BurnDrvnes_zunousengal = {
	"nes_zunousengal", NULL, NULL, NULL, "1985",
	"Zunou Senkan Galg (Japan)\0", NULL, "dB-SOFT", "Miscellaneous",
	NULL, NULL, NULL, NULL,
	BDF_GAME_WORKING, 2, HARDWARE_NES, GBF_VERSHOOT, 0,
	NESGetZipName, nes_zunousengalRomInfo, nes_zunousengalRomName, NULL, NULL, NULL, NULL, NESInputInfo, NESDIPInfo,
	NESInit, NESExit, NESFrame, NESDraw, NESScan, &NESRecalc, 0x40,
	SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH, SCREEN_HEIGHT
};

