[pcsx_rearmed.git] / libpcsxcore / database.c

#include "misc.h"
#include "sio.h"
#include "ppf.h"
#include "new_dynarec/new_dynarec.h"
#include "lightrec/plugin.h"

/* It's duplicated from emu_if.c */
#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))

/* Corresponds to LIGHTREC_OPT_INV_DMA_ONLY of lightrec.h */
#define LIGHTREC_HACK_INV_DMA_ONLY (1 << 0)

u32 lightrec_hacks;

static const char * const MemorycardHack_db[] =
{
	/* Lifeforce Tenka, also known as Codename Tenka */
	"SLES00613", "SLED00690", "SLES00614", "SLES00615",
	"SLES00616", "SLES00617", "SCUS94409"
};

static const char * const cdr_read_hack_db[] =
{
	/* T'ai Fu - Wrath of the Tiger */
	"SLUS00787",
};

static const char * const gpu_slow_llist_db[] =
{
	/* Bomberman Fantasy Race */
	"SLES01712", "SLPS01525", "SLPS91138", "SLPM87102", "SLUS00823",
	/* Crash Bash */
	"SCES02834", "SCUS94570", "SCUS94616", "SCUS94654",
	/* Final Fantasy IV */
	"SCES03840", "SLPM86028", "SLUS01360",
	/* Spot Goes to Hollywood */
	"SLES00330", "SLPS00394", "SLUS00014",
	/* Vampire Hunter D */
	"SLES02731", "SLPS02477", "SLPS03198", "SLUS01138",
};

static const char * const gpu_busy_hack_db[] =
{
	/* ToHeart (Japan) */
	"SLPS01919", "SLPS01920",
};

static const char * const gpu_centering_hack_db[] =
{
	/* Gradius Gaiden */
	"SLPM86042", "SLPM86103", "SLPM87323",
	/* Sexy Parodius */
	"SLPM86009",
};

