@Override
	public boolean setStarters(List<Pokemon> newStarters) {
		// Amount?
		int starterAmount = 2;
		if (!romEntry.isYellow) {
			starterAmount = 3;
		}

		// Basic checks
		if (newStarters.size() != starterAmount) {
			return false;
		}

		for (Pokemon pkmn : newStarters) {
			if (!isInGame(pkmn)) {
				return false;
			}
		}

		// Patch starter bytes
		for (int i = 0; i < starterAmount; i++) {
			byte starter = (byte) pokeNumToRBYTable[newStarters.get(i).number];
			int[] offsets = romEntry.arrayEntries.get("StarterOffsets"
					+ (i + 1));
			for (int offset : offsets) {
				rom[offset] = starter;
			}
		}

		// Special stuff for non-Yellow only

		if (!romEntry.isYellow) {

			// Starter text
			if (romEntry.getValue("CanChangeStarterText") > 0) {
				List<Integer> starterTextOffsets = RomFunctions.search(rom,
						traduire("So! You want the"));
				for (int i = 0; i < 3 && i < starterTextOffsets.size(); i++) {
					writeFixedLengthScriptString("So! You want\\n"
							+ newStarters.get(i).name + "?\\e",
							starterTextOffsets.get(i),
							lengthOfStringAt(starterTextOffsets.get(i)) + 1);
				}
			}

			// Patch starter pokedex routine?
			// Can only do in 1M roms because of size concerns
			if (romEntry.getValue("PatchPokedex") > 0) {

				// Starter pokedex required RAM values
				// RAM offset => value
				// Allows for multiple starters in the same RAM byte
				Map<Integer, Integer> onValues = new TreeMap<Integer, Integer>();
				for (int i = 0; i < 3; i++) {
					int pkDexNum = newStarters.get(i).number;
					int ramOffset = (pkDexNum - 1) / 8
							+ romEntry.getValue("PokedexRamOffset");
					int bitShift = (pkDexNum - 1) % 8;
					int writeValue = 1 << bitShift;
					if (onValues.containsKey(ramOffset)) {
						onValues.put(ramOffset, onValues.get(ramOffset)
								| writeValue);
					} else {
						onValues.put(ramOffset, writeValue);
					}
				}

				// Starter pokedex offset/pointer calculations

				int pkDexOnOffset = romEntry.getValue("StarterPokedexOnOffset");
				int pkDexOffOffset = romEntry
						.getValue("StarterPokedexOffOffset");

				int sizeForOnRoutine = 5 * onValues.size() + 3;
				int writeOnRoutineTo = romEntry
						.getValue("StarterPokedexBranchOffset");
				int writeOffRoutineTo = writeOnRoutineTo + sizeForOnRoutine;
				int offsetForOnRoutine = makeGBPointer(writeOnRoutineTo);
				int offsetForOffRoutine = makeGBPointer(writeOffRoutineTo);
				int retOnOffset = makeGBPointer(pkDexOnOffset + 5);
				int retOffOffset = makeGBPointer(pkDexOffOffset + 4);

				// Starter pokedex
				// Branch to our new routine(s)

				// Turn bytes on
				rom[pkDexOnOffset] = (byte) 0xC3;
				writeWord(pkDexOnOffset + 1, offsetForOnRoutine);
				rom[pkDexOnOffset + 3] = 0x00;
				rom[pkDexOnOffset + 4] = 0x00;

				// Turn bytes off
				rom[pkDexOffOffset] = (byte) 0xC3;
				writeWord(pkDexOffOffset + 1, offsetForOffRoutine);
				rom[pkDexOffOffset + 3] = 0x00;

				// Put together the two scripts
				rom[writeOffRoutineTo] = (byte) 0xAF;
				int turnOnOffset = writeOnRoutineTo;
				int turnOffOffset = writeOffRoutineTo + 1;
				for (int ramOffset : onValues.keySet()) {
					int onValue = onValues.get(ramOffset);
					// Turn on code
					rom[turnOnOffset++] = 0x3E;
					rom[turnOnOffset++] = (byte) onValue;
					// Turn on code for ram writing
					rom[turnOnOffset++] = (byte) 0xEA;
					rom[turnOnOffset++] = (byte) (ramOffset % 0x100);
					rom[turnOnOffset++] = (byte) (ramOffset / 0x100);
					// Turn off code for ram writing
					rom[turnOffOffset++] = (byte) 0xEA;
					rom[turnOffOffset++] = (byte) (ramOffset % 0x100);
					rom[turnOffOffset++] = (byte) (ramOffset / 0x100);
				}
				// Jump back
				rom[turnOnOffset++] = (byte) 0xC3;
				writeWord(turnOnOffset, retOnOffset);

				rom[turnOffOffset++] = (byte) 0xC3;
				writeWord(turnOffOffset, retOffOffset);
			}

		}

		return true;

	}