#define HACK_ENTRY(var, list) \
	{ #var, &Config.hacks.var, list, ARRAY_SIZE(list) }

static const struct
{
	const char *name;
	boolean *var;
	const char * const * id_list;
	size_t id_list_len;
}
hack_db[] =
{
	HACK_ENTRY(cdr_read_timing, cdr_read_hack_db),
	HACK_ENTRY(gpu_slow_list_walking, gpu_slow_llist_db),
	HACK_ENTRY(gpu_busy, gpu_busy_hack_db),
	HACK_ENTRY(gpu_centering, gpu_centering_hack_db),
};

static const struct
{
	int mult;
	const char * const id[4];
}
cycle_multiplier_overrides[] =
{
	/* note: values are = (10000 / gui_option) */
	/* Internal Section - fussy about timings */
	{ 202, { "SLPS01868" } },
	/* Super Robot Taisen Alpha - on the edge with 175,
	 * changing memcard settings is enough to break/unbreak it */
	{ 190, { "SLPS02528", "SLPS02636" } },
	/* Brave Fencer Musashi - cd sectors arrive too fast */
	{ 170, { "SLUS00726", "SLPS01490" } },
#if defined(DRC_DISABLE) || defined(LIGHTREC) /* new_dynarec has a hack for this game */
	/* Parasite Eve II - internal timer checks */
	{ 125, { "SLUS01042", "SLUS01055", "SLES02558", "SLES12558" } },
#endif
	/* Discworld Noir - audio skips if CPU runs too fast */
	{ 222, { "SLES01549", "SLES02063", "SLES02064" } },
	/* Judge Dredd - could also be poor MDEC timing */
	{ 128, { "SLUS00630", "SLES00755" } },
	/* Digimon World */
	{ 153, { "SLUS01032", "SLES02914" } },
	/* Syphon Filter - reportedly hangs under unknown conditions */
	{ 169, { "SCUS94240" } },
	/* Psychic Detective - some weird race condition in the game's cdrom code */
	{ 222, { "SLUS00165", "SLUS00166", "SLUS00167" } },
	{ 222, { "SLES00070", "SLES10070", "SLES20070" } },
};

static const struct
{
	const char * const id;
	u32 hacks;
}
lightrec_hacks_db[] =
{
	/* Formula One Arcade */
	{ "SCES03886", LIGHTREC_HACK_INV_DMA_ONLY },

	/* Formula One '99 */
	{ "SLUS00870", LIGHTREC_HACK_INV_DMA_ONLY },
	{ "SCPS10101", LIGHTREC_HACK_INV_DMA_ONLY },
	{ "SCES01979", LIGHTREC_HACK_INV_DMA_ONLY },
	{ "SLES01979", LIGHTREC_HACK_INV_DMA_ONLY },

	/* Formula One 2000 */
	{ "SLUS01134", LIGHTREC_HACK_INV_DMA_ONLY },
	{ "SCES02777", LIGHTREC_HACK_INV_DMA_ONLY },
	{ "SCES02778", LIGHTREC_HACK_INV_DMA_ONLY },
	{ "SCES02779", LIGHTREC_HACK_INV_DMA_ONLY },

	/* Formula One 2001 */
	{ "SCES03404", LIGHTREC_HACK_INV_DMA_ONLY },
	{ "SCES03423", LIGHTREC_HACK_INV_DMA_ONLY },
	{ "SCES03424", LIGHTREC_HACK_INV_DMA_ONLY },
	{ "SCES03524", LIGHTREC_HACK_INV_DMA_ONLY },
};

/* Function for automatic patching according to GameID. */
void Apply_Hacks_Cdrom(void)
{
	size_t i, j;

	memset(&Config.hacks, 0, sizeof(Config.hacks));

	for (i = 0; i < ARRAY_SIZE(hack_db); i++)
	{
		for (j = 0; j < hack_db[i].id_list_len; j++)
		{
			if (strncmp(CdromId, hack_db[i].id_list[j], 9))
				continue;
			*hack_db[i].var = 1;
			SysPrintf("using hack: %s\n", hack_db[i].name);
			break;
		}
	}

	/* Apply Memory card hack for Codename Tenka. (The game needs one of the memory card slots to be empty) */
	for (i = 0; i < ARRAY_SIZE(MemorycardHack_db); i++)
	{
		if (strncmp(CdromId, MemorycardHack_db[i], 9) == 0)
		{
			/* Disable the second memory card slot for the game */
			Config.Mcd2[0] = 0;
			/* This also needs to be done because in sio.c, they don't use Config.Mcd2 for that purpose */
			McdDisable[1] = 1;
			break;
		}
	}

	/* Dynarec game-specific hacks */
	new_dynarec_hacks_pergame = 0;
	Config.cycle_multiplier_override = 0;

	for (i = 0; i < ARRAY_SIZE(cycle_multiplier_overrides); i++)
	{
		const char * const * const ids = cycle_multiplier_overrides[i].id;
		for (j = 0; j < ARRAY_SIZE(cycle_multiplier_overrides[i].id); j++)
			if (ids[j] && strcmp(ids[j], CdromId) == 0)
				break;
		if (j < ARRAY_SIZE(cycle_multiplier_overrides[i].id))
		{
			Config.cycle_multiplier_override = cycle_multiplier_overrides[i].mult;
			new_dynarec_hacks_pergame |= NDHACK_OVERRIDE_CYCLE_M;
			SysPrintf("using cycle_multiplier_override: %d\n",
				Config.cycle_multiplier_override);
			break;
		}
	}

	lightrec_hacks = 0;

	for (i = 0; drc_is_lightrec() && i < ARRAY_SIZE(lightrec_hacks_db); i++) {
		if (strcmp(CdromId, lightrec_hacks_db[i].id) == 0)
		{
			lightrec_hacks = lightrec_hacks_db[i].hacks;
			SysPrintf("using lightrec_hacks: 0x%x\n", lightrec_hacks);
			break;
		}
	}
}

// from duckstation's gamedb.json
static const u16 libcrypt_ids[] = {
	   17,   311,   995,  1041,  1226,  1241,  1301,  1362,  1431,  1444,
	 1492,  1493,  1494,  1495,  1516,  1517,  1518,  1519,  1545,  1564,
	 1695,  1700,  1701,  1702,  1703,  1704,  1715,  1733,  1763,  1882,
	 1906,  1907,  1909,  1943,  1979,  2004,  2005,  2006,  2007,  2024,
	 2025,  2026,  2027,  2028,  2029,  2030,  2031,  2061,  2071,  2080,
	 2081,  2082,  2083,  2084,  2086,  2104,  2105,  2112,  2113,  2118,
	 2181,  2182,  2184,  2185,  2207,  2208,  2209,  2210,  2211,  2222,
	 2264,  2290,  2292,  2293,  2328,  2329,  2330,  2354,  2355,  2365,
	 2366,  2367,  2368,  2369,  2395,  2396,  2402,  2430,  2431,  2432,
	 2433,  2487,  2488,  2489,  2490,  2491,  2529,  2530,  2531,  2532,
	 2533,  2538,  2544,  2545,  2546,  2558,  2559,  2560,  2561,  2562,
	 2563,  2572,  2573,  2681,  2688,  2689,  2698,  2700,  2704,  2705,
	 2706,  2707,  2708,  2722,  2723,  2724,  2733,  2754,  2755,  2756,
	 2763,  2766,  2767,  2768,  2769,  2824,  2830,  2831,  2834,  2835,
	 2839,  2857,  2858,  2859,  2860,  2861,  2862,  2965,  2966,  2967,
	 2968,  2969,  2975,  2976,  2977,  2978,  2979,  3061,  3062,  3189,
	 3190,  3191,  3241,  3242,  3243,  3244,  3245,  3324,  3489,  3519,
	 3520,  3521,  3522,  3523,  3530,  3603,  3604,  3605,  3606,  3607,
	 3626,  3648, 12080, 12081, 12082, 12083, 12084, 12328, 12329, 12330,
	12558, 12559, 12560, 12561, 12562, 12965, 12966, 12967, 12968, 12969,
	22080, 22081, 22082, 22083, 22084, 22328, 22329, 22330, 22965, 22966,
	22967, 22968, 22969, 32080, 32081, 32082, 32083, 32084, 32965, 32966,
	32967, 32968, 32969
};

// as documented by nocash
static const u16 libcrypt_sectors[16] = {
	14105, 14231, 14485, 14579, 14649, 14899, 15056, 15130,
	15242, 15312, 15378, 15628, 15919, 16031, 16101, 16167
};

int check_unsatisfied_libcrypt(void)
{
	const char *p = CdromId + 4;
	u16 id, key = 0;
	size_t i;

	if (strncmp(CdromId, "SCE", 3) && strncmp(CdromId, "SLE", 3))
		return 0;
	while (*p == '0')
		p++;
	id = (u16)atoi(p);
	for (i = 0; i < ARRAY_SIZE(libcrypt_ids); i++)
		if (id == libcrypt_ids[i])
			break;
	if (i == ARRAY_SIZE(libcrypt_ids))
		return 0;

	// detected a protected game
	if (!CDR_getBufferSub(libcrypt_sectors[0]) && !sbi_sectors) {
		SysPrintf("==================================================\n");
		SysPrintf("LibCrypt game detected with missing SBI/subchannel\n");
		SysPrintf("==================================================\n");
		return 1;
	}

	if (sbi_sectors) {
		// calculate key just for fun (we don't really need it)
		for (i = 0; i < 16; i++)
			if (CheckSBI(libcrypt_sectors[i] - 2*75))
				key |= 1u << (15 - i);
	}
	if (key)
		SysPrintf("%s, possible key=%04X\n", "LibCrypt detected", key);
	else
		SysPrintf("%s\n", "LibCrypt detected");
	return 0;
}
Commit	Line	Data
630b122b	1	#include "misc.h"
630b122b	2	#include "sio.h"
cdee2d81	3	#include "ppf.h"
630b122b	4	#include "new_dynarec/new_dynarec.h"
8bccdd17	5	#include "lightrec/plugin.h"
630b122b	6
	7	/* It's duplicated from emu_if.c */
	8	#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
	9
8bccdd17 PC	10	/* Corresponds to LIGHTREC_OPT_INV_DMA_ONLY of lightrec.h */
	11	#define LIGHTREC_HACK_INV_DMA_ONLY (1 << 0)
	12
	13	u32 lightrec_hacks;
	14
d0d2939d	15	static const char * const MemorycardHack_db[] =
630b122b	16	{
630b122b	17	/* Lifeforce Tenka, also known as Codename Tenka */
d0d2939d	18	"SLES00613", "SLED00690", "SLES00614", "SLES00615",
	19	"SLES00616", "SLES00617", "SCUS94409"
	20	};
	21
	22	static const char * const cdr_read_hack_db[] =
	23	{
	24	/* T'ai Fu - Wrath of the Tiger */
	25	"SLUS00787",
	26	};
	27
fae38d7a	28	static const char * const gpu_slow_llist_db[] =
fae38d7a	29	{
fe564285 WVP	30	/* Bomberman Fantasy Race */
fe564285 WVP	31	"SLES01712", "SLPS01525", "SLPS91138", "SLPM87102", "SLUS00823",
fae38d7a	32	/* Crash Bash */
	33	"SCES02834", "SCUS94570", "SCUS94616", "SCUS94654",
	34	/* Final Fantasy IV */
	35	"SCES03840", "SLPM86028", "SLUS01360",
	36	/* Spot Goes to Hollywood */
	37	"SLES00330", "SLPS00394", "SLUS00014",
	38	/* Vampire Hunter D */
	39	"SLES02731", "SLPS02477", "SLPS03198", "SLUS01138",
	40	};
	41
55ff7130	42	static const char * const gpu_busy_hack_db[] =
	43	{
	44	/* ToHeart (Japan) */
	45	"SLPS01919", "SLPS01920",
	46	};
	47
b3ff74ba	48	static const char * const gpu_centering_hack_db[] =
	49	{
	50	/* Gradius Gaiden */
	51	"SLPM86042", "SLPM86103", "SLPM87323",
	52	/* Sexy Parodius */
	53	"SLPM86009",
	54	};
	55
d0d2939d	56	#define HACK_ENTRY(var, list) \
	57	{ #var, &Config.hacks.var, list, ARRAY_SIZE(list) }
	58
	59	static const struct
	60	{
	61	const char *name;
	62	boolean *var;
	63	const char * const * id_list;
	64	size_t id_list_len;
	65	}
	66	hack_db[] =
	67	{
	68	HACK_ENTRY(cdr_read_timing, cdr_read_hack_db),
fae38d7a	69	HACK_ENTRY(gpu_slow_list_walking, gpu_slow_llist_db),
b3ff74ba	70	HACK_ENTRY(gpu_busy, gpu_busy_hack_db),
b3ff74ba	71	HACK_ENTRY(gpu_centering, gpu_centering_hack_db),
630b122b	72	};
630b122b	73
d7907215	74	static const struct
d7907215	75	{
d7907215	76	int mult;
353119c2	77	const char * const id[4];
d7907215	78	}
1562ed57	79	cycle_multiplier_overrides[] =
d7907215	80	{
9170c48e	81	/* note: values are = (10000 / gui_option) */
d7907215	82	/* Internal Section - fussy about timings */
353119c2	83	{ 202, { "SLPS01868" } },
d7907215	84	/* Super Robot Taisen Alpha - on the edge with 175,
d7907215	85	* changing memcard settings is enough to break/unbreak it */
353119c2	86	{ 190, { "SLPS02528", "SLPS02636" } },
b8f3d43d	87	/* Brave Fencer Musashi - cd sectors arrive too fast */
353119c2	88	{ 170, { "SLUS00726", "SLPS01490" } },
86be2515	89	#if defined(DRC_DISABLE) \|\| defined(LIGHTREC) /* new_dynarec has a hack for this game */
1562ed57	90	/* Parasite Eve II - internal timer checks */
353119c2	91	{ 125, { "SLUS01042", "SLUS01055", "SLES02558", "SLES12558" } },
1562ed57	92	#endif
b99a48f2	93	/* Discworld Noir - audio skips if CPU runs too fast */
353119c2	94	{ 222, { "SLES01549", "SLES02063", "SLES02064" } },
9170c48e	95	/* Judge Dredd - could also be poor MDEC timing */
353119c2	96	{ 128, { "SLUS00630", "SLES00755" } },
9170c48e	97	/* Digimon World */
353119c2	98	{ 153, { "SLUS01032", "SLES02914" } },
8f3fa1e8	99	/* Syphon Filter - reportedly hangs under unknown conditions */
353119c2	100	{ 169, { "SCUS94240" } },
9159f799	101	/* Psychic Detective - some weird race condition in the game's cdrom code */
	102	{ 222, { "SLUS00165", "SLUS00166", "SLUS00167" } },
	103	{ 222, { "SLES00070", "SLES10070", "SLES20070" } },
d7907215	104	};
d7907215	105
8bccdd17 PC	106	static const struct
	107	{
	108	const char * const id;
	109	u32 hacks;
	110	}
	111	lightrec_hacks_db[] =
	112	{
	113	/* Formula One Arcade */
	114	{ "SCES03886", LIGHTREC_HACK_INV_DMA_ONLY },
	115
	116	/* Formula One '99 */
	117	{ "SLUS00870", LIGHTREC_HACK_INV_DMA_ONLY },
	118	{ "SCPS10101", LIGHTREC_HACK_INV_DMA_ONLY },
	119	{ "SCES01979", LIGHTREC_HACK_INV_DMA_ONLY },
	120	{ "SLES01979", LIGHTREC_HACK_INV_DMA_ONLY },
	121
	122	/* Formula One 2000 */
	123	{ "SLUS01134", LIGHTREC_HACK_INV_DMA_ONLY },
	124	{ "SCES02777", LIGHTREC_HACK_INV_DMA_ONLY },
	125	{ "SCES02778", LIGHTREC_HACK_INV_DMA_ONLY },
	126	{ "SCES02779", LIGHTREC_HACK_INV_DMA_ONLY },
	127
	128	/* Formula One 2001 */
	129	{ "SCES03404", LIGHTREC_HACK_INV_DMA_ONLY },
	130	{ "SCES03423", LIGHTREC_HACK_INV_DMA_ONLY },
	131	{ "SCES03424", LIGHTREC_HACK_INV_DMA_ONLY },
	132	{ "SCES03524", LIGHTREC_HACK_INV_DMA_ONLY },
	133	};
	134
630b122b	135	/* Function for automatic patching according to GameID. */
cdee2d81	136	void Apply_Hacks_Cdrom(void)
630b122b	137	{
d0d2939d	138	size_t i, j;
	139
	140	memset(&Config.hacks, 0, sizeof(Config.hacks));
	141
	142	for (i = 0; i < ARRAY_SIZE(hack_db); i++)
	143	{
	144	for (j = 0; j < hack_db[i].id_list_len; j++)
	145	{
	146	if (strncmp(CdromId, hack_db[i].id_list[j], 9))
	147	continue;
	148	*hack_db[i].var = 1;
	149	SysPrintf("using hack: %s\n", hack_db[i].name);
	150	break;
	151	}
	152	}
	153
630b122b	154	/* Apply Memory card hack for Codename Tenka. (The game needs one of the memory card slots to be empty) */
d0d2939d	155	for (i = 0; i < ARRAY_SIZE(MemorycardHack_db); i++)
630b122b	156	{
	157	if (strncmp(CdromId, MemorycardHack_db[i], 9) == 0)
	158	{
	159	/* Disable the second memory card slot for the game */
	160	Config.Mcd2[0] = 0;
	161	/* This also needs to be done because in sio.c, they don't use Config.Mcd2 for that purpose */
	162	McdDisable[1] = 1;
d0d2939d	163	break;
630b122b	164	}
	165	}
	166
	167	/* Dynarec game-specific hacks */
	168	new_dynarec_hacks_pergame = 0;
1562ed57	169	Config.cycle_multiplier_override = 0;
630b122b	170
1562ed57	171	for (i = 0; i < ARRAY_SIZE(cycle_multiplier_overrides); i++)
630b122b	172	{
353119c2	173	const char * const * const ids = cycle_multiplier_overrides[i].id;
	174	for (j = 0; j < ARRAY_SIZE(cycle_multiplier_overrides[i].id); j++)
	175	if (ids[j] && strcmp(ids[j], CdromId) == 0)
	176	break;
	177	if (j < ARRAY_SIZE(cycle_multiplier_overrides[i].id))
d7907215	178	{
1562ed57	179	Config.cycle_multiplier_override = cycle_multiplier_overrides[i].mult;
d7907215	180	new_dynarec_hacks_pergame \|= NDHACK_OVERRIDE_CYCLE_M;
1562ed57	181	SysPrintf("using cycle_multiplier_override: %d\n",
1562ed57	182	Config.cycle_multiplier_override);
d7907215	183	break;
d7907215	184	}
630b122b	185	}
8bccdd17 PC	186
	187	lightrec_hacks = 0;
	188
	189	for (i = 0; drc_is_lightrec() && i < ARRAY_SIZE(lightrec_hacks_db); i++) {
	190	if (strcmp(CdromId, lightrec_hacks_db[i].id) == 0)
	191	{
	192	lightrec_hacks = lightrec_hacks_db[i].hacks;
	193	SysPrintf("using lightrec_hacks: 0x%x\n", lightrec_hacks);
	194	break;
	195	}
	196	}
630b122b	197	}
cdee2d81	198
	199	// from duckstation's gamedb.json
	200	static const u16 libcrypt_ids[] = {
	201	17, 311, 995, 1041, 1226, 1241, 1301, 1362, 1431, 1444,
	202	1492, 1493, 1494, 1495, 1516, 1517, 1518, 1519, 1545, 1564,
	203	1695, 1700, 1701, 1702, 1703, 1704, 1715, 1733, 1763, 1882,
	204	1906, 1907, 1909, 1943, 1979, 2004, 2005, 2006, 2007, 2024,
	205	2025, 2026, 2027, 2028, 2029, 2030, 2031, 2061, 2071, 2080,
	206	2081, 2082, 2083, 2084, 2086, 2104, 2105, 2112, 2113, 2118,
	207	2181, 2182, 2184, 2185, 2207, 2208, 2209, 2210, 2211, 2222,
	208	2264, 2290, 2292, 2293, 2328, 2329, 2330, 2354, 2355, 2365,
	209	2366, 2367, 2368, 2369, 2395, 2396, 2402, 2430, 2431, 2432,
	210	2433, 2487, 2488, 2489, 2490, 2491, 2529, 2530, 2531, 2532,
	211	2533, 2538, 2544, 2545, 2546, 2558, 2559, 2560, 2561, 2562,
	212	2563, 2572, 2573, 2681, 2688, 2689, 2698, 2700, 2704, 2705,
	213	2706, 2707, 2708, 2722, 2723, 2724, 2733, 2754, 2755, 2756,
	214	2763, 2766, 2767, 2768, 2769, 2824, 2830, 2831, 2834, 2835,
	215	2839, 2857, 2858, 2859, 2860, 2861, 2862, 2965, 2966, 2967,
	216	2968, 2969, 2975, 2976, 2977, 2978, 2979, 3061, 3062, 3189,
	217	3190, 3191, 3241, 3242, 3243, 3244, 3245, 3324, 3489, 3519,
	218	3520, 3521, 3522, 3523, 3530, 3603, 3604, 3605, 3606, 3607,
	219	3626, 3648, 12080, 12081, 12082, 12083, 12084, 12328, 12329, 12330,
	220	12558, 12559, 12560, 12561, 12562, 12965, 12966, 12967, 12968, 12969,
	221	22080, 22081, 22082, 22083, 22084, 22328, 22329, 22330, 22965, 22966,
	222	22967, 22968, 22969, 32080, 32081, 32082, 32083, 32084, 32965, 32966,
	223	32967, 32968, 32969
	224	};
	225
	226	// as documented by nocash
	227	static const u16 libcrypt_sectors[16] = {
	228	14105, 14231, 14485, 14579, 14649, 14899, 15056, 15130,
	229	15242, 15312, 15378, 15628, 15919, 16031, 16101, 16167
	230	};
	231
	232	int check_unsatisfied_libcrypt(void)
	233	{
	234	const char *p = CdromId + 4;
	235	u16 id, key = 0;
	236	size_t i;
	237
	238	if (strncmp(CdromId, "SCE", 3) && strncmp(CdromId, "SLE", 3))
	239	return 0;
	240	while (*p == '0')
	241	p++;
	242	id = (u16)atoi(p);
	243	for (i = 0; i < ARRAY_SIZE(libcrypt_ids); i++)
	244	if (id == libcrypt_ids[i])
	245	break;
	246	if (i == ARRAY_SIZE(libcrypt_ids))
	247	return 0;
	248
	249	// detected a protected game
	250	if (!CDR_getBufferSub(libcrypt_sectors[0]) && !sbi_sectors) {
	251	SysPrintf("==================================================\n");
	252	SysPrintf("LibCrypt game detected with missing SBI/subchannel\n");
	253	SysPrintf("==================================================\n");
	254	return 1;
	255	}
	256
	257	if (sbi_sectors) {
	258	// calculate key just for fun (we don't really need it)
	259	for (i = 0; i < 16; i++)
	260	if (CheckSBI(libcrypt_sectors[i] - 2*75))
	261	key \|= 1u << (15 - i);
262	}
263	if (key)
264	SysPrintf("%s, possible key=%04X\n", "LibCrypt detected", key);
265	else
266	SysPrintf("%s\n", "LibCrypt detected");
267	return 0;
268	}