├── .gitignore
├── LICENSE
├── README.md
├── gm8x_fix.c
├── patch_types.h
├── patches.c
└── version.rc


/.gitignore:
--------------------------------------------------------------------------------
1 | *.exe
2 | *.o
3 | *.obj
4 | *.res
5 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2019 Floogle
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # gm8x_fix
  2 | gm8x_fix is a patcher that fixes certain issues in games made with
  3 | GameMaker 7.0, 8.0, and 8.1. You can download the latest release from the
  4 | [Releases](https://github.com/skyfloogle/gm8x_fix/releases/latest) tab.
  5 | 
  6 | # How do I use it?
  7 | Drag the executable file for your game onto gm8x_fix.exe. Or, if you're a
  8 | commandline nerd, you can run it with:
  9 | ```bash
 10 | gm8x_fix [options] FILE
 11 | ```
 12 | Available options include:
 13 | - `-s` Remove commandline output and apply any available patches.
 14 | - `-nb` Disable the automatic backup. Please back up manually if you use this.
 15 | - `-ni` Don't offer input lag patch.
 16 | - `-nj` Don't offer joystick patch.
 17 | - `-ns` Don't offer scheduler patch.
 18 | - `-nm` Don't offer memory patch.
 19 | - `-nd` Don't offer DirectPlay patch.
 20 | 
 21 | If you're automating patching, take note that the program will exit with code
 22 | 1 on failure.
 23 | 
 24 | For building, you can just build the C file with your favourite compiler, it
 25 | doesn't have any dependencies.
 26 | 
 27 | gm8x_fix currently supports games made in the following versions of GameMaker:
 28 | - 7.0
 29 | - 8.0
 30 | - 8.1.65
 31 | - 8.1.71
 32 | - 8.1.91
 33 | - 8.1.135
 34 | - 8.1.140
 35 | - 8.1.141
 36 | 
 37 | # The issues this fixes, and how it fixes them
 38 | ## The input lag patch
 39 | When running a game, GameMaker 8 runs the game code, waits for the next frame
 40 | to start, and *then* puts the image on the screen. This adds a frame of input
 41 | lag. Studio and later swap the waiting and putting the image on the screen.
 42 | The input lag patch changes it to act more like Studio: run the game code, then
 43 | put the frame on the screen **immediately** before waiting for the next frame.
 44 | 
 45 | ## The joystick patch
 46 | Early versions of GameMaker have a *terrible* implementation of joystick
 47 | support, which can cause games to slow down if joysticks are installed but not
 48 | plugged in. This slowdown exists on games that don't use the joystick
 49 | functions, but is much worse on games that do. This occurs because every frame,
 50 | it polls the first two joysticks even if they aren't connected, and polling
 51 | joysticks that aren't connected causes a massive search through the registry,
 52 | which takes up a lot of time.<br/>
 53 | This patch replaces literally every call to the joystick API with some code
 54 | that pretends there are no joysticks connected. Basically, it completely
 55 | disables joystick support.
 56 | 
 57 | ## The scheduler patch
 58 | Between frames, GameMaker calls
 59 | [Sleep](https://docs.microsoft.com/en-us/windows/win32/api/synchapi/nf-synchapi-sleep)
 60 | in order to limit the framerate. Unfortunately, this function isn't very precise,
 61 | which means games can sleep for longer than they were intended to, which may lead
 62 | to sluggish or inconsistent framerates on some computers. There is a function called
 63 | [timeBeginPeriod](https://docs.microsoft.com/en-us/windows/win32/api/timeapi/nf-timeapi-timebeginperiod)
 64 | which allows us to make the function more precise, but GameMaker doesn't use it
 65 | out of the box. This patch invokes that function at game start and improves
 66 | the precision. The patch overwrites the import for one of the joystick functions,
 67 | so using the scheduler patch without the joystick patch may cause issues.
 68 | 
 69 | [Here's](https://www.youtube.com/watch?v=oGg06HMPASg) a YouTube video with a more
 70 | detailed explanation.
 71 | 
 72 | This fix also exists as a DLL hack for GameMaker 8.1 and up (no 8.0, sorry).
 73 | This includes GameMaker:Studio.
 74 | [Click here for more information on gms_scheduler_fix.](https://github.com/omicronrex/gms_scheduler_fix)
 75 | 
 76 | ## The memory patch
 77 | Some games also run into issues on some newer computers where the game crashes
 78 | on startup with the message "Unexpected error occured when running the game" or
 79 | "Out of memory".<br/>
 80 | This can, on some games, be fixed by enabling the flag in the header that tells
 81 | the OS the program can understand addresses bigger than 2GB. Shoutouts to
 82 | [these guys](https://iwannacommunity.com/forum/index.php@topic=2308.msg16505.html)
 83 | for finding that.
 84 | 
 85 | ## The display reset patch
 86 | In all GameMaker 8.1.141 games, when the game loses its Direct3D handle (for
 87 | example, through the computer being locked), without any surfaces having been
 88 | created, the game will lock up. This patch makes it behave the same as if you
 89 | had created and deleted a surface: it will try to get a new handle, then if
 90 | that fails, wait for five seconds and try again, and if that fails it will
 91 | close. This issue only affects specifically 8.1.141.
 92 | 
 93 | ## The DirectPlay patch
 94 | GameMaker games use DirectPlay for networking, but loading the DirectPlay DLL
 95 | on newer versions of Windows brings up a prompt because DirectPlay is
 96 | deprecated. In fact, on newer versions of Windows, it just doesn't work at all,
 97 | and does nothing other than drastically extend startup times.<br/>
 98 | The patch replaces the attempt to load DirectPlay with an attempt to load
 99 | literally nothing. This somehow doesn't break anything unless you're using the
100 | networking functions.
101 | 
102 | # So what's the catch?
103 | If the game used the builtin joystick functions, it will no longer work with
104 | joysticks if you apply the joystick patch. Some games use an external library
105 | like [joydll](http://web.archive.org/web/20191214124845/https://gmc.yoyogames.com/index.php?showtopic=495788)
106 | or the newer [gm82joy](https://github.com/omicronrex/gm82joy)
107 | for joystick support. Those will work fine.
108 | 
109 | The scheduler patch overwrites some debug logging, but that shouldn't cause any
110 | issues.
111 | 
112 | I've heard reports of the input lag patch making the framepacing less
113 | consistent. See how it feels, and decide for yourself which you prefer.
114 | 
115 | The DirectPlay patch will break GameMaker's built-in networking. Any calls to
116 | the networking functions will probably trigger an access violation. If this
117 | causes problems outside of multiplayer modes in any games, open an issue and
118 | I'll make a less janky solution.
119 | 


--------------------------------------------------------------------------------
/gm8x_fix.c:
--------------------------------------------------------------------------------
  1 | #include <errno.h>
  2 | #include <stdio.h>
  3 | #include <stdlib.h>
  4 | #include <string.h>
  5 | 
  6 | #include "patch_types.h"
  7 | // i didn't want to fill the main source file with thousands of lines of patch data
  8 | // but i also didn't want to duplicate all the patch names in a header file
  9 | // so i'm including a c file sorry lads
 10 | #include "patches.c"
 11 | 
 12 | #define CLOSE_PATCHER \
 13 | 	if (!silent) { \
 14 | 		puts("Press Enter to close the patcher."); \
 15 | 		getchar(); \
 16 | 	} \
 17 | 	exit(1);
 18 | #define puts if (!silent) puts
 19 | #define printf if (!silent) printf
 20 | #define wait() if (!silent) while (getchar() != '\n');
 21 | 
 22 | Patch patches[] = {
 23 | 	{.bytes = upx_80_v0, .name = "UPX unpacked header adjustment (variant 0)", .type = UPX},
 24 | 	{.bytes = upx_80_v1, .name = "UPX unpacked header adjustment (variant 1)", .type = UPX},
 25 | 	{.bytes = mempatch, .name = "Memory patch", .type = MEM},
 26 | 
 27 | 	{.bytes = joypatch_70, .name = "GM7.0 joystick patch", .type = JOY},
 28 | 	{.bytes = schedpatch_70, .name = "GM7.0 scheduler patch", .type = SCHED},
 29 | 	{.bytes = inputlagpatch_70, .name = "GM7.0 input lag patch", .type = INPUTLAG},
 30 | 	{.bytes = dplaypatch_70, .name = "GM7.0 DirectPlay patch", .type = DPLAY},
 31 | 
 32 | 	{.bytes = joypatch_80, .name = "GM8.0 joystick patch", .type = JOY},
 33 | 	{.bytes = schedpatch_80, .name = "GM8.0 scheduler patch", .type = SCHED},
 34 | 	{.bytes = schedpatch_80upx, .name = "GM8.0 (UPX unpacked) scheduler patch", .type = SCHED},
 35 | 	{.bytes = inputlagpatch_80, .name = "GM8.0 input lag patch", .type = INPUTLAG},
 36 | 	{.bytes = dplaypatch_80, .name = "GM8.0 DirectPlay patch", .type = DPLAY},
 37 | 
 38 | 	{.bytes = joypatch_81_65, .name = "GM8.1.65 joystick patch", .type = JOY},
 39 | 	{.bytes = schedpatch_81_65, .name = "GM8.1.65 scheduler patch", .type = SCHED},
 40 | 	{.bytes = inputlagpatch_81_65, .name = "GM8.1.65 input lag patch", .type = INPUTLAG},
 41 | 	{.bytes = dplaypatch_81_65, .name = "GM8.1.65 DirectPlay patch", .type = DPLAY},
 42 | 
 43 | 	{.bytes = joypatch_81_71, .name = "GM8.1.71 joystick patch", .type = JOY},
 44 | 	{.bytes = schedpatch_81_71, .name = "GM8.1.71 scheduler patch", .type = SCHED},
 45 | 	{.bytes = inputlagpatch_81_71, .name = "GM8.1.71 input lag patch", .type = INPUTLAG},
 46 | 	{.bytes = dplaypatch_81_71, .name = "GM8.1.71 DirectPlay patch", .type = DPLAY},
 47 | 
 48 | 	{.bytes = joypatch_81_91, .name = "GM8.1.91 joystick patch", .type = JOY},
 49 | 	{.bytes = schedpatch_81_91, .name = "GM8.1.91 scheduler patch", .type = SCHED},
 50 | 	{.bytes = inputlagpatch_81_91, .name = "GM8.1.91 input lag patch", .type = INPUTLAG},
 51 | 	{.bytes = dplaypatch_81_91, .name = "GM8.1.91 DirectPlay patch", .type = DPLAY},
 52 | 
 53 | 	{.bytes = joypatch_81_135, .name = "GM8.1.135 joystick patch", .type = JOY},
 54 | 	{.bytes = schedpatch_81_135, .name = "GM8.1.135 scheduler patch", .type = SCHED},
 55 | 	{.bytes = inputlagpatch_81_135, .name = "GM8.1.135 input lag patch", .type = INPUTLAG},
 56 | 	{.bytes = dplaypatch_81_135, .name = "GM8.1.135 DirectPlay patch", .type = DPLAY},
 57 | 
 58 | 	{.bytes = joypatch_81_140, .name = "GM8.1.140 joystick patch", .type = JOY},
 59 | 	{.bytes = schedpatch_81_140, .name = "GM8.1.140 scheduler patch", .type = SCHED},
 60 | 	{.bytes = inputlagpatch_81_140, .name = "GM8.1.140 input lag patch", .type = INPUTLAG},
 61 | 	{.bytes = dplaypatch_81_140, .name = "GM8.1.140 DirectPlay patch", .type = DPLAY},
 62 | 
 63 | 	{.bytes = joypatch_81_141, .name = "GM8.1.141 joystick patch", .type = JOY},
 64 | 	{.bytes = schedpatch_81_141, .name = "GM8.1.141 scheduler patch", .type = SCHED},
 65 | 	{.bytes = inputlagpatch_81_141, .name = "GM8.1.141 input lag patch", .type = INPUTLAG},
 66 | 	{.bytes = resetpatch_81_141, .name = "GM8.1.141 display reset patch", .type = RESET},
 67 | 	{.bytes = dplaypatch_81_141, .name = "GM8.1.141 DirectPlay patch", .type = DPLAY},
 68 | 	
 69 | 	// the wall of shame
 70 | 	{.bytes = resetpatch_fix_81_141, .name = "gm8x_fix 0.5.5-0.5.6 bugfix", .type = BUGFIX},
 71 | 	
 72 | 	{.bytes = NULL},
 73 | };
 74 | 
 75 | bool silent = false;
 76 | 
 77 | static PatchState can_patch(FILE *f, PatchByte patches[]) {
 78 | 	// returns 2 if already patched, 1 if unpatched, 0 if it's not the right file
 79 | 	bool unpatched = true;
 80 | 	bool patched = true;
 81 | 	int c;
 82 | 	for (PatchByte *p = patches; p->pos != -1; p++) {
 83 | 		fseek(f, p->pos, SEEK_SET);
 84 | 		c = fgetc(f);
 85 | 		if (c != p->orig_byte) {
 86 | 			unpatched = false;
 87 | 		}
 88 | 		if (c != p->new_byte) {
 89 | 			patched = false;
 90 | 		}
 91 | 	}
 92 | 	if (patched){
 93 | 		return DONE;
 94 | 	}
 95 | 	if (unpatched) {
 96 | 		return ABLE;
 97 | 	}
 98 | 	return UNFOUND;
 99 | }
100 | 
101 | static void strcatfn(char *s, const char *fn) {
102 | #ifdef _WIN32
103 | 	// windows files can't have quotes so no sanitation necessary
104 | 	strcat(s, "\"");
105 | 	strcat(s, fn);
106 | 	strcat(s, "\"");
107 | #else
108 | 	// unix files can have quotes so gotta sanitize
109 | 	for (int i = 0; i < strlen(fn); i++) {
110 | 		if (fn[i] != '"') {
111 | 			*s++ = fn[i];
112 | 		} else {
113 | 			*s++ = '\\';
114 | 			*s++ = '"';
115 | 		}
116 | 	}
117 | 	*s++ = '"';
118 | 	*s++ = 0;
119 | #endif
120 | }
121 | 
122 | static bool prompt(const char *text) {
123 | 	if (silent) return true;
124 | 	int c = 0;
125 | 	while (c != 'y' && c != 'n' && c != 'Y' && c != 'N') {
126 | 		printf(text);
127 | 		c = getchar();
128 | 		while (getchar() != '\n');
129 | 	}
130 | 	return (c == 'y' || c == 'Y');
131 | }
132 | 
133 | // return true if a backup can be made
134 | static bool rename_for_backup(const char *fn, const char *bak_fn) {
135 | 	puts("Making backup...");
136 | 	bool can_backup = true;
137 | 	// rename the original
138 | 	if (rename(fn, bak_fn)) {
139 | 		if (errno == EEXIST) {
140 | 			errno = 0;
141 | 			printf("There is already a file in location %s\n", bak_fn);
142 | 			if (prompt("Overwrite it? [y/n] ")) {
143 | 				if (remove(bak_fn)) {
144 | 					printf("Could not remove existing file (errno %i).\n", errno);
145 | 					if (prompt("Continue without making a backup? [y/n] ")) {
146 | 						can_backup = false;
147 | 					} else {
148 | 						CLOSE_PATCHER;
149 | 					}
150 | 				} else {
151 | 					if (rename(fn, bak_fn)) {
152 | 						printf("The existing file was deleted, but the backup could still not be made (errno %i).\n", errno);
153 | 						puts("I hope there wasn't anything important in there...");
154 | 						if (prompt("Continue without making a backup? [y/n] ")) {
155 | 							can_backup = false;
156 | 						} else {
157 | 							CLOSE_PATCHER;
158 | 						}
159 | 					}
160 | 				}
161 | 			} else {
162 | 				can_backup = false;
163 | 			}
164 | 		} else {
165 | 			printf("Failed to add .bak to the filename (errno %i).\n", errno);
166 | 			if (prompt("Continue without making a backup? [y/n] ")) {
167 | 				can_backup = false;
168 | 			} else {
169 | 				CLOSE_PATCHER;
170 | 			}
171 | 		}
172 | 	}
173 | 	return can_backup;
174 | }
175 | 
176 | // de-upx if necessary, return true if unpacked
177 | static bool upx(FILE **fp, const char *fn, const char *argv0, bool make_backup) {
178 | 	FILE *f = *fp;
179 | 	// identify UPX0 header
180 | 	fseek(f, 0x3c, SEEK_SET);
181 | 	int pe_pointer;
182 | 	fread(&pe_pointer, 4, 1, f);
183 | 	fseek(f, pe_pointer + 0x14, SEEK_SET);
184 | 	short opt_len;
185 | 	fread(&opt_len, 2, 1, f);
186 | 	fseek(f, opt_len + 2, SEEK_CUR);
187 | 	const char head1[] = "UPX0\0\0\0"; // 4th null is implicit
188 | 	for (int i = 0; i < 8; i++) {
189 | 		if (fgetc(f) != head1[i]) return false;
190 | 	}
191 | 	char *bak_fn = NULL;
192 | 	bool can_backup = false;
193 | 	if (make_backup) {
194 | 		// make backup filename
195 | 		bak_fn = malloc(strlen(fn) + 5);
196 | 		strcpy(bak_fn, fn);
197 | 		strcat(bak_fn, ".bak");
198 | 		// ask for confirmation
199 | 		printf("Will make a backup to %s\n", bak_fn);
200 | 		puts("Looks like your game was packed with UPX. We need to unpack it first.");
201 | 		puts("Please download the latest release of UPX from https://github.com/upx/upx/releases/latest");
202 | 		puts("and put upx.exe in the same directory as gm8x_fix.exe, then press Enter to unpack.");
203 | 		wait();
204 | 		// rename original
205 | 		fclose(f);
206 | 		can_backup = rename_for_backup(fn, bak_fn);
207 | 	} else {
208 | 		puts("Looks like your game was packed with UPX. We need to unpack it first.");
209 | 		puts("Please download the latest release of UPX from https://github.com/upx/upx/releases/latest");
210 | 		puts("and put upx.exe in the same directory as gm8x_fix.exe, then press Enter to unpack.");
211 | 		puts("NOTE: Making a backup is HIGHLY RECOMMENDED for UPX games!");
212 | 		wait();
213 | 		fclose(f);
214 | 	}
215 | 	// get upx path
216 | 	char *cmd_buf = calloc((strlen(fn) + 5) * 4 + strlen(argv0), 1);
217 | 	// wrap entire thing in quotes on windows because system() on windows is `funky`
218 | #ifdef _WIN32
219 | 	cmd_buf[0] = '"';
220 | #endif
221 | 	int path_len = strlen(argv0);
222 | 	while (path_len > 0 && argv0[path_len-1] != '/'
223 | #ifdef _WIN32
224 | 		&& argv0[path_len-1] != '\\'
225 | #endif
226 | 	) {
227 | 		path_len--;
228 | 	}
229 | 	if (path_len > 0) {
230 | 		strcatfn(cmd_buf, argv0);
231 | 	}
232 | 	cmd_buf[path_len+2] = 0;
233 | #ifndef _WIN32
234 | 	cmd_buf[path_len+1] = 0;
235 | #endif
236 | 	if (can_backup) {
237 | 		strcat(cmd_buf, "upx\" -d -o ");
238 | 		strcatfn(cmd_buf, fn);
239 | 		strcat(cmd_buf, " ");
240 | 		strcatfn(cmd_buf, bak_fn);
241 | 	} else {
242 | 		strcat(cmd_buf, "upx -d ");
243 | 		strcatfn(cmd_buf, fn);
244 | 	}
245 | #ifdef _WIN32
246 | 	strcat(cmd_buf, "\"");
247 | #endif
248 | 	int res = system(cmd_buf);
249 | 	if (res != 0) {
250 | 		printf("UPX unpack failed (error code %i).", res);
251 | 		if (can_backup && rename(bak_fn, fn) != 0) {
252 | 			printf("Could not restore the original file (errno %i).\n", errno);
253 | 			puts("Your game will have had .bak added to its filename, and no ");
254 | 			puts("patches have been applied.");
255 | 		} else {
256 | 			puts("The backup has been restored and the game is unchanged.");
257 | 		}
258 | 		free(bak_fn);
259 | 		free(cmd_buf);
260 | 		CLOSE_PATCHER;
261 | 	}
262 | 	if (bak_fn != NULL) free(bak_fn);
263 | 	free(cmd_buf);
264 | 	// reopen
265 | 	*fp = f = fopen(fn, "rb");
266 | 	return true;
267 | }
268 | 
269 | static void patch_exe(FILE *f, PatchByte patches[]) {
270 | 	for (PatchByte *p = patches; p->pos != -1; p++) {
271 | 		fseek(f, p->pos, SEEK_SET);
272 | 		fputc(p->new_byte, f);
273 | 	}
274 | }
275 | 
276 | int main(int argc, const char *argv[]) {
277 | 	// check arguments
278 | 	const char *fn = NULL;
279 | 	bool show_help = false;
280 | 	bool valid_args = true;
281 | 	bool make_backup = true;
282 | 	bool disable_patches[TYPE_COUNT] = {0};
283 | 	if (argc == 2) {
284 | 		if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0) {
285 | 			show_help = true;
286 | 		} else {
287 | 			fn = argv[1];
288 | 		}
289 | 	} else if (argc >= 3) {
290 | 		for (int i = 1; i < argc; i++) {
291 | 			if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0) {
292 | 				show_help = true;
293 | 				break;
294 | 			} else if (strcmp(argv[i], "-s") == 0) {
295 | 				silent = true;
296 | 			} else if (strcmp(argv[i], "-nb") == 0) {
297 | 				make_backup = false;
298 | 			} else if (strcmp(argv[i], "-nj") == 0) {
299 | 				disable_patches[JOY] = true;
300 | 			} else if (strcmp(argv[i], "-nm") == 0) {
301 | 				disable_patches[MEM] = true;
302 | 			} else if (strcmp(argv[i], "-nd") == 0) {
303 | 				disable_patches[DPLAY] = true;
304 | 			} else if (strcmp(argv[i], "-ns") == 0) {
305 | 				disable_patches[SCHED] = true;
306 | 			} else if (strcmp(argv[i], "-ni") == 0) {
307 | 				disable_patches[INPUTLAG] = true;
308 | 			} else if (strcmp(argv[i], "-nr") == 0) {
309 | 				disable_patches[RESET] = true;
310 | 			} else if (fn == NULL) {
311 | 				// yeah i don't feel like figuring out something better
312 | 				fn = argv[i];
313 | 			} else {
314 | 				valid_args = false;
315 | 			}
316 | 		}
317 | 	} else {
318 | 		valid_args = false;
319 | 	}
320 | 	// funny title
321 | 	puts("Welcome to gm8x_fix v0.5.9!");
322 | 	puts("Source code is at https://github.com/skyfloogle/gm8x_fix under MIT license.");
323 | 	puts("---------------------------------------------------------------------------");
324 | 	// did the user decide to be a funnyman and disable everything
325 | 	bool all_disabled = true;
326 | 	for (int i = 0; i < TYPE_COUNT; i++) {
327 | 		if (i != UPX && i != BUGFIX && !disable_patches[i]) {
328 | 			all_disabled = false;
329 | 			break;
330 | 		}
331 | 	}
332 | 	if (all_disabled) {
333 | 		puts("you literally disabled all patches what were you expecting to happen");
334 | 		CLOSE_PATCHER;
335 | 	}
336 | 	// compain about arguments if necessary
337 | 	if (!valid_args || show_help) {
338 | 		if (!valid_args) puts("Error: Invalid arguments.");
339 | 		puts("Please drag your Game Maker game onto the patcher's executable file.");
340 | 		puts("Or if you're a commandline nerd, run with this:");
341 | 		puts(" gm8x_fix [options] FILE");
342 | 		puts("Check the readme on GitHub for information on what the patches are.");
343 | 		puts("Available options include:");
344 | 		puts(" -h   Show this help. (--help also works)");
345 | 		puts(" -s   Remove commandline output and apply any available patches.");
346 | 		puts(" -nb  Disable automatic backup (please back up manually if you do this)");
347 | 		puts(" -ni  Don't offer input lag patch.");
348 | 		puts(" -nj  Don't offer joystick patch.");
349 | 		puts(" -ns  Don't offer scheduler patch.");
350 | 		puts(" -nr  Don't offer display reset patch.");
351 | 		puts(" -nm  Don't offer memory patch.");
352 | 		puts(" -nd  Don't offer DirectPlay patch.\n");
353 | 		CLOSE_PATCHER;
354 | 	}
355 | 	printf("Inspecting file: %s\n\n", fn);
356 | 	FILE *f = fopen(fn, "rb");
357 | 	if (f == NULL) {
358 | 		printf("Could not open file (errno %i).\n", errno);
359 | 		CLOSE_PATCHER;
360 | 	}
361 | 	if (fgetc(f) != 'M' || fgetc(f) != 'Z') {
362 | 		fclose(f);
363 | 		puts("This is not an executable file.");
364 | 		CLOSE_PATCHER;
365 | 	}
366 | 	// de-upx if necessary
367 | 	bool unpacked_upx = upx(&f, fn, argv[0], make_backup);
368 | 	// identify patches
369 | 	bool any_patch_applied = false;
370 | 	bool can_apply_any = false;
371 | 	bool upx_found = false;
372 | 	for (Patch *patch = patches; patch->bytes != NULL; patch++) {
373 | 		patch->state = can_patch(f, patch->bytes);
374 | 		if (disable_patches[patch->type] && patch->state == ABLE) {
375 | 			patch->state = UNFOUND;
376 | 		}
377 | 		if (patch->type != MEM) {
378 | 			if (patch->state == ABLE) {
379 | 				if (patch->type == UPX) {
380 | 					upx_found = true;
381 | 				}
382 | 				can_apply_any = true;
383 | 			} else if (patch->state == DONE) {
384 | 				any_patch_applied = true;
385 | 			}
386 | 		}
387 | 	}
388 | 
389 | 	// list patches
390 | 	if (!can_apply_any && !any_patch_applied) {
391 | 		puts("This game cannot be patched. It may not be a GameMaker 7.0, 8.0, or 8.1 game.");
392 | 		fclose(f);
393 | 		CLOSE_PATCHER;
394 | 	}
395 | 	if (unpacked_upx && can_apply_any && !upx_found) {
396 | 		puts("Unpacked with UPX, but header offset wasn't recognised. I haven't seen this before, please file an issue on the GitHub.");
397 | 		puts("You can continue applying patches if you want by pressing Enter.");
398 | 		wait();
399 | 	}
400 | 	if (any_patch_applied) {
401 | 		puts("Patches already applied:");
402 | 		for (Patch *patch = patches; patch->bytes != NULL; patch++) {
403 | 			if (patch->state == DONE) {
404 | 				printf("* %s\n", patch->name);
405 | 			}
406 | 		}
407 | 	}
408 | 	if (can_apply_any) {
409 | 		puts("Patches that can be applied:");
410 | 		for (Patch *patch = patches; patch->bytes != NULL; patch++) {
411 | 			if (patch->state == ABLE) {
412 | 				if (patch->type == UPX || patch->type == BUGFIX) {
413 | 					printf("* %s (required, I won't ask for confirmation)\n", patch->name);
414 | 				} else {
415 | 					printf("* %s\n", patch->name);
416 | 				}
417 | 			}
418 | 		}
419 | 	} else {
420 | 		puts("No new patches can be applied.");
421 | 		fclose(f);
422 | 		CLOSE_PATCHER;
423 | 	}
424 | 	// if we unpacked upx it's already backed up
425 | 	if (!unpacked_upx && make_backup) {
426 | 		// make backup filename
427 | 		char *bak_fn = malloc(strlen(fn) + 5);
428 | 		strcpy(bak_fn, fn);
429 | 		strcat(bak_fn, ".bak");
430 | 		// ask for confirmation
431 | 		printf("Will make a backup to %s\n", bak_fn);
432 | 		printf("Press Enter to make a backup and choose patches to apply. ");
433 | 		wait();
434 | 		fclose(f); // i waited until here to close it so you can't mess with the file before confirming
435 | 		bool can_backup = rename_for_backup(fn, bak_fn);
436 | 		if (can_backup) {
437 | 			// copy it to the original location
438 | 			char *copy_cmd = malloc(strlen(bak_fn) * 4);
439 | #ifdef _WIN32
440 | 			strcpy(copy_cmd, "copy ");
441 | #else
442 | 			strcpy(copy_cmd, "cp ");
443 | #endif
444 | 			strcatfn(copy_cmd, bak_fn);
445 | 			strcat(copy_cmd, " ");
446 | 			strcatfn(copy_cmd, fn);
447 | 			int res = system(copy_cmd);
448 | 			if (res != 0) {
449 | 				printf("File copy failed (error code %i).\n", res);
450 | 				if (rename(bak_fn, fn) != 0) {
451 | 					printf("Could not restore the original file (errno %i).\n", errno);
452 | 					puts("Your game will have had .bak added to its filename, and no ");
453 | 					puts("patches have been applied.");
454 | 				} else {
455 | 					puts("The backup has been restored and the game is unchanged.");
456 | 				}
457 | 				free(bak_fn);
458 | 				free(copy_cmd);
459 | 				CLOSE_PATCHER;
460 | 			}
461 | 			free(bak_fn);
462 | 			free(copy_cmd);
463 | 		} else {
464 | 			puts("Not backing up.");
465 | 		}
466 | 	} else {
467 | 		fclose(f);
468 | 	}
469 | 	// apply the patches
470 | 	f = fopen(fn, "rb+");
471 | 	bool joy_patched = false;
472 | 	for (Patch *patch = patches; patch->bytes != NULL; patch++) {
473 | 		if (patch->type == JOY && patch->state == DONE) {
474 | 			joy_patched = true;
475 | 		}
476 | 		if (patch->state == ABLE) {
477 | 			bool able = false;
478 | 			if (patch->type == UPX || patch->type == BUGFIX) {
479 | 				able = true;
480 | 				printf("Applying %s...\n", patch->name);
481 | 			} else {
482 | 				if (patch->type == SCHED && !joy_patched) {
483 | 					puts("It looks like the joystick patch wasn't applied. It's best to apply that if you're going to use the scheduler patch.");
484 | 				}
485 | 				printf("Apply %s? [y/n] ", patch->name);
486 | 				able = prompt("");
487 | 			}
488 | 			if (able) {
489 | 				patch_exe(f, patch->bytes);
490 | 				if (patch->type == JOY) {
491 | 					joy_patched = true;
492 | 				}
493 | 			}
494 | 		}
495 | 	}
496 | 	fclose(f);
497 | 	puts("All done!");
498 | 	puts("Press Enter to close the patcher.");
499 | 	wait();
500 | 	return 0;
501 | }
502 | 


--------------------------------------------------------------------------------
/patch_types.h:
--------------------------------------------------------------------------------
 1 | #ifndef PATCH_TYPES_H
 2 | #define PATCH_TYPES_H
 3 | 
 4 | #include <stdbool.h>
 5 | #include <stdint.h>
 6 | 
 7 | typedef struct {
 8 | 	int pos;
 9 | 	uint8_t orig_byte;
10 | 	uint8_t new_byte;
11 | } PatchByte;
12 | 
13 | typedef enum {
14 | 	UPX,
15 | 	JOY,
16 | 	MEM,
17 | 	DPLAY,
18 | 	SCHED,
19 | 	INPUTLAG,
20 | 	RESET,
21 | 	BUGFIX, // for when i messed up
22 | 	TYPE_COUNT,
23 | } PatchType;
24 | 
25 | typedef enum {
26 | 	UNFOUND, // default aka 0
27 | 	ABLE,
28 | 	DONE,
29 | } PatchState;
30 | 
31 | typedef struct {
32 | 	PatchByte *bytes;
33 | 	char *name;
34 | 	PatchType type;
35 | 	PatchState state;
36 | } Patch;
37 | 
38 | #endif
39 | 


--------------------------------------------------------------------------------
/patches.c:
--------------------------------------------------------------------------------
   1 | #include "patch_types.h"
   2 | 
   3 | // Memory patch: literally just turn on the IMAGE_FILE_LARGE_ADDRESS_AWARE flag
   4 | PatchByte mempatch[] = {
   5 | 	{0x116, 0x8e, 0xae},
   6 | 	{-1,0,0}
   7 | };
   8 | 
   9 | 
  10 | // UPX fix (and variants)
  11 | // Fixes the file offset GM8 tries to load game data at in de-UPX'd games
  12 | PatchByte upx_80_v0[] = {
  13 | 	{0x144ac1, 0xa4, 0xf0},
  14 | 	{0x144ac2, 0x0a, 0x1c},
  15 | 	{-1,0,0}
  16 | };
  17 | 
  18 | PatchByte upx_80_v1[] = {
  19 | 	{0x144ac1, 0x9c, 0xf0},
  20 | 	{0x144ac2, 0x0a, 0x1c},
  21 | 	{-1,0,0}
  22 | };
  23 | 
  24 | // JOYSTICK PATCHES
  25 | // How to create:
  26 | // 1. Find all calls to joystick functions (joyGetPos, joyGetPosEx, joyGetDevCapsW)
  27 | // 2. Replace with nops and "mov eax, 0xa5" to emulate joystick being unplugged
  28 | 
  29 | PatchByte joypatch_70[] = {
  30 | 	{ 0x13c04b, 0x53, 0x90 },
  31 | 	{ 0x13c04c, 0x6a, 0x90 },
  32 | 	{ 0x13c04d, 0x00, 0x90 },
  33 | 	{ 0x13c04e, 0xe8, 0xb8 },
  34 | 	{ 0x13c04f, 0xa9, 0xa5 },
  35 | 	{ 0x13c050, 0x96, 0x00 },
  36 | 	{ 0x13c051, 0xf4, 0x00 },
  37 | 	{ 0x13c052, 0xff, 0x00 },
  38 | 	{ 0x164fa4, 0x50, 0x90 },
  39 | 	{ 0x164fa5, 0x53, 0x90 },
  40 | 	{ 0x164fa6, 0xe8, 0xb8 },
  41 | 	{ 0x164fa7, 0x49, 0xa5 },
  42 | 	{ 0x164fa8, 0x07, 0x00 },
  43 | 	{ 0x164fa9, 0xf2, 0x00 },
  44 | 	{ 0x164faa, 0xff, 0x00 },
  45 | 	{ 0x165004, 0x50, 0x90 },
  46 | 	{ 0x165005, 0x56, 0x90 },
  47 | 	{ 0x165006, 0xe8, 0xb8 },
  48 | 	{ 0x165007, 0xe9, 0xa5 },
  49 | 	{ 0x165008, 0x06, 0x00 },
  50 | 	{ 0x165009, 0xf2, 0x00 },
  51 | 	{ 0x16500a, 0xff, 0x00 },
  52 | 	{ 0x16509e, 0x68, 0x90 },
  53 | 	{ 0x16509f, 0x94, 0x90 },
  54 | 	{ 0x1650a0, 0x01, 0x90 },
  55 | 	{ 0x1650a1, 0x00, 0x90 },
  56 | 	{ 0x1650a2, 0x00, 0x90 },
  57 | 	{ 0x1650a3, 0x8d, 0x90 },
  58 | 	{ 0x1650a4, 0x85, 0x90 },
  59 | 	{ 0x1650a5, 0x6c, 0x90 },
  60 | 	{ 0x1650a6, 0xfe, 0x90 },
  61 | 	{ 0x1650a7, 0xff, 0x90 },
  62 | 	{ 0x1650a8, 0xff, 0x90 },
  63 | 	{ 0x1650a9, 0x50, 0x90 },
  64 | 	{ 0x1650aa, 0x56, 0x90 },
  65 | 	{ 0x1650ab, 0xe8, 0xb8 },
  66 | 	{ 0x1650ac, 0x3c, 0xa5 },
  67 | 	{ 0x1650ad, 0x06, 0x00 },
  68 | 	{ 0x1650ae, 0xf2, 0x00 },
  69 | 	{ 0x1650af, 0xff, 0x00 },
  70 | 	{ 0x165108, 0x68, 0x90 },
  71 | 	{ 0x165109, 0x94, 0x90 },
  72 | 	{ 0x16510a, 0x01, 0x90 },
  73 | 	{ 0x16510b, 0x00, 0x90 },
  74 | 	{ 0x16510c, 0x00, 0x90 },
  75 | 	{ 0x16510d, 0x8d, 0x90 },
  76 | 	{ 0x16510e, 0x85, 0x90 },
  77 | 	{ 0x16510f, 0x6c, 0x90 },
  78 | 	{ 0x165110, 0xfe, 0x90 },
  79 | 	{ 0x165111, 0xff, 0x90 },
  80 | 	{ 0x165112, 0xff, 0x90 },
  81 | 	{ 0x165113, 0x50, 0x90 },
  82 | 	{ 0x165114, 0x56, 0x90 },
  83 | 	{ 0x165115, 0xe8, 0xb8 },
  84 | 	{ 0x165116, 0xd2, 0xa5 },
  85 | 	{ 0x165117, 0x05, 0x00 },
  86 | 	{ 0x165118, 0xf2, 0x00 },
  87 | 	{ 0x165119, 0xff, 0x00 },
  88 | 	{ 0x16517c, 0x68, 0x90 },
  89 | 	{ 0x16517d, 0x94, 0x90 },
  90 | 	{ 0x16517e, 0x01, 0x90 },
  91 | 	{ 0x16517f, 0x00, 0x90 },
  92 | 	{ 0x165180, 0x00, 0x90 },
  93 | 	{ 0x165181, 0x8d, 0x90 },
  94 | 	{ 0x165182, 0x85, 0x90 },
  95 | 	{ 0x165183, 0x6c, 0x90 },
  96 | 	{ 0x165184, 0xfe, 0x90 },
  97 | 	{ 0x165185, 0xff, 0x90 },
  98 | 	{ 0x165186, 0xff, 0x90 },
  99 | 	{ 0x165187, 0x50, 0x90 },
 100 | 	{ 0x165188, 0x56, 0x90 },
 101 | 	{ 0x165189, 0xe8, 0xb8 },
 102 | 	{ 0x16518a, 0x5e, 0xa5 },
 103 | 	{ 0x16518b, 0x05, 0x00 },
 104 | 	{ 0x16518c, 0xf2, 0x00 },
 105 | 	{ 0x16518d, 0xff, 0x00 },
 106 | 	{ 0x1651f0, 0x68, 0x90 },
 107 | 	{ 0x1651f1, 0x94, 0x90 },
 108 | 	{ 0x1651f2, 0x01, 0x90 },
 109 | 	{ 0x1651f3, 0x00, 0x90 },
 110 | 	{ 0x1651f4, 0x00, 0x90 },
 111 | 	{ 0x1651f5, 0x8d, 0x90 },
 112 | 	{ 0x1651f6, 0x85, 0x90 },
 113 | 	{ 0x1651f7, 0x6c, 0x90 },
 114 | 	{ 0x1651f8, 0xfe, 0x90 },
 115 | 	{ 0x1651f9, 0xff, 0x90 },
 116 | 	{ 0x1651fa, 0xff, 0x90 },
 117 | 	{ 0x1651fb, 0x50, 0x90 },
 118 | 	{ 0x1651fc, 0x56, 0x90 },
 119 | 	{ 0x1651fd, 0xe8, 0xb8 },
 120 | 	{ 0x1651fe, 0xea, 0xa5 },
 121 | 	{ 0x1651ff, 0x04, 0x00 },
 122 | 	{ 0x165200, 0xf2, 0x00 },
 123 | 	{ 0x165201, 0xff, 0x00 },
 124 | 	{ 0x165277, 0x50, 0x90 },
 125 | 	{ 0x165278, 0x56, 0x90 },
 126 | 	{ 0x165279, 0xe8, 0xb8 },
 127 | 	{ 0x16527a, 0x7e, 0xa5 },
 128 | 	{ 0x16527b, 0x04, 0x00 },
 129 | 	{ 0x16527c, 0xf2, 0x00 },
 130 | 	{ 0x16527d, 0xff, 0x00 },
 131 | 	{ 0x1656de, 0x50, 0x90 },
 132 | 	{ 0x1656df, 0x56, 0x90 },
 133 | 	{ 0x1656e0, 0xe8, 0xb8 },
 134 | 	{ 0x1656e1, 0x17, 0xa5 },
 135 | 	{ 0x1656e3, 0xf2, 0x00 },
 136 | 	{ 0x1656e4, 0xff, 0x00 },
 137 | 	{ 0x16575e, 0x50, 0x90 },
 138 | 	{ 0x16575f, 0x56, 0x90 },
 139 | 	{ 0x165760, 0xe8, 0xb8 },
 140 | 	{ 0x165761, 0x97, 0xa5 },
 141 | 	{ 0x165762, 0xff, 0x00 },
 142 | 	{ 0x165763, 0xf1, 0x00 },
 143 | 	{ 0x165764, 0xff, 0x00 },
 144 | 	{ 0x1657de, 0x50, 0x90 },
 145 | 	{ 0x1657df, 0x56, 0x90 },
 146 | 	{ 0x1657e0, 0xe8, 0xb8 },
 147 | 	{ 0x1657e1, 0x17, 0xa5 },
 148 | 	{ 0x1657e2, 0xff, 0x00 },
 149 | 	{ 0x1657e3, 0xf1, 0x00 },
 150 | 	{ 0x1657e4, 0xff, 0x00 },
 151 | 	{ 0x16585e, 0x50, 0x90 },
 152 | 	{ 0x16585f, 0x56, 0x90 },
 153 | 	{ 0x165860, 0xe8, 0xb8 },
 154 | 	{ 0x165861, 0x97, 0xa5 },
 155 | 	{ 0x165862, 0xfe, 0x00 },
 156 | 	{ 0x165863, 0xf1, 0x00 },
 157 | 	{ 0x165864, 0xff, 0x00 },
 158 | 	{ 0x1658de, 0x50, 0x90 },
 159 | 	{ 0x1658df, 0x56, 0x90 },
 160 | 	{ 0x1658e0, 0xe8, 0xb8 },
 161 | 	{ 0x1658e1, 0x17, 0xa5 },
 162 | 	{ 0x1658e2, 0xfe, 0x00 },
 163 | 	{ 0x1658e3, 0xf1, 0x00 },
 164 | 	{ 0x1658e4, 0xff, 0x00 },
 165 | 	{ 0x16595e, 0x50, 0x90 },
 166 | 	{ 0x16595f, 0x56, 0x90 },
 167 | 	{ 0x165960, 0xe8, 0xb8 },
 168 | 	{ 0x165961, 0x97, 0xa5 },
 169 | 	{ 0x165962, 0xfd, 0x00 },
 170 | 	{ 0x165963, 0xf1, 0x00 },
 171 | 	{ 0x165964, 0xff, 0x00 },
 172 | 	{ 0x1659e2, 0x50, 0x90 },
 173 | 	{ 0x1659e3, 0x56, 0x90 },
 174 | 	{ 0x1659e4, 0xe8, 0xb8 },
 175 | 	{ 0x1659e5, 0x13, 0xa5 },
 176 | 	{ 0x1659e6, 0xfd, 0x00 },
 177 | 	{ 0x1659e7, 0xf1, 0x00 },
 178 | 	{ 0x1659e8, 0xff, 0x00 },
 179 | 	{-1,0,0}
 180 | };
 181 | 
 182 | PatchByte joypatch_80[] = {
 183 | 	{ 0x1399df, 0x53, 0xb8 },
 184 | 	{ 0x1399e0, 0x6a, 0xa5 },
 185 | 	{ 0x1399e2, 0xe8, 0x0 },
 186 | 	{ 0x1399e3, 0x61, 0x0 },
 187 | 	{ 0x1399e4, 0x7b, 0x90 },
 188 | 	{ 0x1399e5, 0xf4, 0x90 },
 189 | 	{ 0x1399e6, 0xff, 0x90 },
 190 | 	{ 0x139ae0, 0x53, 0xb8 },
 191 | 	{ 0x139ae1, 0x6a, 0xa5 },
 192 | 	{ 0x139ae2, 0x1, 0x0 },
 193 | 	{ 0x139ae3, 0xe8, 0x0 },
 194 | 	{ 0x139ae4, 0x60, 0x0 },
 195 | 	{ 0x139ae5, 0x7a, 0x90 },
 196 | 	{ 0x139ae6, 0xf4, 0x90 },
 197 | 	{ 0x139ae7, 0xff, 0x90 },
 198 | 	{ 0x16466d, 0x50, 0xb8 },
 199 | 	{ 0x16466e, 0x53, 0xa5 },
 200 | 	{ 0x16466f, 0xe8, 0x0 },
 201 | 	{ 0x164670, 0xcc, 0x0 },
 202 | 	{ 0x164671, 0xce, 0x0 },
 203 | 	{ 0x164672, 0xf1, 0x90 },
 204 | 	{ 0x164673, 0xff, 0x90 },
 205 | 	{ 0x1646cd, 0x50, 0xb8 },
 206 | 	{ 0x1646ce, 0x56, 0xa5 },
 207 | 	{ 0x1646cf, 0xe8, 0x0 },
 208 | 	{ 0x1646d0, 0x6c, 0x0 },
 209 | 	{ 0x1646d1, 0xce, 0x0 },
 210 | 	{ 0x1646d2, 0xf1, 0x90 },
 211 | 	{ 0x1646d3, 0xff, 0x90 },
 212 | 	{ 0x164767, 0x68, 0xb8 },
 213 | 	{ 0x164768, 0x94, 0xa5 },
 214 | 	{ 0x164769, 0x1, 0x0 },
 215 | 	{ 0x16476c, 0x8d, 0x90 },
 216 | 	{ 0x16476d, 0x85, 0x90 },
 217 | 	{ 0x16476e, 0x6c, 0x90 },
 218 | 	{ 0x16476f, 0xfe, 0x90 },
 219 | 	{ 0x164770, 0xff, 0x90 },
 220 | 	{ 0x164771, 0xff, 0x90 },
 221 | 	{ 0x164772, 0x50, 0x90 },
 222 | 	{ 0x164773, 0x56, 0x90 },
 223 | 	{ 0x164774, 0xe8, 0x90 },
 224 | 	{ 0x164775, 0xbf, 0x90 },
 225 | 	{ 0x164776, 0xcd, 0x90 },
 226 | 	{ 0x164777, 0xf1, 0x90 },
 227 | 	{ 0x164778, 0xff, 0x90 },
 228 | 	{ 0x1647d1, 0x68, 0xb8 },
 229 | 	{ 0x1647d2, 0x94, 0xa5 },
 230 | 	{ 0x1647d3, 0x1, 0x0 },
 231 | 	{ 0x1647d6, 0x8d, 0x90 },
 232 | 	{ 0x1647d7, 0x85, 0x90 },
 233 | 	{ 0x1647d8, 0x6c, 0x90 },
 234 | 	{ 0x1647d9, 0xfe, 0x90 },
 235 | 	{ 0x1647da, 0xff, 0x90 },
 236 | 	{ 0x1647db, 0xff, 0x90 },
 237 | 	{ 0x1647dc, 0x50, 0x90 },
 238 | 	{ 0x1647dd, 0x56, 0x90 },
 239 | 	{ 0x1647de, 0xe8, 0x90 },
 240 | 	{ 0x1647df, 0x55, 0x90 },
 241 | 	{ 0x1647e0, 0xcd, 0x90 },
 242 | 	{ 0x1647e1, 0xf1, 0x90 },
 243 | 	{ 0x1647e2, 0xff, 0x90 },
 244 | 	{ 0x164849, 0x68, 0xb8 },
 245 | 	{ 0x16484a, 0x94, 0xa5 },
 246 | 	{ 0x16484b, 0x1, 0x0 },
 247 | 	{ 0x16484e, 0x8d, 0x90 },
 248 | 	{ 0x16484f, 0x85, 0x90 },
 249 | 	{ 0x164850, 0x6c, 0x90 },
 250 | 	{ 0x164851, 0xfe, 0x90 },
 251 | 	{ 0x164852, 0xff, 0x90 },
 252 | 	{ 0x164853, 0xff, 0x90 },
 253 | 	{ 0x164854, 0x50, 0x90 },
 254 | 	{ 0x164855, 0x56, 0x90 },
 255 | 	{ 0x164856, 0xe8, 0x90 },
 256 | 	{ 0x164857, 0xdd, 0x90 },
 257 | 	{ 0x164858, 0xcc, 0x90 },
 258 | 	{ 0x164859, 0xf1, 0x90 },
 259 | 	{ 0x16485a, 0xff, 0x90 },
 260 | 	{ 0x1648c1, 0x68, 0xb8 },
 261 | 	{ 0x1648c2, 0x94, 0xa5 },
 262 | 	{ 0x1648c3, 0x1, 0x0 },
 263 | 	{ 0x1648c6, 0x8d, 0x90 },
 264 | 	{ 0x1648c7, 0x85, 0x90 },
 265 | 	{ 0x1648c8, 0x6c, 0x90 },
 266 | 	{ 0x1648c9, 0xfe, 0x90 },
 267 | 	{ 0x1648ca, 0xff, 0x90 },
 268 | 	{ 0x1648cb, 0xff, 0x90 },
 269 | 	{ 0x1648cc, 0x50, 0x90 },
 270 | 	{ 0x1648cd, 0x56, 0x90 },
 271 | 	{ 0x1648ce, 0xe8, 0x90 },
 272 | 	{ 0x1648cf, 0x65, 0x90 },
 273 | 	{ 0x1648d0, 0xcc, 0x90 },
 274 | 	{ 0x1648d1, 0xf1, 0x90 },
 275 | 	{ 0x1648d2, 0xff, 0x90 },
 276 | 	{ 0x164948, 0x50, 0xb8 },
 277 | 	{ 0x164949, 0x56, 0xa5 },
 278 | 	{ 0x16494a, 0xe8, 0x0 },
 279 | 	{ 0x16494b, 0xf9, 0x0 },
 280 | 	{ 0x16494c, 0xcb, 0x0 },
 281 | 	{ 0x16494d, 0xf1, 0x90 },
 282 | 	{ 0x16494e, 0xff, 0x90 },
 283 | 	{ 0x164daf, 0x50, 0xb8 },
 284 | 	{ 0x164db0, 0x56, 0xa5 },
 285 | 	{ 0x164db1, 0xe8, 0x0 },
 286 | 	{ 0x164db2, 0x92, 0x0 },
 287 | 	{ 0x164db3, 0xc7, 0x0 },
 288 | 	{ 0x164db4, 0xf1, 0x90 },
 289 | 	{ 0x164db5, 0xff, 0x90 },
 290 | 	{ 0x164e2f, 0x50, 0xb8 },
 291 | 	{ 0x164e30, 0x56, 0xa5 },
 292 | 	{ 0x164e31, 0xe8, 0x0 },
 293 | 	{ 0x164e32, 0x12, 0x0 },
 294 | 	{ 0x164e33, 0xc7, 0x0 },
 295 | 	{ 0x164e34, 0xf1, 0x90 },
 296 | 	{ 0x164e35, 0xff, 0x90 },
 297 | 	{ 0x164eaf, 0x50, 0xb8 },
 298 | 	{ 0x164eb0, 0x56, 0xa5 },
 299 | 	{ 0x164eb1, 0xe8, 0x0 },
 300 | 	{ 0x164eb2, 0x92, 0x0 },
 301 | 	{ 0x164eb3, 0xc6, 0x0 },
 302 | 	{ 0x164eb4, 0xf1, 0x90 },
 303 | 	{ 0x164eb5, 0xff, 0x90 },
 304 | 	{ 0x164f2f, 0x50, 0xb8 },
 305 | 	{ 0x164f30, 0x56, 0xa5 },
 306 | 	{ 0x164f31, 0xe8, 0x0 },
 307 | 	{ 0x164f32, 0x12, 0x0 },
 308 | 	{ 0x164f33, 0xc6, 0x0 },
 309 | 	{ 0x164f34, 0xf1, 0x90 },
 310 | 	{ 0x164f35, 0xff, 0x90 },
 311 | 	{ 0x164faf, 0x50, 0xb8 },
 312 | 	{ 0x164fb0, 0x56, 0xa5 },
 313 | 	{ 0x164fb1, 0xe8, 0x0 },
 314 | 	{ 0x164fb2, 0x92, 0x0 },
 315 | 	{ 0x164fb3, 0xc5, 0x0 },
 316 | 	{ 0x164fb4, 0xf1, 0x90 },
 317 | 	{ 0x164fb5, 0xff, 0x90 },
 318 | 	{ 0x16502f, 0x50, 0xb8 },
 319 | 	{ 0x165030, 0x56, 0xa5 },
 320 | 	{ 0x165031, 0xe8, 0x0 },
 321 | 	{ 0x165032, 0x12, 0x0 },
 322 | 	{ 0x165033, 0xc5, 0x0 },
 323 | 	{ 0x165034, 0xf1, 0x90 },
 324 | 	{ 0x165035, 0xff, 0x90 },
 325 | 	{ 0x1650b3, 0x50, 0xb8 },
 326 | 	{ 0x1650b4, 0x56, 0xa5 },
 327 | 	{ 0x1650b5, 0xe8, 0x0 },
 328 | 	{ 0x1650b6, 0x8e, 0x0 },
 329 | 	{ 0x1650b7, 0xc4, 0x0 },
 330 | 	{ 0x1650b8, 0xf1, 0x90 },
 331 | 	{ 0x1650b9, 0xff, 0x90 },
 332 | 	{-1,0,0}
 333 | };
 334 | 
 335 | PatchByte joypatch_81_65[] = {
 336 | 	{ 0x1cefb3, 0x53, 0xb8 },
 337 | 	{ 0x1cefb4, 0x6a, 0xa5 },
 338 | 	{ 0x1cefb6, 0xe8, 0x00 },
 339 | 	{ 0x1cefb7, 0x4d, 0x00 },
 340 | 	{ 0x1cefb8, 0xa2, 0x90 },
 341 | 	{ 0x1cefb9, 0xf3, 0x90 },
 342 | 	{ 0x1cefba, 0xff, 0x90 },
 343 | 	{ 0x1cf0b4, 0x53, 0xb8 },
 344 | 	{ 0x1cf0b5, 0x6a, 0xa5 },
 345 | 	{ 0x1cf0b6, 0x01, 0x00 },
 346 | 	{ 0x1cf0b7, 0xe8, 0x00 },
 347 | 	{ 0x1cf0b8, 0x4c, 0x00 },
 348 | 	{ 0x1cf0b9, 0xa1, 0x90 },
 349 | 	{ 0x1cf0ba, 0xf3, 0x90 },
 350 | 	{ 0x1cf0bb, 0xff, 0x90 },
 351 | 	{ 0x20a5ea, 0x8d, 0xb8 },
 352 | 	{ 0x20a5eb, 0x45, 0xa5 },
 353 | 	{ 0x20a5ec, 0xf0, 0x00 },
 354 | 	{ 0x20a5ed, 0x50, 0x00 },
 355 | 	{ 0x20a5ee, 0x53, 0x00 },
 356 | 	{ 0x20a5ef, 0xe8, 0x90 },
 357 | 	{ 0x20a5f0, 0x0c, 0x90 },
 358 | 	{ 0x20a5f1, 0xec, 0x90 },
 359 | 	{ 0x20a5f2, 0xef, 0x90 },
 360 | 	{ 0x20a5f3, 0xff, 0x90 },
 361 | 	{ 0x20a64a, 0x8d, 0xb8 },
 362 | 	{ 0x20a64b, 0x45, 0xa5 },
 363 | 	{ 0x20a64c, 0xf0, 0x00 },
 364 | 	{ 0x20a64d, 0x50, 0x00 },
 365 | 	{ 0x20a64e, 0x56, 0x00 },
 366 | 	{ 0x20a64f, 0xe8, 0x90 },
 367 | 	{ 0x20a650, 0xac, 0x90 },
 368 | 	{ 0x20a651, 0xeb, 0x90 },
 369 | 	{ 0x20a652, 0xef, 0x90 },
 370 | 	{ 0x20a653, 0xff, 0x90 },
 371 | 	{ 0x20a6e9, 0x68, 0xb8 },
 372 | 	{ 0x20a6ea, 0xd8, 0xa5 },
 373 | 	{ 0x20a6eb, 0x02, 0x00 },
 374 | 	{ 0x20a6ee, 0x8d, 0x90 },
 375 | 	{ 0x20a6ef, 0x85, 0x90 },
 376 | 	{ 0x20a6f0, 0x28, 0x90 },
 377 | 	{ 0x20a6f1, 0xfd, 0x90 },
 378 | 	{ 0x20a6f2, 0xff, 0x90 },
 379 | 	{ 0x20a6f3, 0xff, 0x90 },
 380 | 	{ 0x20a6f4, 0x50, 0x90 },
 381 | 	{ 0x20a6f5, 0x56, 0x90 },
 382 | 	{ 0x20a6f6, 0xe8, 0x90 },
 383 | 	{ 0x20a6f7, 0xfd, 0x90 },
 384 | 	{ 0x20a6f8, 0xea, 0x90 },
 385 | 	{ 0x20a6f9, 0xef, 0x90 },
 386 | 	{ 0x20a6fa, 0xff, 0x90 },
 387 | 	{ 0x20a755, 0x68, 0xb8 },
 388 | 	{ 0x20a756, 0xd8, 0xa5 },
 389 | 	{ 0x20a757, 0x02, 0x00 },
 390 | 	{ 0x20a75a, 0x8d, 0x90 },
 391 | 	{ 0x20a75b, 0x85, 0x90 },
 392 | 	{ 0x20a75c, 0x28, 0x90 },
 393 | 	{ 0x20a75d, 0xfd, 0x90 },
 394 | 	{ 0x20a75e, 0xff, 0x90 },
 395 | 	{ 0x20a75f, 0xff, 0x90 },
 396 | 	{ 0x20a760, 0x50, 0x90 },
 397 | 	{ 0x20a761, 0x56, 0x90 },
 398 | 	{ 0x20a762, 0xe8, 0x90 },
 399 | 	{ 0x20a763, 0x91, 0x90 },
 400 | 	{ 0x20a764, 0xea, 0x90 },
 401 | 	{ 0x20a765, 0xef, 0x90 },
 402 | 	{ 0x20a766, 0xff, 0x90 },
 403 | 	{ 0x20a7cd, 0x68, 0xb8 },
 404 | 	{ 0x20a7ce, 0xd8, 0xa5 },
 405 | 	{ 0x20a7cf, 0x02, 0x00 },
 406 | 	{ 0x20a7d2, 0x8d, 0x90 },
 407 | 	{ 0x20a7d3, 0x85, 0x90 },
 408 | 	{ 0x20a7d4, 0x28, 0x90 },
 409 | 	{ 0x20a7d5, 0xfd, 0x90 },
 410 | 	{ 0x20a7d6, 0xff, 0x90 },
 411 | 	{ 0x20a7d7, 0xff, 0x90 },
 412 | 	{ 0x20a7d8, 0x50, 0x90 },
 413 | 	{ 0x20a7d9, 0x56, 0x90 },
 414 | 	{ 0x20a7da, 0xe8, 0x90 },
 415 | 	{ 0x20a7db, 0x19, 0x90 },
 416 | 	{ 0x20a7dc, 0xea, 0x90 },
 417 | 	{ 0x20a7dd, 0xef, 0x90 },
 418 | 	{ 0x20a7de, 0xff, 0x90 },
 419 | 	{ 0x20a845, 0x68, 0xb8 },
 420 | 	{ 0x20a846, 0xd8, 0xa5 },
 421 | 	{ 0x20a847, 0x02, 0x00 },
 422 | 	{ 0x20a84a, 0x8d, 0x90 },
 423 | 	{ 0x20a84b, 0x85, 0x90 },
 424 | 	{ 0x20a84c, 0x28, 0x90 },
 425 | 	{ 0x20a84d, 0xfd, 0x90 },
 426 | 	{ 0x20a84e, 0xff, 0x90 },
 427 | 	{ 0x20a84f, 0xff, 0x90 },
 428 | 	{ 0x20a850, 0x50, 0x90 },
 429 | 	{ 0x20a851, 0x56, 0x90 },
 430 | 	{ 0x20a852, 0xe8, 0x90 },
 431 | 	{ 0x20a853, 0xa1, 0x90 },
 432 | 	{ 0x20a854, 0xe9, 0x90 },
 433 | 	{ 0x20a855, 0xef, 0x90 },
 434 | 	{ 0x20a856, 0xff, 0x90 },
 435 | 	{ 0x20a8c9, 0x8d, 0xb8 },
 436 | 	{ 0x20a8ca, 0x45, 0xa5 },
 437 | 	{ 0x20a8cb, 0xcc, 0x00 },
 438 | 	{ 0x20a8cc, 0x50, 0x00 },
 439 | 	{ 0x20a8cd, 0x56, 0x00 },
 440 | 	{ 0x20a8ce, 0xe8, 0x90 },
 441 | 	{ 0x20a8cf, 0x35, 0x90 },
 442 | 	{ 0x20a8d0, 0xe9, 0x90 },
 443 | 	{ 0x20a8d1, 0xef, 0x90 },
 444 | 	{ 0x20a8d2, 0xff, 0x90 },
 445 | 	{ 0x20ad30, 0x8d, 0xb8 },
 446 | 	{ 0x20ad31, 0x45, 0xa5 },
 447 | 	{ 0x20ad32, 0xcc, 0x00 },
 448 | 	{ 0x20ad33, 0x50, 0x00 },
 449 | 	{ 0x20ad34, 0x56, 0x00 },
 450 | 	{ 0x20ad35, 0xe8, 0x90 },
 451 | 	{ 0x20ad36, 0xce, 0x90 },
 452 | 	{ 0x20ad37, 0xe4, 0x90 },
 453 | 	{ 0x20ad38, 0xef, 0x90 },
 454 | 	{ 0x20ad39, 0xff, 0x90 },
 455 | 	{ 0x20adb0, 0x8d, 0xb8 },
 456 | 	{ 0x20adb1, 0x45, 0xa5 },
 457 | 	{ 0x20adb2, 0xcc, 0x00 },
 458 | 	{ 0x20adb3, 0x50, 0x00 },
 459 | 	{ 0x20adb4, 0x56, 0x00 },
 460 | 	{ 0x20adb5, 0xe8, 0x90 },
 461 | 	{ 0x20adb6, 0x4e, 0x90 },
 462 | 	{ 0x20adb7, 0xe4, 0x90 },
 463 | 	{ 0x20adb8, 0xef, 0x90 },
 464 | 	{ 0x20adb9, 0xff, 0x90 },
 465 | 	{ 0x20ae30, 0x8d, 0xb8 },
 466 | 	{ 0x20ae31, 0x45, 0xa5 },
 467 | 	{ 0x20ae32, 0xcc, 0x00 },
 468 | 	{ 0x20ae33, 0x50, 0x00 },
 469 | 	{ 0x20ae34, 0x56, 0x00 },
 470 | 	{ 0x20ae35, 0xe8, 0x90 },
 471 | 	{ 0x20ae36, 0xce, 0x90 },
 472 | 	{ 0x20ae37, 0xe3, 0x90 },
 473 | 	{ 0x20ae38, 0xef, 0x90 },
 474 | 	{ 0x20ae39, 0xff, 0x90 },
 475 | 	{ 0x20aeb0, 0x8d, 0xb8 },
 476 | 	{ 0x20aeb1, 0x45, 0xa5 },
 477 | 	{ 0x20aeb2, 0xcc, 0x00 },
 478 | 	{ 0x20aeb3, 0x50, 0x00 },
 479 | 	{ 0x20aeb4, 0x56, 0x00 },
 480 | 	{ 0x20aeb5, 0xe8, 0x90 },
 481 | 	{ 0x20aeb6, 0x4e, 0x90 },
 482 | 	{ 0x20aeb7, 0xe3, 0x90 },
 483 | 	{ 0x20aeb8, 0xef, 0x90 },
 484 | 	{ 0x20aeb9, 0xff, 0x90 },
 485 | 	{ 0x20af30, 0x8d, 0xb8 },
 486 | 	{ 0x20af31, 0x45, 0xa5 },
 487 | 	{ 0x20af32, 0xcc, 0x00 },
 488 | 	{ 0x20af33, 0x50, 0x00 },
 489 | 	{ 0x20af34, 0x56, 0x00 },
 490 | 	{ 0x20af35, 0xe8, 0x90 },
 491 | 	{ 0x20af36, 0xce, 0x90 },
 492 | 	{ 0x20af37, 0xe2, 0x90 },
 493 | 	{ 0x20af38, 0xef, 0x90 },
 494 | 	{ 0x20af39, 0xff, 0x90 },
 495 | 	{ 0x20afb0, 0x8d, 0xb8 },
 496 | 	{ 0x20afb1, 0x45, 0xa5 },
 497 | 	{ 0x20afb2, 0xcc, 0x00 },
 498 | 	{ 0x20afb3, 0x50, 0x00 },
 499 | 	{ 0x20afb4, 0x56, 0x00 },
 500 | 	{ 0x20afb5, 0xe8, 0x90 },
 501 | 	{ 0x20afb6, 0x4e, 0x90 },
 502 | 	{ 0x20afb7, 0xe2, 0x90 },
 503 | 	{ 0x20afb8, 0xef, 0x90 },
 504 | 	{ 0x20afb9, 0xff, 0x90 },
 505 | 	{ 0x20b034, 0x8d, 0xb8 },
 506 | 	{ 0x20b035, 0x45, 0xa5 },
 507 | 	{ 0x20b036, 0xcc, 0x00 },
 508 | 	{ 0x20b037, 0x50, 0x00 },
 509 | 	{ 0x20b038, 0x56, 0x00 },
 510 | 	{ 0x20b039, 0xe8, 0x90 },
 511 | 	{ 0x20b03a, 0xca, 0x90 },
 512 | 	{ 0x20b03b, 0xe1, 0x90 },
 513 | 	{ 0x20b03c, 0xef, 0x90 },
 514 | 	{ 0x20b03d, 0xff, 0x90 },
 515 | 	{-1,0,0}
 516 | };
 517 | 
 518 | PatchByte joypatch_81_71[] = {
 519 | 	{ 0x1cf0f7, 0x53, 0xb8 },
 520 | 	{ 0x1cf0f8, 0x6a, 0xa5 },
 521 | 	{ 0x1cf0fa, 0xe8, 0x0 },
 522 | 	{ 0x1cf0fb, 0x9, 0x0 },
 523 | 	{ 0x1cf0fc, 0xa1, 0x90 },
 524 | 	{ 0x1cf0fd, 0xf3, 0x90 },
 525 | 	{ 0x1cf0fe, 0xff, 0x90 },
 526 | 	{ 0x1cf1f8, 0x53, 0xb8 },
 527 | 	{ 0x1cf1f9, 0x6a, 0xa5 },
 528 | 	{ 0x1cf1fa, 0x1, 0x0 },
 529 | 	{ 0x1cf1fb, 0xe8, 0x0 },
 530 | 	{ 0x1cf1fc, 0x8, 0x0 },
 531 | 	{ 0x1cf1fd, 0xa0, 0x90 },
 532 | 	{ 0x1cf1fe, 0xf3, 0x90 },
 533 | 	{ 0x1cf1ff, 0xff, 0x90 },
 534 | 	{ 0x20a821, 0x50, 0xb8 },
 535 | 	{ 0x20a822, 0x53, 0xa5 },
 536 | 	{ 0x20a823, 0xe8, 0x0 },
 537 | 	{ 0x20a824, 0xd8, 0x0 },
 538 | 	{ 0x20a825, 0xe9, 0x0 },
 539 | 	{ 0x20a826, 0xef, 0x90 },
 540 | 	{ 0x20a827, 0xff, 0x90 },
 541 | 	{ 0x20a881, 0x50, 0xb8 },
 542 | 	{ 0x20a882, 0x56, 0xa5 },
 543 | 	{ 0x20a883, 0xe8, 0x0 },
 544 | 	{ 0x20a884, 0x78, 0x0 },
 545 | 	{ 0x20a885, 0xe9, 0x0 },
 546 | 	{ 0x20a886, 0xef, 0x90 },
 547 | 	{ 0x20a887, 0xff, 0x90 },
 548 | 	{ 0x20a928, 0x50, 0xb8 },
 549 | 	{ 0x20a929, 0x56, 0xa5 },
 550 | 	{ 0x20a92a, 0xe8, 0x0 },
 551 | 	{ 0x20a92b, 0xc9, 0x0 },
 552 | 	{ 0x20a92c, 0xe8, 0x0 },
 553 | 	{ 0x20a92d, 0xef, 0x90 },
 554 | 	{ 0x20a92e, 0xff, 0x90 },
 555 | 	{ 0x20a994, 0x50, 0xb8 },
 556 | 	{ 0x20a995, 0x56, 0xa5 },
 557 | 	{ 0x20a996, 0xe8, 0x0 },
 558 | 	{ 0x20a997, 0x5d, 0x0 },
 559 | 	{ 0x20a998, 0xe8, 0x0 },
 560 | 	{ 0x20a999, 0xef, 0x90 },
 561 | 	{ 0x20a99a, 0xff, 0x90 },
 562 | 	{ 0x20aa0c, 0x50, 0xb8 },
 563 | 	{ 0x20aa0d, 0x56, 0xa5 },
 564 | 	{ 0x20aa0e, 0xe8, 0x0 },
 565 | 	{ 0x20aa0f, 0xe5, 0x0 },
 566 | 	{ 0x20aa10, 0xe7, 0x0 },
 567 | 	{ 0x20aa11, 0xef, 0x90 },
 568 | 	{ 0x20aa12, 0xff, 0x90 },
 569 | 	{ 0x20aa84, 0x50, 0xb8 },
 570 | 	{ 0x20aa85, 0x56, 0xa5 },
 571 | 	{ 0x20aa86, 0xe8, 0x0 },
 572 | 	{ 0x20aa87, 0x6d, 0x0 },
 573 | 	{ 0x20aa88, 0xe7, 0x0 },
 574 | 	{ 0x20aa89, 0xef, 0x90 },
 575 | 	{ 0x20aa8a, 0xff, 0x90 },
 576 | 	{ 0x20ab00, 0x50, 0xb8 },
 577 | 	{ 0x20ab01, 0x56, 0xa5 },
 578 | 	{ 0x20ab02, 0xe8, 0x0 },
 579 | 	{ 0x20ab03, 0x1, 0x0 },
 580 | 	{ 0x20ab04, 0xe7, 0x0 },
 581 | 	{ 0x20ab05, 0xef, 0x90 },
 582 | 	{ 0x20ab06, 0xff, 0x90 },
 583 | 	{ 0x20af67, 0x50, 0xb8 },
 584 | 	{ 0x20af68, 0x56, 0xa5 },
 585 | 	{ 0x20af69, 0xe8, 0x0 },
 586 | 	{ 0x20af6a, 0x9a, 0x0 },
 587 | 	{ 0x20af6b, 0xe2, 0x0 },
 588 | 	{ 0x20af6c, 0xef, 0x90 },
 589 | 	{ 0x20af6d, 0xff, 0x90 },
 590 | 	{ 0x20afe7, 0x50, 0xb8 },
 591 | 	{ 0x20afe8, 0x56, 0xa5 },
 592 | 	{ 0x20afe9, 0xe8, 0x0 },
 593 | 	{ 0x20afea, 0x1a, 0x0 },
 594 | 	{ 0x20afeb, 0xe2, 0x0 },
 595 | 	{ 0x20afec, 0xef, 0x90 },
 596 | 	{ 0x20afed, 0xff, 0x90 },
 597 | 	{ 0x20b067, 0x50, 0xb8 },
 598 | 	{ 0x20b068, 0x56, 0xa5 },
 599 | 	{ 0x20b069, 0xe8, 0x0 },
 600 | 	{ 0x20b06a, 0x9a, 0x0 },
 601 | 	{ 0x20b06b, 0xe1, 0x0 },
 602 | 	{ 0x20b06c, 0xef, 0x90 },
 603 | 	{ 0x20b06d, 0xff, 0x90 },
 604 | 	{ 0x20b0e7, 0x50, 0xb8 },
 605 | 	{ 0x20b0e8, 0x56, 0xa5 },
 606 | 	{ 0x20b0e9, 0xe8, 0x0 },
 607 | 	{ 0x20b0ea, 0x1a, 0x0 },
 608 | 	{ 0x20b0eb, 0xe1, 0x0 },
 609 | 	{ 0x20b0ec, 0xef, 0x90 },
 610 | 	{ 0x20b0ed, 0xff, 0x90 },
 611 | 	{ 0x20b167, 0x50, 0xb8 },
 612 | 	{ 0x20b168, 0x56, 0xa5 },
 613 | 	{ 0x20b169, 0xe8, 0x0 },
 614 | 	{ 0x20b16a, 0x9a, 0x0 },
 615 | 	{ 0x20b16b, 0xe0, 0x0 },
 616 | 	{ 0x20b16c, 0xef, 0x90 },
 617 | 	{ 0x20b16d, 0xff, 0x90 },
 618 | 	{ 0x20b1e7, 0x50, 0xb8 },
 619 | 	{ 0x20b1e8, 0x56, 0xa5 },
 620 | 	{ 0x20b1e9, 0xe8, 0x0 },
 621 | 	{ 0x20b1ea, 0x1a, 0x0 },
 622 | 	{ 0x20b1eb, 0xe0, 0x0 },
 623 | 	{ 0x20b1ec, 0xef, 0x90 },
 624 | 	{ 0x20b1ed, 0xff, 0x90 },
 625 | 	{ 0x20b26b, 0x50, 0xb8 },
 626 | 	{ 0x20b26c, 0x56, 0xa5 },
 627 | 	{ 0x20b26d, 0xe8, 0x0 },
 628 | 	{ 0x20b26e, 0x96, 0x0 },
 629 | 	{ 0x20b26f, 0xdf, 0x0 },
 630 | 	{ 0x20b270, 0xef, 0x90 },
 631 | 	{ 0x20b271, 0xff, 0x90 },
 632 | 	{-1,0,0}
 633 | };
 634 | 
 635 | PatchByte joypatch_81_91[] = {
 636 | 	    { 0x1c1fe3, 0x53, 0xb8 },
 637 |     { 0x1c1fe4, 0x6a, 0xa5 },
 638 |     { 0x1c1fe6, 0xe8, 0x0 },
 639 |     { 0x1c1fe7, 0xfd, 0x0 },
 640 |     { 0x1c1fe8, 0x72, 0x90 },
 641 |     { 0x1c1fe9, 0xf4, 0x90 },
 642 |     { 0x1c1fea, 0xff, 0x90 },
 643 |     { 0x1c20e4, 0x53, 0xb8 },
 644 |     { 0x1c20e5, 0x6a, 0xa5 },
 645 |     { 0x1c20e6, 0x1, 0x0 },
 646 |     { 0x1c20e7, 0xe8, 0x0 },
 647 |     { 0x1c20e8, 0xfc, 0x0 },
 648 |     { 0x1c20e9, 0x71, 0x90 },
 649 |     { 0x1c20ea, 0xf4, 0x90 },
 650 |     { 0x1c20eb, 0xff, 0x90 },
 651 |     { 0x20c761, 0x50, 0xb8 },
 652 |     { 0x20c762, 0x53, 0xa5 },
 653 |     { 0x20c763, 0xe8, 0x0 },
 654 |     { 0x20c764, 0x78, 0x0 },
 655 |     { 0x20c765, 0xcb, 0x0 },
 656 |     { 0x20c766, 0xef, 0x90 },
 657 |     { 0x20c767, 0xff, 0x90 },
 658 |     { 0x20c7c1, 0x50, 0xb8 },
 659 |     { 0x20c7c2, 0x56, 0xa5 },
 660 |     { 0x20c7c3, 0xe8, 0x0 },
 661 |     { 0x20c7c4, 0x18, 0x0 },
 662 |     { 0x20c7c5, 0xcb, 0x0 },
 663 |     { 0x20c7c6, 0xef, 0x90 },
 664 |     { 0x20c7c7, 0xff, 0x90 },
 665 |     { 0x20c85d, 0x68, 0xb8 },
 666 |     { 0x20c85e, 0xd8, 0xa5 },
 667 |     { 0x20c85f, 0x2, 0x0 },
 668 |     { 0x20c862, 0x8d, 0x90 },
 669 |     { 0x20c863, 0x85, 0x90 },
 670 |     { 0x20c864, 0x28, 0x90 },
 671 |     { 0x20c865, 0xfd, 0x90 },
 672 |     { 0x20c866, 0xff, 0x90 },
 673 |     { 0x20c867, 0xff, 0x90 },
 674 |     { 0x20c868, 0x50, 0x90 },
 675 |     { 0x20c869, 0x56, 0x90 },
 676 |     { 0x20c86a, 0xe8, 0x90 },
 677 |     { 0x20c86b, 0x69, 0x90 },
 678 |     { 0x20c86c, 0xca, 0x90 },
 679 |     { 0x20c86d, 0xef, 0x90 },
 680 |     { 0x20c86e, 0xff, 0x90 },
 681 |     { 0x20c8c9, 0x68, 0xb8 },
 682 |     { 0x20c8ca, 0xd8, 0xa5 },
 683 |     { 0x20c8cb, 0x2, 0x0 },
 684 |     { 0x20c8ce, 0x8d, 0x90 },
 685 |     { 0x20c8cf, 0x85, 0x90 },
 686 |     { 0x20c8d0, 0x28, 0x90 },
 687 |     { 0x20c8d1, 0xfd, 0x90 },
 688 |     { 0x20c8d2, 0xff, 0x90 },
 689 |     { 0x20c8d3, 0xff, 0x90 },
 690 |     { 0x20c8d4, 0x50, 0x90 },
 691 |     { 0x20c8d5, 0x56, 0x90 },
 692 |     { 0x20c8d6, 0xe8, 0x90 },
 693 |     { 0x20c8d7, 0xfd, 0x90 },
 694 |     { 0x20c8d8, 0xc9, 0x90 },
 695 |     { 0x20c8d9, 0xef, 0x90 },
 696 |     { 0x20c8da, 0xff, 0x90 },
 697 |     { 0x20c941, 0x68, 0xb8 },
 698 |     { 0x20c942, 0xd8, 0xa5 },
 699 |     { 0x20c943, 0x2, 0x0 },
 700 |     { 0x20c946, 0x8d, 0x90 },
 701 |     { 0x20c947, 0x85, 0x90 },
 702 |     { 0x20c948, 0x28, 0x90 },
 703 |     { 0x20c949, 0xfd, 0x90 },
 704 |     { 0x20c94a, 0xff, 0x90 },
 705 |     { 0x20c94b, 0xff, 0x90 },
 706 |     { 0x20c94c, 0x50, 0x90 },
 707 |     { 0x20c94d, 0x56, 0x90 },
 708 |     { 0x20c94e, 0xe8, 0x90 },
 709 |     { 0x20c94f, 0x85, 0x90 },
 710 |     { 0x20c950, 0xc9, 0x90 },
 711 |     { 0x20c951, 0xef, 0x90 },
 712 |     { 0x20c952, 0xff, 0x90 },
 713 |     { 0x20c9b9, 0x68, 0xb8 },
 714 |     { 0x20c9ba, 0xd8, 0xa5 },
 715 |     { 0x20c9bb, 0x2, 0x0 },
 716 |     { 0x20c9be, 0x8d, 0x90 },
 717 |     { 0x20c9bf, 0x85, 0x90 },
 718 |     { 0x20c9c0, 0x28, 0x90 },
 719 |     { 0x20c9c1, 0xfd, 0x90 },
 720 |     { 0x20c9c2, 0xff, 0x90 },
 721 |     { 0x20c9c3, 0xff, 0x90 },
 722 |     { 0x20c9c4, 0x50, 0x90 },
 723 |     { 0x20c9c5, 0x56, 0x90 },
 724 |     { 0x20c9c6, 0xe8, 0x90 },
 725 |     { 0x20c9c7, 0xd, 0x90 },
 726 |     { 0x20c9c8, 0xc9, 0x90 },
 727 |     { 0x20c9c9, 0xef, 0x90 },
 728 |     { 0x20c9ca, 0xff, 0x90 },
 729 |     { 0x20ca40, 0x50, 0xb8 },
 730 |     { 0x20ca41, 0x56, 0xa5 },
 731 |     { 0x20ca42, 0xe8, 0x0 },
 732 |     { 0x20ca43, 0xa1, 0x0 },
 733 |     { 0x20ca44, 0xc8, 0x0 },
 734 |     { 0x20ca45, 0xef, 0x90 },
 735 |     { 0x20ca46, 0xff, 0x90 },
 736 |     { 0x20cea7, 0x50, 0xb8 },
 737 |     { 0x20cea8, 0x56, 0xa5 },
 738 |     { 0x20cea9, 0xe8, 0x0 },
 739 |     { 0x20ceaa, 0x3a, 0x0 },
 740 |     { 0x20ceab, 0xc4, 0x0 },
 741 |     { 0x20ceac, 0xef, 0x90 },
 742 |     { 0x20cead, 0xff, 0x90 },
 743 |     { 0x20cf27, 0x50, 0xb8 },
 744 |     { 0x20cf28, 0x56, 0xa5 },
 745 |     { 0x20cf29, 0xe8, 0x0 },
 746 |     { 0x20cf2a, 0xba, 0x0 },
 747 |     { 0x20cf2b, 0xc3, 0x0 },
 748 |     { 0x20cf2c, 0xef, 0x90 },
 749 |     { 0x20cf2d, 0xff, 0x90 },
 750 |     { 0x20cfa7, 0x50, 0xb8 },
 751 |     { 0x20cfa8, 0x56, 0xa5 },
 752 |     { 0x20cfa9, 0xe8, 0x0 },
 753 |     { 0x20cfaa, 0x3a, 0x0 },
 754 |     { 0x20cfab, 0xc3, 0x0 },
 755 |     { 0x20cfac, 0xef, 0x90 },
 756 |     { 0x20cfad, 0xff, 0x90 },
 757 |     { 0x20d027, 0x50, 0xb8 },
 758 |     { 0x20d028, 0x56, 0xa5 },
 759 |     { 0x20d029, 0xe8, 0x0 },
 760 |     { 0x20d02a, 0xba, 0x0 },
 761 |     { 0x20d02b, 0xc2, 0x0 },
 762 |     { 0x20d02c, 0xef, 0x90 },
 763 |     { 0x20d02d, 0xff, 0x90 },
 764 |     { 0x20d0a7, 0x50, 0xb8 },
 765 |     { 0x20d0a8, 0x56, 0xa5 },
 766 |     { 0x20d0a9, 0xe8, 0x0 },
 767 |     { 0x20d0aa, 0x3a, 0x0 },
 768 |     { 0x20d0ab, 0xc2, 0x0 },
 769 |     { 0x20d0ac, 0xef, 0x90 },
 770 |     { 0x20d0ad, 0xff, 0x90 },
 771 |     { 0x20d127, 0x50, 0xb8 },
 772 |     { 0x20d128, 0x56, 0xa5 },
 773 |     { 0x20d129, 0xe8, 0x0 },
 774 |     { 0x20d12a, 0xba, 0x0 },
 775 |     { 0x20d12b, 0xc1, 0x0 },
 776 |     { 0x20d12c, 0xef, 0x90 },
 777 |     { 0x20d12d, 0xff, 0x90 },
 778 |     { 0x20d1ab, 0x50, 0xb8 },
 779 |     { 0x20d1ac, 0x56, 0xa5 },
 780 |     { 0x20d1ad, 0xe8, 0x0 },
 781 |     { 0x20d1ae, 0x36, 0x0 },
 782 |     { 0x20d1af, 0xc1, 0x0 },
 783 |     { 0x20d1b0, 0xef, 0x90 },
 784 |     { 0x20d1b1, 0xff, 0x90 },
 785 | 	{-1,0,0}
 786 | };
 787 | 
 788 | PatchByte joypatch_81_135[] = {
 789 | 	{ 0x1c5eb3, 0x53, 0xb8 },
 790 | 	{ 0x1c5eb4, 0x6a, 0xa5 },
 791 | 	{ 0x1c5eb6, 0xe8, 0x00 },
 792 | 	{ 0x1c5eb7, 0x61, 0x00 },
 793 | 	{ 0x1c5eb8, 0x67, 0x90 },
 794 | 	{ 0x1c5eb9, 0xf4, 0x90 },
 795 | 	{ 0x1c5eba, 0xff, 0x90 },
 796 | 	{ 0x1c5fb4, 0x53, 0xb8 },
 797 | 	{ 0x1c5fb5, 0x6a, 0xa5 },
 798 | 	{ 0x1c5fb6, 0x01, 0x00 },
 799 | 	{ 0x1c5fb7, 0xe8, 0x00 },
 800 | 	{ 0x1c5fb8, 0x60, 0x00 },
 801 | 	{ 0x1c5fb9, 0x66, 0x90 },
 802 | 	{ 0x1c5fba, 0xf4, 0x90 },
 803 | 	{ 0x1c5fbb, 0xff, 0x90 },
 804 | 	{ 0x212f59, 0x50, 0xb8 },
 805 | 	{ 0x212f5a, 0x53, 0xa5 },
 806 | 	{ 0x212f5b, 0xe8, 0x00 },
 807 | 	{ 0x212f5c, 0xb4, 0x00 },
 808 | 	{ 0x212f5d, 0x96, 0x00 },
 809 | 	{ 0x212f5e, 0xef, 0x90 },
 810 | 	{ 0x212f5f, 0xff, 0x90 },
 811 | 	{ 0x212fb9, 0x50, 0xb8 },
 812 | 	{ 0x212fba, 0x56, 0xa5 },
 813 | 	{ 0x212fbb, 0xe8, 0x00 },
 814 | 	{ 0x212fbc, 0x54, 0x00 },
 815 | 	{ 0x212fbd, 0x96, 0x00 },
 816 | 	{ 0x212fbe, 0xef, 0x90 },
 817 | 	{ 0x212fbf, 0xff, 0x90 },
 818 | 	{ 0x21305e, 0x50, 0xb8 },
 819 | 	{ 0x21305f, 0x56, 0xa5 },
 820 | 	{ 0x213060, 0xe8, 0x00 },
 821 | 	{ 0x213061, 0xa7, 0x00 },
 822 | 	{ 0x213062, 0x95, 0x00 },
 823 | 	{ 0x213063, 0xef, 0x90 },
 824 | 	{ 0x213064, 0xff, 0x90 },
 825 | 	{ 0x2130d0, 0x50, 0xb8 },
 826 | 	{ 0x2130d1, 0x56, 0xa5 },
 827 | 	{ 0x2130d2, 0xe8, 0x00 },
 828 | 	{ 0x2130d3, 0x35, 0x00 },
 829 | 	{ 0x2130d4, 0x95, 0x00 },
 830 | 	{ 0x2130d5, 0xef, 0x90 },
 831 | 	{ 0x2130d6, 0xff, 0x90 },
 832 | 	{ 0x213148, 0x50, 0xb8 },
 833 | 	{ 0x213149, 0x56, 0xa5 },
 834 | 	{ 0x21314a, 0xe8, 0x00 },
 835 | 	{ 0x21314b, 0xbd, 0x00 },
 836 | 	{ 0x21314c, 0x94, 0x00 },
 837 | 	{ 0x21314d, 0xef, 0x90 },
 838 | 	{ 0x21314e, 0xff, 0x90 },
 839 | 	{ 0x2131c0, 0x50, 0xb8 },
 840 | 	{ 0x2131c1, 0x56, 0xa5 },
 841 | 	{ 0x2131c2, 0xe8, 0x00 },
 842 | 	{ 0x2131c3, 0x45, 0x00 },
 843 | 	{ 0x2131c4, 0x94, 0x00 },
 844 | 	{ 0x2131c5, 0xef, 0x90 },
 845 | 	{ 0x2131c6, 0xff, 0x90 },
 846 | 	{ 0x21323c, 0x50, 0xb8 },
 847 | 	{ 0x21323d, 0x56, 0xa5 },
 848 | 	{ 0x21323e, 0xe8, 0x00 },
 849 | 	{ 0x21323f, 0xd9, 0x00 },
 850 | 	{ 0x213240, 0x93, 0x00 },
 851 | 	{ 0x213241, 0xef, 0x90 },
 852 | 	{ 0x213242, 0xff, 0x90 },
 853 | 	{ 0x2136a3, 0x50, 0xb8 },
 854 | 	{ 0x2136a4, 0x56, 0xa5 },
 855 | 	{ 0x2136a5, 0xe8, 0x00 },
 856 | 	{ 0x2136a6, 0x72, 0x00 },
 857 | 	{ 0x2136a7, 0x8f, 0x00 },
 858 | 	{ 0x2136a8, 0xef, 0x90 },
 859 | 	{ 0x2136a9, 0xff, 0x90 },
 860 | 	{ 0x213723, 0x50, 0xb8 },
 861 | 	{ 0x213724, 0x56, 0xa5 },
 862 | 	{ 0x213725, 0xe8, 0x00 },
 863 | 	{ 0x213726, 0xf2, 0x00 },
 864 | 	{ 0x213727, 0x8e, 0x00 },
 865 | 	{ 0x213728, 0xef, 0x90 },
 866 | 	{ 0x213729, 0xff, 0x90 },
 867 | 	{ 0x2137a3, 0x50, 0xb8 },
 868 | 	{ 0x2137a4, 0x56, 0xa5 },
 869 | 	{ 0x2137a5, 0xe8, 0x00 },
 870 | 	{ 0x2137a6, 0x72, 0x00 },
 871 | 	{ 0x2137a7, 0x8e, 0x00 },
 872 | 	{ 0x2137a8, 0xef, 0x90 },
 873 | 	{ 0x2137a9, 0xff, 0x90 },
 874 | 	{ 0x213823, 0x50, 0xb8 },
 875 | 	{ 0x213824, 0x56, 0xa5 },
 876 | 	{ 0x213825, 0xe8, 0x00 },
 877 | 	{ 0x213826, 0xf2, 0x00 },
 878 | 	{ 0x213827, 0x8d, 0x00 },
 879 | 	{ 0x213828, 0xef, 0x90 },
 880 | 	{ 0x213829, 0xff, 0x90 },
 881 | 	{ 0x2138a3, 0x50, 0xb8 },
 882 | 	{ 0x2138a4, 0x56, 0xa5 },
 883 | 	{ 0x2138a5, 0xe8, 0x00 },
 884 | 	{ 0x2138a6, 0x72, 0x00 },
 885 | 	{ 0x2138a7, 0x8d, 0x00 },
 886 | 	{ 0x2138a8, 0xef, 0x90 },
 887 | 	{ 0x2138a9, 0xff, 0x90 },
 888 | 	{ 0x213923, 0x50, 0xb8 },
 889 | 	{ 0x213924, 0x56, 0xa5 },
 890 | 	{ 0x213925, 0xe8, 0x00 },
 891 | 	{ 0x213926, 0xf2, 0x00 },
 892 | 	{ 0x213927, 0x8c, 0x00 },
 893 | 	{ 0x213928, 0xef, 0x90 },
 894 | 	{ 0x213929, 0xff, 0x90 },
 895 | 	{ 0x2139a7, 0x50, 0xb8 },
 896 | 	{ 0x2139a8, 0x56, 0xa5 },
 897 | 	{ 0x2139a9, 0xe8, 0x00 },
 898 | 	{ 0x2139aa, 0x6e, 0x00 },
 899 | 	{ 0x2139ab, 0x8c, 0x00 },
 900 | 	{ 0x2139ac, 0xef, 0x90 },
 901 | 	{ 0x2139ad, 0xff, 0x90 },
 902 | 	{-1,0,0}
 903 | };
 904 | 
 905 | PatchByte joypatch_81_140[] = {
 906 | 	{ 0x1f6cdb, 0x53, 0xb8 },
 907 | 	{ 0x1f6cdc, 0x6a, 0xa5 },
 908 | 	{ 0x1f6cde, 0xe8, 0x0 },
 909 | 	{ 0x1f6cdf, 0x39, 0x0 },
 910 | 	{ 0x1f6ce0, 0x59, 0x90 },
 911 | 	{ 0x1f6ce1, 0xf1, 0x90 },
 912 | 	{ 0x1f6ce2, 0xff, 0x90 },
 913 | 	{ 0x1f6ddc, 0x53, 0xb8 },
 914 | 	{ 0x1f6ddd, 0x6a, 0xa5 },
 915 | 	{ 0x1f6dde, 0x1, 0x0 },
 916 | 	{ 0x1f6ddf, 0xe8, 0x0 },
 917 | 	{ 0x1f6de0, 0x38, 0x0 },
 918 | 	{ 0x1f6de1, 0x58, 0x90 },
 919 | 	{ 0x1f6de2, 0xf1, 0x90 },
 920 | 	{ 0x1f6de3, 0xff, 0x90 },
 921 | 	{ 0x2444e1, 0x50, 0xb8 },
 922 | 	{ 0x2444e2, 0x53, 0xa5 },
 923 | 	{ 0x2444e3, 0xe8, 0x0 },
 924 | 	{ 0x2444e4, 0x2c, 0x0 },
 925 | 	{ 0x2444e5, 0x81, 0x0 },
 926 | 	{ 0x2444e6, 0xec, 0x90 },
 927 | 	{ 0x2444e7, 0xff, 0x90 },
 928 | 	{ 0x244541, 0x50, 0xb8 },
 929 | 	{ 0x244542, 0x56, 0xa5 },
 930 | 	{ 0x244543, 0xe8, 0x0 },
 931 | 	{ 0x244544, 0xcc, 0x0 },
 932 | 	{ 0x244545, 0x80, 0x0 },
 933 | 	{ 0x244546, 0xec, 0x90 },
 934 | 	{ 0x244547, 0xff, 0x90 },
 935 | 	{ 0x2445e6, 0x50, 0xb8 },
 936 | 	{ 0x2445e7, 0x56, 0xa5 },
 937 | 	{ 0x2445e8, 0xe8, 0x0 },
 938 | 	{ 0x2445e9, 0x1f, 0x0 },
 939 | 	{ 0x2445ea, 0x80, 0x0 },
 940 | 	{ 0x2445eb, 0xec, 0x90 },
 941 | 	{ 0x2445ec, 0xff, 0x90 },
 942 | 	{ 0x244658, 0x50, 0xb8 },
 943 | 	{ 0x244659, 0x56, 0xa5 },
 944 | 	{ 0x24465a, 0xe8, 0x0 },
 945 | 	{ 0x24465b, 0xad, 0x0 },
 946 | 	{ 0x24465c, 0x7f, 0x0 },
 947 | 	{ 0x24465d, 0xec, 0x90 },
 948 | 	{ 0x24465e, 0xff, 0x90 },
 949 | 	{ 0x2446d0, 0x50, 0xb8 },
 950 | 	{ 0x2446d1, 0x56, 0xa5 },
 951 | 	{ 0x2446d2, 0xe8, 0x0 },
 952 | 	{ 0x2446d3, 0x35, 0x0 },
 953 | 	{ 0x2446d4, 0x7f, 0x0 },
 954 | 	{ 0x2446d5, 0xec, 0x90 },
 955 | 	{ 0x2446d6, 0xff, 0x90 },
 956 | 	{ 0x244748, 0x50, 0xb8 },
 957 | 	{ 0x244749, 0x56, 0xa5 },
 958 | 	{ 0x24474a, 0xe8, 0x0 },
 959 | 	{ 0x24474b, 0xbd, 0x0 },
 960 | 	{ 0x24474c, 0x7e, 0x0 },
 961 | 	{ 0x24474d, 0xec, 0x90 },
 962 | 	{ 0x24474e, 0xff, 0x90 },
 963 | 	{ 0x2447c4, 0x50, 0xb8 },
 964 | 	{ 0x2447c5, 0x56, 0xa5 },
 965 | 	{ 0x2447c6, 0xe8, 0x0 },
 966 | 	{ 0x2447c7, 0x51, 0x0 },
 967 | 	{ 0x2447c8, 0x7e, 0x0 },
 968 | 	{ 0x2447c9, 0xec, 0x90 },
 969 | 	{ 0x2447ca, 0xff, 0x90 },
 970 | 	{ 0x244c2b, 0x50, 0xb8 },
 971 | 	{ 0x244c2c, 0x56, 0xa5 },
 972 | 	{ 0x244c2d, 0xe8, 0x0 },
 973 | 	{ 0x244c2e, 0xea, 0x0 },
 974 | 	{ 0x244c2f, 0x79, 0x0 },
 975 | 	{ 0x244c30, 0xec, 0x90 },
 976 | 	{ 0x244c31, 0xff, 0x90 },
 977 | 	{ 0x244cab, 0x50, 0xb8 },
 978 | 	{ 0x244cac, 0x56, 0xa5 },
 979 | 	{ 0x244cad, 0xe8, 0x0 },
 980 | 	{ 0x244cae, 0x6a, 0x0 },
 981 | 	{ 0x244caf, 0x79, 0x0 },
 982 | 	{ 0x244cb0, 0xec, 0x90 },
 983 | 	{ 0x244cb1, 0xff, 0x90 },
 984 | 	{ 0x244d2b, 0x50, 0xb8 },
 985 | 	{ 0x244d2c, 0x56, 0xa5 },
 986 | 	{ 0x244d2d, 0xe8, 0x0 },
 987 | 	{ 0x244d2e, 0xea, 0x0 },
 988 | 	{ 0x244d2f, 0x78, 0x0 },
 989 | 	{ 0x244d30, 0xec, 0x90 },
 990 | 	{ 0x244d31, 0xff, 0x90 },
 991 | 	{ 0x244dab, 0x50, 0xb8 },
 992 | 	{ 0x244dac, 0x56, 0xa5 },
 993 | 	{ 0x244dad, 0xe8, 0x0 },
 994 | 	{ 0x244dae, 0x6a, 0x0 },
 995 | 	{ 0x244daf, 0x78, 0x0 },
 996 | 	{ 0x244db0, 0xec, 0x90 },
 997 | 	{ 0x244db1, 0xff, 0x90 },
 998 | 	{ 0x244e2b, 0x50, 0xb8 },
 999 | 	{ 0x244e2c, 0x56, 0xa5 },
1000 | 	{ 0x244e2d, 0xe8, 0x0 },
1001 | 	{ 0x244e2e, 0xea, 0x0 },
1002 | 	{ 0x244e2f, 0x77, 0x0 },
1003 | 	{ 0x244e30, 0xec, 0x90 },
1004 | 	{ 0x244e31, 0xff, 0x90 },
1005 | 	{ 0x244eab, 0x50, 0xb8 },
1006 | 	{ 0x244eac, 0x56, 0xa5 },
1007 | 	{ 0x244ead, 0xe8, 0x0 },
1008 | 	{ 0x244eae, 0x6a, 0x0 },
1009 | 	{ 0x244eaf, 0x77, 0x0 },
1010 | 	{ 0x244eb0, 0xec, 0x90 },
1011 | 	{ 0x244eb1, 0xff, 0x90 },
1012 | 	{ 0x244f2f, 0x50, 0xb8 },
1013 | 	{ 0x244f30, 0x56, 0xa5 },
1014 | 	{ 0x244f31, 0xe8, 0x0 },
1015 | 	{ 0x244f32, 0xe6, 0x0 },
1016 | 	{ 0x244f33, 0x76, 0x0 },
1017 | 	{ 0x244f34, 0xec, 0x90 },
1018 | 	{ 0x244f35, 0xff, 0x90 },
1019 | 	{-1,0,0}
1020 | };
1021 | 
1022 | PatchByte joypatch_81_141[] = {
1023 | 	{ 0x1f6ce7, 0x53, 0xb8 },
1024 | 	{ 0x1f6ce8, 0x6a, 0xa5 },
1025 | 	{ 0x1f6cea, 0xe8, 0x0 },
1026 | 	{ 0x1f6ceb, 0x2d, 0x0 },
1027 | 	{ 0x1f6cec, 0x59, 0x90 },
1028 | 	{ 0x1f6ced, 0xf1, 0x90 },
1029 | 	{ 0x1f6cee, 0xff, 0x90 },
1030 | 	{ 0x1f6de8, 0x53, 0xb8 },
1031 | 	{ 0x1f6de9, 0x6a, 0xa5 },
1032 | 	{ 0x1f6dea, 0x1, 0x0 },
1033 | 	{ 0x1f6deb, 0xe8, 0x0 },
1034 | 	{ 0x1f6dec, 0x2c, 0x0 },
1035 | 	{ 0x1f6ded, 0x58, 0x90 },
1036 | 	{ 0x1f6dee, 0xf1, 0x90 },
1037 | 	{ 0x1f6def, 0xff, 0x90 },
1038 | 	{ 0x244711, 0x50, 0xb8 },
1039 | 	{ 0x244712, 0x53, 0xa5 },
1040 | 	{ 0x244713, 0xe8, 0x0 },
1041 | 	{ 0x244714, 0xfc, 0x0 },
1042 | 	{ 0x244715, 0x7e, 0x0 },
1043 | 	{ 0x244716, 0xec, 0x90 },
1044 | 	{ 0x244717, 0xff, 0x90 },
1045 | 	{ 0x244771, 0x50, 0xb8 },
1046 | 	{ 0x244772, 0x56, 0xa5 },
1047 | 	{ 0x244773, 0xe8, 0x0 },
1048 | 	{ 0x244774, 0x9c, 0x0 },
1049 | 	{ 0x244775, 0x7e, 0x0 },
1050 | 	{ 0x244776, 0xec, 0x90 },
1051 | 	{ 0x244777, 0xff, 0x90 },
1052 | 	{ 0x24480b, 0x68, 0xb8 },
1053 | 	{ 0x24480c, 0xd8, 0xa5 },
1054 | 	{ 0x24480d, 0x2, 0x0 },
1055 | 	{ 0x244810, 0x8d, 0x90 },
1056 | 	{ 0x244811, 0x85, 0x90 },
1057 | 	{ 0x244812, 0x28, 0x90 },
1058 | 	{ 0x244813, 0xfd, 0x90 },
1059 | 	{ 0x244814, 0xff, 0x90 },
1060 | 	{ 0x244815, 0xff, 0x90 },
1061 | 	{ 0x244816, 0x50, 0x90 },
1062 | 	{ 0x244817, 0x56, 0x90 },
1063 | 	{ 0x244818, 0xe8, 0x90 },
1064 | 	{ 0x244819, 0xef, 0x90 },
1065 | 	{ 0x24481a, 0x7d, 0x90 },
1066 | 	{ 0x24481b, 0xec, 0x90 },
1067 | 	{ 0x24481c, 0xff, 0x90 },
1068 | 	{ 0x24487d, 0x68, 0xb8 },
1069 | 	{ 0x24487e, 0xd8, 0xa5 },
1070 | 	{ 0x24487f, 0x2, 0x0 },
1071 | 	{ 0x244882, 0x8d, 0x90 },
1072 | 	{ 0x244883, 0x85, 0x90 },
1073 | 	{ 0x244884, 0x28, 0x90 },
1074 | 	{ 0x244885, 0xfd, 0x90 },
1075 | 	{ 0x244886, 0xff, 0x90 },
1076 | 	{ 0x244887, 0xff, 0x90 },
1077 | 	{ 0x244888, 0x50, 0x90 },
1078 | 	{ 0x244889, 0x56, 0x90 },
1079 | 	{ 0x24488a, 0xe8, 0x90 },
1080 | 	{ 0x24488b, 0x7d, 0x90 },
1081 | 	{ 0x24488c, 0x7d, 0x90 },
1082 | 	{ 0x24488d, 0xec, 0x90 },
1083 | 	{ 0x24488e, 0xff, 0x90 },
1084 | 	{ 0x2448f5, 0x68, 0xb8 },
1085 | 	{ 0x2448f6, 0xd8, 0xa5 },
1086 | 	{ 0x2448f7, 0x2, 0x0 },
1087 | 	{ 0x2448fa, 0x8d, 0x90 },
1088 | 	{ 0x2448fb, 0x85, 0x90 },
1089 | 	{ 0x2448fc, 0x28, 0x90 },
1090 | 	{ 0x2448fd, 0xfd, 0x90 },
1091 | 	{ 0x2448fe, 0xff, 0x90 },
1092 | 	{ 0x2448ff, 0xff, 0x90 },
1093 | 	{ 0x244900, 0x50, 0x90 },
1094 | 	{ 0x244901, 0x56, 0x90 },
1095 | 	{ 0x244902, 0xe8, 0x90 },
1096 | 	{ 0x244903, 0x5, 0x90 },
1097 | 	{ 0x244904, 0x7d, 0x90 },
1098 | 	{ 0x244905, 0xec, 0x90 },
1099 | 	{ 0x244906, 0xff, 0x90 },
1100 | 	{ 0x24496d, 0x68, 0xb8 },
1101 | 	{ 0x24496e, 0xd8, 0xa5 },
1102 | 	{ 0x24496f, 0x2, 0x0 },
1103 | 	{ 0x244972, 0x8d, 0x90 },
1104 | 	{ 0x244973, 0x85, 0x90 },
1105 | 	{ 0x244974, 0x28, 0x90 },
1106 | 	{ 0x244975, 0xfd, 0x90 },
1107 | 	{ 0x244976, 0xff, 0x90 },
1108 | 	{ 0x244977, 0xff, 0x90 },
1109 | 	{ 0x244978, 0x50, 0x90 },
1110 | 	{ 0x244979, 0x56, 0x90 },
1111 | 	{ 0x24497a, 0xe8, 0x90 },
1112 | 	{ 0x24497b, 0x8d, 0x90 },
1113 | 	{ 0x24497c, 0x7c, 0x90 },
1114 | 	{ 0x24497d, 0xec, 0x90 },
1115 | 	{ 0x24497e, 0xff, 0x90 },
1116 | 	{ 0x2449f4, 0x50, 0xb8 },
1117 | 	{ 0x2449f5, 0x56, 0xa5 },
1118 | 	{ 0x2449f6, 0xe8, 0x0 },
1119 | 	{ 0x2449f7, 0x21, 0x0 },
1120 | 	{ 0x2449f8, 0x7c, 0x0 },
1121 | 	{ 0x2449f9, 0xec, 0x90 },
1122 | 	{ 0x2449fa, 0xff, 0x90 },
1123 | 	{ 0x244e5b, 0x50, 0xb8 },
1124 | 	{ 0x244e5c, 0x56, 0xa5 },
1125 | 	{ 0x244e5d, 0xe8, 0x0 },
1126 | 	{ 0x244e5e, 0xba, 0x0 },
1127 | 	{ 0x244e5f, 0x77, 0x0 },
1128 | 	{ 0x244e60, 0xec, 0x90 },
1129 | 	{ 0x244e61, 0xff, 0x90 },
1130 | 	{ 0x244edb, 0x50, 0xb8 },
1131 | 	{ 0x244edc, 0x56, 0xa5 },
1132 | 	{ 0x244edd, 0xe8, 0x0 },
1133 | 	{ 0x244ede, 0x3a, 0x0 },
1134 | 	{ 0x244edf, 0x77, 0x0 },
1135 | 	{ 0x244ee0, 0xec, 0x90 },
1136 | 	{ 0x244ee1, 0xff, 0x90 },
1137 | 	{ 0x244f5b, 0x50, 0xb8 },
1138 | 	{ 0x244f5c, 0x56, 0xa5 },
1139 | 	{ 0x244f5d, 0xe8, 0x0 },
1140 | 	{ 0x244f5e, 0xba, 0x0 },
1141 | 	{ 0x244f5f, 0x76, 0x0 },
1142 | 	{ 0x244f60, 0xec, 0x90 },
1143 | 	{ 0x244f61, 0xff, 0x90 },
1144 | 	{ 0x244fdb, 0x50, 0xb8 },
1145 | 	{ 0x244fdc, 0x56, 0xa5 },
1146 | 	{ 0x244fdd, 0xe8, 0x0 },
1147 | 	{ 0x244fde, 0x3a, 0x0 },
1148 | 	{ 0x244fdf, 0x76, 0x0 },
1149 | 	{ 0x244fe0, 0xec, 0x90 },
1150 | 	{ 0x244fe1, 0xff, 0x90 },
1151 | 	{ 0x24505b, 0x50, 0xb8 },
1152 | 	{ 0x24505c, 0x56, 0xa5 },
1153 | 	{ 0x24505d, 0xe8, 0x0 },
1154 | 	{ 0x24505e, 0xba, 0x0 },
1155 | 	{ 0x24505f, 0x75, 0x0 },
1156 | 	{ 0x245060, 0xec, 0x90 },
1157 | 	{ 0x245061, 0xff, 0x90 },
1158 | 	{ 0x2450db, 0x50, 0xb8 },
1159 | 	{ 0x2450dc, 0x56, 0xa5 },
1160 | 	{ 0x2450dd, 0xe8, 0x0 },
1161 | 	{ 0x2450de, 0x3a, 0x0 },
1162 | 	{ 0x2450df, 0x75, 0x0 },
1163 | 	{ 0x2450e0, 0xec, 0x90 },
1164 | 	{ 0x2450e1, 0xff, 0x90 },
1165 | 	{ 0x24515f, 0x50, 0xb8 },
1166 | 	{ 0x245160, 0x56, 0xa5 },
1167 | 	{ 0x245161, 0xe8, 0x0 },
1168 | 	{ 0x245162, 0xb6, 0x0 },
1169 | 	{ 0x245163, 0x74, 0x0 },
1170 | 	{ 0x245164, 0xec, 0x90 },
1171 | 	{ 0x245165, 0xff, 0x90 },
1172 | 	{-1,0,0}
1173 | };
1174 | 
1175 | // DPLAY PATCHES
1176 | // How to create:
1177 | // 1. Find L"DPlayX.dll"
1178 | // 2. Replace the 'D' with a null byte
1179 | 
1180 | PatchByte dplaypatch_70[] = {
1181 | 	{ 0x147980, 'D', 0 },
1182 | 	{ 0x147981, 'P', 'P' },
1183 | 	{ 0x147982, 'l', 'l' },
1184 | 	{ 0x147983, 'a', 'a' },
1185 | 	{ 0x147984, 'y', 'y' },
1186 | 	{ 0x147985, 'X', 'X' },
1187 | 	{-1,0,0}
1188 | };
1189 | 
1190 | PatchByte dplaypatch_80[] = {
1191 | 	{ 0x187380, 'D', 0 },
1192 | 	{ 0x187381, 'P', 'P' },
1193 | 	{ 0x187382, 'l', 'l' },
1194 | 	{ 0x187383, 'a', 'a' },
1195 | 	{ 0x187384, 'y', 'y' },
1196 | 	{ 0x187385, 'X', 'X' },
1197 | 	{-1,0,0}
1198 | };
1199 | 
1200 | PatchByte dplaypatch_81_65[] = {
1201 | 	{ 0x23d184, 'D', 0 },
1202 | 	{ 0x23d186, 'P', 'P' },
1203 | 	{ 0x23d188, 'l', 'l' },
1204 | 	{ 0x23d18a, 'a', 'a' },
1205 | 	{ 0x23d18c, 'y', 'y' },
1206 | 	{ 0x23d18e, 'X', 'X' },
1207 | 	{-1,0,0}
1208 | };
1209 | 
1210 | PatchByte dplaypatch_81_71[] = {
1211 | 	{0x23d384, 'D', 0},
1212 | 	{0x23d386, 'P', 'P'},
1213 | 	{0x23d388, 'l', 'l'},
1214 | 	{0x23d38a, 'a', 'a'},
1215 | 	{0x23d38c, 'y', 'y'},
1216 | 	{0x23d38e, 'X', 'X'},
1217 | 	{-1,0,0}
1218 | };
1219 | 
1220 | PatchByte dplaypatch_81_91[] = {
1221 | 	{0x23f1ac, 'D', 0},
1222 | 	{0x23f1ae, 'P', 'P'},
1223 | 	{0x23f1b0, 'l', 'l'},
1224 | 	{0x23f1b2, 'a', 'a'},
1225 | 	{0x23f1b4, 'y', 'y'},
1226 | 	{0x23f1b6, 'X', 'X'},
1227 | 	{-1,0,0}
1228 | };
1229 | 
1230 | PatchByte dplaypatch_81_135[] = {
1231 | 	{ 0x2761ac, 'D', 0 },
1232 | 	{ 0x2761ae, 'P', 'P' },
1233 | 	{ 0x2761b0, 'l', 'l' },
1234 | 	{ 0x2761b2, 'a', 'a' },
1235 | 	{ 0x2761b4, 'y', 'y' },
1236 | 	{ 0x2761b6, 'X', 'X' },
1237 | 	{-1,0,0}
1238 | };
1239 | 
1240 | PatchByte dplaypatch_81_140[] = {
1241 | 	{ 0x279a10, 'D', 0 },
1242 | 	{ 0x279a12, 'P', 'P' },
1243 | 	{ 0x279a14, 'l', 'l' },
1244 | 	{ 0x279a16, 'a', 'a' },
1245 | 	{ 0x279a18, 'y', 'y' },
1246 | 	{ 0x279a1a, 'X', 'X' },
1247 | 	{-1,0,0}
1248 | };
1249 | 
1250 | PatchByte dplaypatch_81_141[] = {
1251 | 	{ 0x279c10, 'D', 0 },
1252 | 	{ 0x279c12, 'P', 'P' },
1253 | 	{ 0x279c14, 'l', 'l' },
1254 | 	{ 0x279c16, 'a', 'a' },
1255 | 	{ 0x279c18, 'y', 'y' },
1256 | 	{ 0x279c1a, 'X', 'X' },
1257 | 	{-1,0,0}
1258 | };
1259 | 
1260 | // SCHEDULER PATCHES
1261 | // How to create:
1262 | // 1. replace "joyGetDevCapsW" (or A, for 8.0) with "timeBeginPeriod"
1263 | // 2. call the JMP wrapper for timeBeginPeriod instead of writing "Loading help"
1264 | 
1265 | PatchByte schedpatch_70[] = {
1266 | 	{ 0x146755, 0xb8, 0x6a },
1267 | 	{ 0x146756, 0x2d, 0x01 },
1268 | 	{ 0x146757, 0x00, 0xe8 },
1269 | 	{ 0x146758, 0x00, 0x90 },
1270 | 	{ 0x146759, 0x00, 0xef },
1271 | 	{ 0x14675a, 0xe8, 0xf3 },
1272 | 	{ 0x14675b, 0x25, 0xff },
1273 | 	{ 0x14675c, 0xef, 0x90 },
1274 | 	{ 0x14675d, 0xff, 0x90 },
1275 | 	{ 0x14675e, 0xff, 0x90 },
1276 | 	{ 0x18bba2, 0x6a, 0x74 },
1277 | 	{ 0x18bba3, 0x6f, 0x69 },
1278 | 	{ 0x18bba4, 0x79, 0x6d },
1279 | 	{ 0x18bba5, 0x47, 0x65 },
1280 | 	{ 0x18bba6, 0x65, 0x42 },
1281 | 	{ 0x18bba7, 0x74, 0x65 },
1282 | 	{ 0x18bba8, 0x44, 0x67 },
1283 | 	{ 0x18bba9, 0x65, 0x69 },
1284 | 	{ 0x18bbaa, 0x76, 0x6e },
1285 | 	{ 0x18bbab, 0x43, 0x50 },
1286 | 	{ 0x18bbac, 0x61, 0x65 },
1287 | 	{ 0x18bbad, 0x70, 0x72 },
1288 | 	{ 0x18bbae, 0x73, 0x69 },
1289 | 	{ 0x18bbaf, 0x41, 0x6f },
1290 | 	{ 0x18bbb0, 0x00, 0x64 },
1291 | 	{-1,0,0}
1292 | };
1293 | 
1294 | PatchByte schedpatch_80[] = {
1295 | 	{0x14461a, 0xb8, 0x6a},
1296 | 	{0x14461b, 0x2d, 0x01},
1297 | 	{0x14461c, 0x00, 0xe8},
1298 | 	{0x14461d, 0x00, 0x17},
1299 | 	{0x14461e, 0x00, 0xcf},
1300 | 	{0x14461f, 0xe8, 0xf3},
1301 | 	{0x144620, 0x18, 0xff},
1302 | 	{0x144621, 0xef, 0x90},
1303 | 	{0x144622, 0xff, 0x90},
1304 | 	{0x144623, 0xff, 0x90},
1305 | 	{0x191e82, 'j', 't'},
1306 | 	{0x191e83, 'o', 'i'},
1307 | 	{0x191e84, 'y', 'm'},
1308 | 	{0x191e85, 'G', 'e'},
1309 | 	{0x191e86, 'e', 'B'},
1310 | 	{0x191e87, 't', 'e'},
1311 | 	{0x191e88, 'D', 'g'},
1312 | 	{0x191e89, 'e', 'i'},
1313 | 	{0x191e8a, 'v', 'n'},
1314 | 	{0x191e8b, 'C', 'P'},
1315 | 	{0x191e8c, 'a', 'e'},
1316 | 	{0x191e8d, 'p', 'r'},
1317 | 	{0x191e8e, 's', 'i'},
1318 | 	{0x191e8f, 'A', 'o'},
1319 | 	{0x191e90, 0x0, 'd'},
1320 | 	{-1,0,0}
1321 | };
1322 | 
1323 | PatchByte schedpatch_80upx[] = {
1324 | 	{0x14461a, 0xb8, 0x6a},
1325 | 	{0x14461b, 0x2d, 0x01},
1326 | 	{0x14461c, 0x00, 0xe8},
1327 | 	{0x14461d, 0x00, 0x17},
1328 | 	{0x14461e, 0x00, 0xcf},
1329 | 	{0x14461f, 0xe8, 0xf3},
1330 | 	{0x144620, 0x18, 0xff},
1331 | 	{0x144621, 0xef, 0x90},
1332 | 	{0x144622, 0xff, 0x90},
1333 | 	{0x144623, 0xff, 0x90},
1334 | 	{0x191c4e, 'j', 't'},
1335 | 	{0x191c4f, 'o', 'i'},
1336 | 	{0x191c50, 'y', 'm'},
1337 | 	{0x191c51, 'G', 'e'},
1338 | 	{0x191c52, 'e', 'B'},
1339 | 	{0x191c53, 't', 'e'},
1340 | 	{0x191c54, 'D', 'g'},
1341 | 	{0x191c55, 'e', 'i'},
1342 | 	{0x191c56, 'v', 'n'},
1343 | 	{0x191c57, 'C', 'P'},
1344 | 	{0x191c58, 'a', 'e'},
1345 | 	{0x191c59, 'p', 'r'},
1346 | 	{0x191c5a, 's', 'i'},
1347 | 	{0x191c5b, 'A', 'o'},
1348 | 	{0x191c5c, 0x0, 'd'},
1349 | 	{-1,0,0}
1350 | };
1351 | 
1352 | PatchByte schedpatch_81_65[] = {
1353 | 	{ 0x1e3fd6, 0xb8, 0x6a },
1354 | 	{ 0x1e3fd7, 0x2d, 0x01 },
1355 | 	{ 0x1e3fd8, 0x00, 0xe8 },
1356 | 	{ 0x1e3fd9, 0x00, 0x1b },
1357 | 	{ 0x1e3fda, 0x00, 0x52 },
1358 | 	{ 0x1e3fdb, 0xe8, 0xf2 },
1359 | 	{ 0x1e3fdc, 0x98, 0xff },
1360 | 	{ 0x1e3fdd, 0xe7, 0x90 },
1361 | 	{ 0x1e3fde, 0xff, 0x90 },
1362 | 	{ 0x1e3fdf, 0xff, 0x90 },
1363 | 	{ 0x24cb5e, 'j', 't' },
1364 | 	{ 0x24cb5f, 'o', 'i' },
1365 | 	{ 0x24cb60, 'y', 'm' },
1366 | 	{ 0x24cb61, 'G', 'e' },
1367 | 	{ 0x24cb62, 'e', 'B' },
1368 | 	{ 0x24cb63, 't', 'e' },
1369 | 	{ 0x24cb64, 'D', 'g' },
1370 | 	{ 0x24cb65, 'e', 'i' },
1371 | 	{ 0x24cb66, 'v', 'n' },
1372 | 	{ 0x24cb67, 'C', 'P' },
1373 | 	{ 0x24cb68, 'a', 'e' },
1374 | 	{ 0x24cb69, 'p', 'r' },
1375 | 	{ 0x24cb6a, 's', 'i' },
1376 | 	{ 0x24cb6b, 'W', 'o' },
1377 | 	{ 0x24cb6c, 0x0, 'd' },
1378 | 		{-1,0,0}
1379 | };
1380 | 
1381 | PatchByte schedpatch_81_71[] = {
1382 | 	{ 0x1e4126, 0xb8, 0x6a },
1383 | 	{ 0x1e4127, 0x2d, 0x1 },
1384 | 	{ 0x1e4128, 0x0, 0xe8 },
1385 | 	{ 0x1e4129, 0x0, 0xcb },
1386 | 	{ 0x1e412a, 0x0, 0x50 },
1387 | 	{ 0x1e412b, 0xe8, 0xf2 },
1388 | 	{ 0x1e412c, 0x98, 0xff },
1389 | 	{ 0x1e412d, 0xe7, 0x90 },
1390 | 	{ 0x1e412e, 0xff, 0x90 },
1391 | 	{ 0x1e412f, 0xff, 0x90 },
1392 | 	{ 0x24cd5e, 'j', 't' },
1393 | 	{ 0x24cd5f, 'o', 'i' },
1394 | 	{ 0x24cd60, 'y', 'm' },
1395 | 	{ 0x24cd61, 'G', 'e' },
1396 | 	{ 0x24cd62, 'e', 'B' },
1397 | 	{ 0x24cd63, 't', 'e' },
1398 | 	{ 0x24cd64, 'D', 'g' },
1399 | 	{ 0x24cd65, 'e', 'i' },
1400 | 	{ 0x24cd66, 'v', 'n' },
1401 | 	{ 0x24cd67, 'C', 'P' },
1402 | 	{ 0x24cd68, 'a', 'e' },
1403 | 	{ 0x24cd69, 'p', 'r' },
1404 | 	{ 0x24cd6a, 's', 'i' },
1405 | 	{ 0x24cd6b, 'W', 'o' },
1406 | 	{ 0x24cd6c, 0x0, 'd' },
1407 | 	{-1,0,0}
1408 | };
1409 | 
1410 | PatchByte schedpatch_81_91[] = {
1411 | 	{ 0x1f03b2, 0xb8, 0x6a },
1412 | 	{ 0x1f03b3, 0x2d, 0x1 },
1413 | 	{ 0x1f03b4, 0x0, 0xe8 },
1414 | 	{ 0x1f03b5, 0x0, 0x1f },
1415 | 	{ 0x1f03b6, 0x0, 0x8f },
1416 | 	{ 0x1f03b7, 0xe8, 0xf1 },
1417 | 	{ 0x1f03b8, 0x98, 0xff },
1418 | 	{ 0x1f03b9, 0xe7, 0x90 },
1419 | 	{ 0x1f03ba, 0xff, 0x90 },
1420 | 	{ 0x1f03bb, 0xff, 0x90 },
1421 | 	{ 0x24ebfc, 'j', 't' },
1422 | 	{ 0x24ebfd, 'o', 'i' },
1423 | 	{ 0x24ebfe, 'y', 'm' },
1424 | 	{ 0x24ebff, 'G', 'e' },
1425 | 	{ 0x24ec00, 'e', 'B' },
1426 | 	{ 0x24ec01, 't', 'e' },
1427 | 	{ 0x24ec02, 'D', 'g' },
1428 | 	{ 0x24ec03, 'e', 'i' },
1429 | 	{ 0x24ec04, 'v', 'n' },
1430 | 	{ 0x24ec05, 'C', 'P' },
1431 | 	{ 0x24ec06, 'a', 'e' },
1432 | 	{ 0x24ec07, 'p', 'r' },
1433 | 	{ 0x24ec08, 's', 'i' },
1434 | 	{ 0x24ec09, 'W', 'o' },
1435 | 	{ 0x24ec0a, 0x0, 'd' },
1436 | 	{-1,0,0}
1437 | };
1438 | 
1439 | PatchByte schedpatch_81_135[] = {
1440 | 	{ 0x1f52be, 0xb8, 0x6a },
1441 | 	{ 0x1f52bf, 0x2d, 0x01 },
1442 | 	{ 0x1f52c0, 0x00, 0xe8 },
1443 | 	{ 0x1f52c1, 0x00, 0x47 },
1444 | 	{ 0x1f52c2, 0x00, 0x73 },
1445 | 	{ 0x1f52c3, 0xe8, 0xf1 },
1446 | 	{ 0x1f52c4, 0x90, 0xff },
1447 | 	{ 0x1f52c5, 0xe7, 0x90 },
1448 | 	{ 0x1f52c6, 0xff, 0x90 },
1449 | 	{ 0x1f52c7, 0xff, 0x90 },
1450 | 	{ 0x288688, 'j', 't' },
1451 | 	{ 0x288689, 'o', 'i' },
1452 | 	{ 0x28868a, 'y', 'm' },
1453 | 	{ 0x28868b, 'G', 'e' },
1454 | 	{ 0x28868c, 'e', 'B' },
1455 | 	{ 0x28868d, 't', 'e' },
1456 | 	{ 0x28868e, 'D', 'g' },
1457 | 	{ 0x28868f, 'e', 'i' },
1458 | 	{ 0x288690, 'v', 'n' },
1459 | 	{ 0x288691, 'C', 'P' },
1460 | 	{ 0x288692, 'a', 'e' },
1461 | 	{ 0x288693, 'p', 'r' },
1462 | 	{ 0x288694, 's', 'i' },
1463 | 	{ 0x288695, 'W', 'o' },
1464 | 	{ 0x288696, 0x0, 'd' },
1465 | 	{-1,0,0}
1466 | };
1467 | 
1468 | PatchByte schedpatch_81_140[] = {
1469 | 	{ 0x279d23, 0xb8, 0x6a },
1470 | 	{ 0x279d24, 0x20, 0x1 },
1471 | 	{ 0x279d25, 0xb1, 0xe8 },
1472 | 	{ 0x279d26, 0x67, 0xe2 },
1473 | 	{ 0x279d27, 0x0, 0x22 },
1474 | 	{ 0x279d28, 0xe8, 0xe9 },
1475 | 	{ 0x279d29, 0xd7, 0xff },
1476 | 	{ 0x279d2a, 0x67, 0x90 },
1477 | 	{ 0x279d2b, 0xee, 0x90 },
1478 | 	{ 0x279d2c, 0xff, 0x90 },
1479 | 	{ 0x28bc88, 'j', 't' },
1480 | 	{ 0x28bc89, 'o', 'i' },
1481 | 	{ 0x28bc8a, 'y', 'm' },
1482 | 	{ 0x28bc8b, 'G', 'e' },
1483 | 	{ 0x28bc8c, 'e', 'B' },
1484 | 	{ 0x28bc8d, 't', 'e' },
1485 | 	{ 0x28bc8e, 'D', 'g' },
1486 | 	{ 0x28bc8f, 'e', 'i' },
1487 | 	{ 0x28bc90, 'v', 'n' },
1488 | 	{ 0x28bc91, 'C', 'P' },
1489 | 	{ 0x28bc92, 'a', 'e' },
1490 | 	{ 0x28bc93, 'p', 'r' },
1491 | 	{ 0x28bc94, 's', 'i' },
1492 | 	{ 0x28bc95, 'W', 'o' },
1493 | 	{ 0x28bc96, 0x0, 'd' },
1494 | 	{-1,0,0}
1495 | };
1496 | 
1497 | PatchByte schedpatch_81_141[] = {
1498 | 	{0x279f23, 0xb8, 0x6a},
1499 | 	{0x279f24, 0x20, 0x01},
1500 | 	{0x279f25, 0xb1, 0xe8},
1501 | 	{0x279f26, 0x67, 0xe2},
1502 | 	{0x279f27, 0x00, 0x22},
1503 | 	{0x279f28, 0xe8, 0xe9},
1504 | 	{0x279f29, 0xd7, 0xff},
1505 | 	{0x279f2a, 0x67, 0x90},
1506 | 	{0x279f2b, 0xee, 0x90},
1507 | 	{0x279f2c, 0xff, 0x90},
1508 | 	{0x28be88, 'j', 't'},
1509 | 	{0x28be89, 'o', 'i'},
1510 | 	{0x28be8a, 'y', 'm'},
1511 | 	{0x28be8b, 'G', 'e'},
1512 | 	{0x28be8c, 'e', 'B'},
1513 | 	{0x28be8d, 't', 'e'},
1514 | 	{0x28be8e, 'D', 'g'},
1515 | 	{0x28be8f, 'e', 'i'},
1516 | 	{0x28be90, 'v', 'n'},
1517 | 	{0x28be91, 'C', 'P'},
1518 | 	{0x28be92, 'a', 'e'},
1519 | 	{0x28be93, 'p', 'r'},
1520 | 	{0x28be94, 's', 'i'},
1521 | 	{0x28be95, 'W', 'o'},
1522 | 	{0x28be96, 0x0, 'd'},
1523 | 	{-1,0,0}
1524 | };
1525 | 
1526 | // INPUT LAG PATCHES
1527 | // How to create:
1528 | // 1. Find where the timing code and screen presenting is done (search via GML sleep)
1529 | // 2. Swap timing with presenting
1530 | // 3. Fix call instructions
1531 | 
1532 | PatchByte inputlagpatch_70[] = {
1533 | 	{ 0x13fe89, 0xe8, 0xa1 },
1534 | 	{ 0x13fe8a, 0x36, 0xc4 },
1535 | 	{ 0x13fe8b, 0xbb, 0xa1 },
1536 | 	{ 0x13fe8c, 0xf5, 0x58 },
1537 | 	{ 0x13fe8d, 0xff, 0x00 },
1538 | 	{ 0x13fe8e, 0x89, 0x83 },
1539 | 	{ 0x13fe8f, 0x45, 0x38 },
1540 | 	{ 0x13fe90, 0xf0, 0xff },
1541 | 	{ 0x13fe91, 0x89, 0x75 },
1542 | 	{ 0x13fe92, 0x55, 0x14 },
1543 | 	{ 0x13fe93, 0xf4, 0xa1 },
1544 | 	{ 0x13fe94, 0x8b, 0x3c },
1545 | 	{ 0x13fe95, 0x45, 0x9c },
1546 | 	{ 0x13fe96, 0xf0, 0x58 },
1547 | 	{ 0x13fe97, 0x8b, 0x00 },
1548 | 	{ 0x13fe98, 0x55, 0x80 },
1549 | 	{ 0x13fe99, 0xf4, 0x38 },
1550 | 	{ 0x13fe9a, 0x3b, 0x00 },
1551 | 	{ 0x13fe9b, 0x55, 0x74 },
1552 | 	{ 0x13fe9c, 0xfc, 0x0a },
1553 | 	{ 0x13fe9d, 0x75, 0xe8 },
1554 | 	{ 0x13fe9e, 0x07, 0x32 },
1555 | 	{ 0x13fe9f, 0x3b, 0x38 },
1556 | 	{ 0x13fea0, 0x45, 0xf6 },
1557 | 	{ 0x13fea1, 0xf8, 0xff },
1558 | 	{ 0x13fea2, 0x73, 0xe8 },
1559 | 	{ 0x13fea3, 0x10, 0x0d },
1560 | 	{ 0x13fea4, 0xeb, 0x38 },
1561 | 	{ 0x13fea5, 0x02, 0xf6 },
1562 | 	{ 0x13fea6, 0x7d, 0xff },
1563 | 	{ 0x13fea7, 0x0c, 0xe8 },
1564 | 	{ 0x13fea8, 0x8b, 0x18 },
1565 | 	{ 0x13fea9, 0x45, 0xbb },
1566 | 	{ 0x13feaa, 0xf0, 0xf5 },
1567 | 	{ 0x13feab, 0x89, 0xff },
1568 | 	{ 0x13feac, 0x45, 0x89 },
1569 | 	{ 0x13fead, 0xf8, 0x45 },
1570 | 	{ 0x13feae, 0x8b, 0xf0 },
1571 | 	{ 0x13feaf, 0x45, 0x89 },
1572 | 	{ 0x13feb0, 0xf4, 0x55 },
1573 | 	{ 0x13feb1, 0x89, 0xf4 },
1574 | 	{ 0x13feb2, 0x45, 0x8b },
1575 | 	{ 0x13feb3, 0xfc, 0x45 },
1576 | 	{ 0x13feb4, 0xa1, 0xf0 },
1577 | 	{ 0x13feb5, 0x70, 0x8b },
1578 | 	{ 0x13feb6, 0x9d, 0x55 },
1579 | 	{ 0x13feb7, 0x58, 0xf4 },
1580 | 	{ 0x13feb8, 0x00, 0x3b },
1581 | 	{ 0x13feb9, 0x8b, 0x55 },
1582 | 	{ 0x13feba, 0x00, 0xfc },
1583 | 	{ 0x13febb, 0x83, 0x75 },
1584 | 	{ 0x13febc, 0x78, 0x07 },
1585 | 	{ 0x13febd, 0x08, 0x3b },
1586 | 	{ 0x13febe, 0x00, 0x45 },
1587 | 	{ 0x13febf, 0x7f, 0xf8 },
1588 | 	{ 0x13fec0, 0x0e, 0x73 },
1589 | 	{ 0x13fec1, 0xa1, 0x10 },
1590 | 	{ 0x13fec2, 0x70, 0xeb },
1591 | 	{ 0x13fec3, 0x9d, 0x02 },
1592 | 	{ 0x13fec4, 0x58, 0x7d },
1593 | 	{ 0x13fec5, 0x00, 0x0c },
1594 | 	{ 0x13fec7, 0x00, 0x45 },
1595 | 	{ 0x13fec8, 0xc7, 0xf0 },
1596 | 	{ 0x13fec9, 0x40, 0x89 },
1597 | 	{ 0x13feca, 0x08, 0x45 },
1598 | 	{ 0x13fecb, 0x01, 0xf8 },
1599 | 	{ 0x13fecc, 0x00, 0x8b },
1600 | 	{ 0x13fecd, 0x00, 0x45 },
1601 | 	{ 0x13fece, 0x00, 0xf4 },
1602 | 	{ 0x13fecf, 0x6a, 0x89 },
1603 | 	{ 0x13fed0, 0x00, 0x45 },
1604 | 	{ 0x13fed1, 0x6a, 0xfc },
1605 | 	{ 0x13fed2, 0x00, 0xa1 },
1606 | 	{ 0x13fed3, 0xa1, 0x70 },
1607 | 	{ 0x13fed4, 0x70, 0x9d },
1608 | 	{ 0x13fed5, 0x9d, 0x58 },
1609 | 	{ 0x13fed6, 0x58, 0x00 },
1610 | 	{ 0x13fed7, 0x00, 0x8b },
1611 | 	{ 0x13fed8, 0x8b, 0x00 },
1612 | 	{ 0x13fed9, 0x00, 0x83 },
1613 | 	{ 0x13feda, 0xff, 0x78 },
1614 | 	{ 0x13fedb, 0x70, 0x08 },
1615 | 	{ 0x13fedc, 0x08, 0x00 },
1616 | 	{ 0x13fedd, 0xb8, 0x7f },
1617 | 	{ 0x13fede, 0x40, 0x0e },
1618 | 	{ 0x13fedf, 0x42, 0xa1 },
1619 | 	{ 0x13fee0, 0x0f, 0x70 },
1620 | 	{ 0x13fee1, 0x00, 0x9d },
1621 | 	{ 0x13fee2, 0x5a, 0x58 },
1622 | 	{ 0x13fee3, 0x8b, 0x00 },
1623 | 	{ 0x13fee4, 0xca, 0x8b },
1624 | 	{ 0x13fee5, 0x99, 0x00 },
1625 | 	{ 0x13fee6, 0xf7, 0xc7 },
1626 | 	{ 0x13fee7, 0xf9, 0x40 },
1627 | 	{ 0x13fee8, 0x99, 0x08 },
1628 | 	{ 0x13fee9, 0x52, 0x01 },
1629 | 	{ 0x13feea, 0x50, 0x00 },
1630 | 	{ 0x13feeb, 0x8b, 0x00 },
1631 | 	{ 0x13feec, 0x45, 0x00 },
1632 | 	{ 0x13feed, 0xf0, 0x6a },
1633 | 	{ 0x13feee, 0x8b, 0x00 },
1634 | 	{ 0x13feef, 0x55, 0x6a },
1635 | 	{ 0x13fef0, 0xf4, 0x00 },
1636 | 	{ 0x13fef1, 0x2b, 0xa1 },
1637 | 	{ 0x13fef2, 0x45, 0x70 },
1638 | 	{ 0x13fef3, 0xf8, 0x9d },
1639 | 	{ 0x13fef4, 0x1b, 0x58 },
1640 | 	{ 0x13fef5, 0x55, 0x00 },
1641 | 	{ 0x13fef6, 0xfc, 0x8b },
1642 | 	{ 0x13fef7, 0x29, 0x00 },
1643 | 	{ 0x13fef8, 0x04, 0xff },
1644 | 	{ 0x13fef9, 0x24, 0x70 },
1645 | 	{ 0x13fefa, 0x19, 0x08 },
1646 | 	{ 0x13fefb, 0x54, 0xb8 },
1647 | 	{ 0x13fefc, 0x24, 0x40 },
1648 | 	{ 0x13fefd, 0x04, 0x42 },
1649 | 	{ 0x13fefe, 0x58, 0x0f },
1650 | 	{ 0x13feff, 0x5a, 0x00 },
1651 | 	{ 0x13ff00, 0x52, 0x5a },
1652 | 	{ 0x13ff01, 0x50, 0x8b },
1653 | 	{ 0x13ff02, 0xe8, 0xca },
1654 | 	{ 0x13ff03, 0x05, 0x99 },
1655 | 	{ 0x13ff04, 0xbc, 0xf7 },
1656 | 	{ 0x13ff05, 0xee, 0xf9 },
1657 | 	{ 0x13ff06, 0xff, 0x99 },
1658 | 	{ 0x13ff07, 0x89, 0x52 },
1659 | 	{ 0x13ff08, 0x45, 0x50 },
1660 | 	{ 0x13ff09, 0xe8, 0x8b },
1661 | 	{ 0x13ff0a, 0x89, 0x45 },
1662 | 	{ 0x13ff0b, 0x55, 0xf0 },
1663 | 	{ 0x13ff0c, 0xec, 0x8b },
1664 | 	{ 0x13ff0d, 0xff, 0x55 },
1665 | 	{ 0x13ff0e, 0x75, 0xf4 },
1666 | 	{ 0x13ff0f, 0xec, 0x2b },
1667 | 	{ 0x13ff10, 0xff, 0x45 },
1668 | 	{ 0x13ff11, 0x75, 0xf8 },
1669 | 	{ 0x13ff12, 0xe8, 0x1b },
1670 | 	{ 0x13ff13, 0x6a, 0x55 },
1671 | 	{ 0x13ff14, 0x00, 0xfc },
1672 | 	{ 0x13ff15, 0x68, 0x29 },
1673 | 	{ 0x13ff16, 0x40, 0x04 },
1674 | 	{ 0x13ff17, 0x42, 0x24 },
1675 | 	{ 0x13ff18, 0x0f, 0x19 },
1676 | 	{ 0x13ff19, 0x00, 0x54 },
1677 | 	{ 0x13ff1a, 0xe8, 0x24 },
1678 | 	{ 0x13ff1b, 0xed, 0x04 },
1679 | 	{ 0x13ff1c, 0xba, 0x58 },
1680 | 	{ 0x13ff1d, 0xee, 0x5a },
1681 | 	{ 0x13ff1e, 0xff, 0x52 },
1682 | 	{ 0x13ff1f, 0x89, 0x50 },
1683 | 	{ 0x13ff20, 0x45, 0xe8 },
1684 | 	{ 0x13ff21, 0xe8, 0xe7 },
1685 | 	{ 0x13ff22, 0x89, 0xbb },
1686 | 	{ 0x13ff23, 0x55, 0xee },
1687 | 	{ 0x13ff24, 0xec, 0xff },
1688 | 	{ 0x13ff25, 0xff, 0x89 },
1689 | 	{ 0x13ff26, 0x75, 0x45 },
1690 | 	{ 0x13ff27, 0xec, 0xe8 },
1691 | 	{ 0x13ff28, 0xff, 0x89 },
1692 | 	{ 0x13ff29, 0x75, 0x55 },
1693 | 	{ 0x13ff2a, 0xe8, 0xec },
1694 | 	{ 0x13ff2b, 0xe8, 0xff },
1695 | 	{ 0x13ff2c, 0x20, 0x75 },
1696 | 	{ 0x13ff2d, 0xbb, 0xec },
1697 | 	{ 0x13ff2e, 0xf5, 0xff },
1698 | 	{ 0x13ff2f, 0xff, 0x75 },
1699 | 	{ 0x13ff30, 0x8b, 0xe8 },
1700 | 	{ 0x13ff31, 0x45, 0x6a },
1701 | 	{ 0x13ff32, 0xf0, 0x00 },
1702 | 	{ 0x13ff33, 0x8b, 0x68 },
1703 | 	{ 0x13ff34, 0x55, 0x40 },
1704 | 	{ 0x13ff35, 0xf4, 0x42 },
1705 | 	{ 0x13ff36, 0x03, 0x0f },
1706 | 	{ 0x13ff37, 0x45, 0x00 },
1707 | 	{ 0x13ff39, 0x13, 0xcf },
1708 | 	{ 0x13ff3a, 0x55, 0xba },
1709 | 	{ 0x13ff3b, 0xec, 0xee },
1710 | 	{ 0x13ff3c, 0x89, 0xff },
1711 | 	{ 0x13ff3d, 0x45, 0x89 },
1712 | 	{ 0x13ff3e, 0xf8, 0x45 },
1713 | 	{ 0x13ff3f, 0x89, 0xe8 },
1714 | 	{ 0x13ff40, 0x55, 0x89 },
1715 | 	{ 0x13ff41, 0xfc, 0x55 },
1716 | 	{ 0x13ff42, 0x8b, 0xec },
1717 | 	{ 0x13ff43, 0x45, 0xff },
1718 | 	{ 0x13ff44, 0xf8, 0x75 },
1719 | 	{ 0x13ff45, 0x8b, 0xec },
1720 | 	{ 0x13ff46, 0x55, 0xff },
1721 | 	{ 0x13ff47, 0xfc, 0x75 },
1722 | 	{ 0x13ff48, 0x3b, 0xe8 },
1723 | 	{ 0x13ff49, 0x55, 0xe8 },
1724 | 	{ 0x13ff4a, 0xe4, 0x02 },
1725 | 	{ 0x13ff4b, 0x75, 0xbb },
1726 | 	{ 0x13ff4c, 0x07, 0xf5 },
1727 | 	{ 0x13ff4d, 0x3b, 0xff },
1728 | 	{ 0x13ff4e, 0x45, 0x8b },
1729 | 	{ 0x13ff4f, 0xe0, 0x45 },
1730 | 	{ 0x13ff50, 0x73, 0xf0 },
1731 | 	{ 0x13ff51, 0x10, 0x8b },
1732 | 	{ 0x13ff52, 0xeb, 0x55 },
1733 | 	{ 0x13ff53, 0x02, 0xf4 },
1734 | 	{ 0x13ff54, 0x7d, 0x03 },
1735 | 	{ 0x13ff55, 0x0c, 0x45 },
1736 | 	{ 0x13ff56, 0x8b, 0xe8 },
1737 | 	{ 0x13ff57, 0x45, 0x13 },
1738 | 	{ 0x13ff58, 0xf8, 0x55 },
1739 | 	{ 0x13ff59, 0x89, 0xec },
1740 | 	{ 0x13ff5a, 0x45, 0x89 },
1741 | 	{ 0x13ff5b, 0xe0, 0x45 },
1742 | 	{ 0x13ff5c, 0x8b, 0xf8 },
1743 | 	{ 0x13ff5d, 0x45, 0x89 },
1744 | 	{ 0x13ff5e, 0xfc, 0x55 },
1745 | 	{ 0x13ff5f, 0x89, 0xfc },
1746 | 	{ 0x13ff60, 0x45, 0x8b },
1747 | 	{ 0x13ff61, 0xe4, 0x45 },
1748 | 	{ 0x13ff62, 0x6a, 0xf8 },
1749 | 	{ 0x13ff63, 0x00, 0x8b },
1750 | 	{ 0x13ff64, 0x68, 0x55 },
1751 | 	{ 0x13ff65, 0x40, 0xfc },
1752 | 	{ 0x13ff66, 0x42, 0x3b },
1753 | 	{ 0x13ff67, 0x0f, 0x55 },
1754 | 	{ 0x13ff68, 0x00, 0xe4 },
1755 | 	{ 0x13ff69, 0x8b, 0x75 },
1756 | 	{ 0x13ff6a, 0x45, 0x07 },
1757 | 	{ 0x13ff6b, 0xf8, 0x3b },
1758 | 	{ 0x13ff6c, 0x8b, 0x45 },
1759 | 	{ 0x13ff6d, 0x55, 0xe0 },
1760 | 	{ 0x13ff6e, 0xfc, 0x73 },
1761 | 	{ 0x13ff6f, 0xe8, 0x10 },
1762 | 	{ 0x13ff70, 0x3c, 0xeb },
1763 | 	{ 0x13ff71, 0x54, 0x02 },
1764 | 	{ 0x13ff72, 0xec, 0x7d },
1765 | 	{ 0x13ff73, 0xff, 0x0c },
1766 | 	{ 0x13ff74, 0x52, 0x8b },
1767 | 	{ 0x13ff75, 0x50, 0x45 },
1768 | 	{ 0x13ff76, 0x6a, 0xf8 },
1769 | 	{ 0x13ff77, 0x00, 0x89 },
1770 | 	{ 0x13ff78, 0x68, 0x45 },
1771 | 	{ 0x13ff79, 0x40, 0xe0 },
1772 | 	{ 0x13ff7a, 0x42, 0x8b },
1773 | 	{ 0x13ff7b, 0x0f, 0x45 },
1774 | 	{ 0x13ff7c, 0x00, 0xfc },
1775 | 	{ 0x13ff7d, 0x8b, 0x89 },
1776 | 	{ 0x13ff7f, 0xe0, 0xe4 },
1777 | 	{ 0x13ff80, 0x8b, 0x6a },
1778 | 	{ 0x13ff81, 0x55, 0x00 },
1779 | 	{ 0x13ff82, 0xe4, 0x68 },
1780 | 	{ 0x13ff83, 0xe8, 0x40 },
1781 | 	{ 0x13ff84, 0x28, 0x42 },
1782 | 	{ 0x13ff85, 0x54, 0x0f },
1783 | 	{ 0x13ff86, 0xec, 0x00 },
1784 | 	{ 0x13ff87, 0xff, 0x8b },
1785 | 	{ 0x13ff88, 0x3b, 0x45 },
1786 | 	{ 0x13ff89, 0x54, 0xf8 },
1787 | 	{ 0x13ff8a, 0x24, 0x8b },
1788 | 	{ 0x13ff8b, 0x04, 0x55 },
1789 | 	{ 0x13ff8c, 0x75, 0xfc },
1790 | 	{ 0x13ff8d, 0x09, 0xe8 },
1791 | 	{ 0x13ff8e, 0x3b, 0x1e },
1792 | 	{ 0x13ff8f, 0x04, 0x54 },
1793 | 	{ 0x13ff90, 0x24, 0xec },
1794 | 	{ 0x13ff91, 0x5a, 0xff },
1795 | 	{ 0x13ff92, 0x58, 0x52 },
1796 | 	{ 0x13ff93, 0x73, 0x50 },
1797 | 	{ 0x13ff94, 0x21, 0x6a },
1798 | 	{ 0x13ff95, 0xeb, 0x00 },
1799 | 	{ 0x13ff96, 0x04, 0x68 },
1800 | 	{ 0x13ff97, 0x5a, 0x40 },
1801 | 	{ 0x13ff98, 0x58, 0x42 },
1802 | 	{ 0x13ff99, 0x7d, 0x0f },
1803 | 	{ 0x13ff9a, 0x1b, 0x00 },
1804 | 	{ 0x13ff9b, 0xa1, 0x8b },
1805 | 	{ 0x13ff9c, 0xb4, 0x45 },
1806 | 	{ 0x13ff9d, 0x99, 0xe0 },
1807 | 	{ 0x13ff9e, 0x58, 0x8b },
1808 | 	{ 0x13ff9f, 0x00, 0x55 },
1809 | 	{ 0x13ffa0, 0x8b, 0xe4 },
1810 | 	{ 0x13ffa1, 0x55, 0xe8 },
1811 | 	{ 0x13ffa2, 0xdc, 0x0a },
1812 | 	{ 0x13ffa3, 0x89, 0x54 },
1813 | 	{ 0x13ffa4, 0x10, 0xec },
1814 | 	{ 0x13ffa5, 0x33, 0xff },
1815 | 	{ 0x13ffa6, 0xc0, 0x3b },
1816 | 	{ 0x13ffa7, 0x89, 0x54 },
1817 | 	{ 0x13ffa8, 0x45, 0x24 },
1818 | 	{ 0x13ffa9, 0xdc, 0x04 },
1819 | 	{ 0x13ffaa, 0x8b, 0x75 },
1820 | 	{ 0x13ffab, 0x45, 0x09 },
1821 | 	{ 0x13ffac, 0xf8, 0x3b },
1822 | 	{ 0x13ffad, 0x89, 0x04 },
1823 | 	{ 0x13ffae, 0x45, 0x24 },
1824 | 	{ 0x13ffaf, 0xe0, 0x5a },
1825 | 	{ 0x13ffb0, 0x8b, 0x58 },
1826 | 	{ 0x13ffb1, 0x45, 0x73 },
1827 | 	{ 0x13ffb2, 0xfc, 0x21 },
1828 | 	{ 0x13ffb3, 0x89, 0xeb },
1829 | 	{ 0x13ffb4, 0x45, 0x04 },
1830 | 	{ 0x13ffb5, 0xe4, 0x5a },
1831 | 	{ 0x13ffb6, 0xff, 0x58 },
1832 | 	{ 0x13ffb7, 0x45, 0x7d },
1833 | 	{ 0x13ffb8, 0xdc, 0x1b },
1834 | 	{ 0x13ffba, 0xc4, 0xb4 },
1835 | 	{ 0x13ffbb, 0xa1, 0x99 },
1836 | 	{ 0x13ffbe, 0x83, 0x8b },
1837 | 	{ 0x13ffbf, 0x38, 0x55 },
1838 | 	{ 0x13ffc0, 0xff, 0xdc },
1839 | 	{ 0x13ffc1, 0x75, 0x89 },
1840 | 	{ 0x13ffc2, 0x14, 0x10 },
1841 | 	{ 0x13ffc3, 0xa1, 0x33 },
1842 | 	{ 0x13ffc4, 0x3c, 0xc0 },
1843 | 	{ 0x13ffc5, 0x9c, 0x89 },
1844 | 	{ 0x13ffc6, 0x58, 0x45 },
1845 | 	{ 0x13ffc7, 0x00, 0xdc },
1846 | 	{ 0x13ffc8, 0x80, 0x8b },
1847 | 	{ 0x13ffc9, 0x38, 0x45 },
1848 | 	{ 0x13ffca, 0x00, 0xf8 },
1849 | 	{ 0x13ffcb, 0x74, 0x89 },
1850 | 	{ 0x13ffcc, 0x0a, 0x45 },
1851 | 	{ 0x13ffcd, 0xe8, 0xe0 },
1852 | 	{ 0x13ffce, 0x02, 0x8b },
1853 | 	{ 0x13ffcf, 0x37, 0x45 },
1854 | 	{ 0x13ffd0, 0xf6, 0xfc },
1855 | 	{ 0x13ffd1, 0xff, 0x89 },
1856 | 	{ 0x13ffd2, 0xe8, 0x45 },
1857 | 	{ 0x13ffd3, 0xdd, 0xe4 },
1858 | 	{ 0x13ffd4, 0x36, 0xff },
1859 | 	{ 0x13ffd5, 0xf6, 0x45 },
1860 | 	{ 0x13ffd6, 0xff, 0xdc },
1861 | 	{-1,0,0}
1862 | };
1863 | 
1864 | PatchByte inputlagpatch_80[] = {
1865 | 	{ 0x13dcbd, 0xe8, 0xff },
1866 | 	{ 0x13dcbe, 0xfe, 0x45 },
1867 | 	{ 0x13dcbf, 0xbc, 0xdc },
1868 | 	{ 0x13dcc0, 0xf5, 0xa1 },
1869 | 	{ 0x13dcc1, 0xff, 0x4 },
1870 | 	{ 0x13dcc2, 0x89, 0xf6 },
1871 | 	{ 0x13dcc3, 0x45, 0x58 },
1872 | 	{ 0x13dcc4, 0xf0, 0x0 },
1873 | 	{ 0x13dcc5, 0x89, 0x83 },
1874 | 	{ 0x13dcc6, 0x55, 0x38 },
1875 | 	{ 0x13dcc7, 0xf4, 0xff },
1876 | 	{ 0x13dcc8, 0x8b, 0x75 },
1877 | 	{ 0x13dcc9, 0x45, 0x14 },
1878 | 	{ 0x13dcca, 0xf0, 0xa1 },
1879 | 	{ 0x13dccb, 0x8b, 0x84 },
1880 | 	{ 0x13dccc, 0x55, 0xf9 },
1881 | 	{ 0x13dccd, 0xf4, 0x58 },
1882 | 	{ 0x13dcce, 0x3b, 0x0 },
1883 | 	{ 0x13dccf, 0x55, 0x80 },
1884 | 	{ 0x13dcd0, 0xfc, 0x38 },
1885 | 	{ 0x13dcd1, 0x75, 0x0 },
1886 | 	{ 0x13dcd2, 0x7, 0x74 },
1887 | 	{ 0x13dcd3, 0x3b, 0xa },
1888 | 	{ 0x13dcd4, 0x45, 0xe8 },
1889 | 	{ 0x13dcd5, 0xf8, 0x2f },
1890 | 	{ 0x13dcd6, 0x73, 0x3e },
1891 | 	{ 0x13dcd7, 0x10, 0xf6 },
1892 | 	{ 0x13dcd8, 0xeb, 0xff },
1893 | 	{ 0x13dcd9, 0x2, 0xe8 },
1894 | 	{ 0x13dcda, 0x7d, 0xa },
1895 | 	{ 0x13dcdb, 0xc, 0x3e },
1896 | 	{ 0x13dcdc, 0x8b, 0xf6 },
1897 | 	{ 0x13dcdd, 0x45, 0xff },
1898 | 	{ 0x13dcde, 0xf0, 0xe8 },
1899 | 	{ 0x13dcdf, 0x89, 0xdd },
1900 | 	{ 0x13dce0, 0x45, 0xbc },
1901 | 	{ 0x13dce1, 0xf8, 0xf5 },
1902 | 	{ 0x13dce2, 0x8b, 0xff },
1903 | 	{ 0x13dce3, 0x45, 0x89 },
1904 | 	{ 0x13dce4, 0xf4, 0x45 },
1905 | 	{ 0x13dce5, 0x89, 0xf0 },
1906 | 	{ 0x13dce6, 0x45, 0x89 },
1907 | 	{ 0x13dce7, 0xfc, 0x55 },
1908 | 	{ 0x13dce8, 0xa1, 0xf4 },
1909 | 	{ 0x13dce9, 0xc4, 0x8b },
1910 | 	{ 0x13dcea, 0xfa, 0x45 },
1911 | 	{ 0x13dceb, 0x58, 0xf0 },
1912 | 	{ 0x13dcec, 0x0, 0x8b },
1913 | 	{ 0x13dced, 0x8b, 0x55 },
1914 | 	{ 0x13dcee, 0x0, 0xf4 },
1915 | 	{ 0x13dcef, 0x83, 0x3b },
1916 | 	{ 0x13dcf0, 0x78, 0x55 },
1917 | 	{ 0x13dcf1, 0x8, 0xfc },
1918 | 	{ 0x13dcf2, 0x0, 0x75 },
1919 | 	{ 0x13dcf3, 0x7f, 0x7 },
1920 | 	{ 0x13dcf4, 0xe, 0x3b },
1921 | 	{ 0x13dcf5, 0xa1, 0x45 },
1922 | 	{ 0x13dcf6, 0xc4, 0xf8 },
1923 | 	{ 0x13dcf7, 0xfa, 0x73 },
1924 | 	{ 0x13dcf8, 0x58, 0x10 },
1925 | 	{ 0x13dcf9, 0x0, 0xeb },
1926 | 	{ 0x13dcfa, 0x8b, 0x2 },
1927 | 	{ 0x13dcfb, 0x0, 0x7d },
1928 | 	{ 0x13dcfc, 0xc7, 0xc },
1929 | 	{ 0x13dcfd, 0x40, 0x8b },
1930 | 	{ 0x13dcfe, 0x8, 0x45 },
1931 | 	{ 0x13dcff, 0x1, 0xf0 },
1932 | 	{ 0x13dd00, 0x0, 0x89 },
1933 | 	{ 0x13dd01, 0x0, 0x45 },
1934 | 	{ 0x13dd02, 0x0, 0xf8 },
1935 | 	{ 0x13dd03, 0xa1, 0x8b },
1936 | 	{ 0x13dd04, 0xc4, 0x45 },
1937 | 	{ 0x13dd05, 0xfa, 0xf4 },
1938 | 	{ 0x13dd06, 0x58, 0x89 },
1939 | 	{ 0x13dd07, 0x0, 0x45 },
1940 | 	{ 0x13dd08, 0x8b, 0xfc },
1941 | 	{ 0x13dd09, 0x0, 0xa1 },
1942 | 	{ 0x13dd0a, 0xff, 0xc4 },
1943 | 	{ 0x13dd0b, 0x70, 0xfa },
1944 | 	{ 0x13dd0c, 0x8, 0x58 },
1945 | 	{ 0x13dd0d, 0xb8, 0x0 },
1946 | 	{ 0x13dd0e, 0x40, 0x8b },
1947 | 	{ 0x13dd0f, 0x42, 0x0 },
1948 | 	{ 0x13dd10, 0xf, 0x83 },
1949 | 	{ 0x13dd11, 0x0, 0x78 },
1950 | 	{ 0x13dd12, 0x5a, 0x8 },
1951 | 	{ 0x13dd13, 0x8b, 0x0 },
1952 | 	{ 0x13dd14, 0xca, 0x7f },
1953 | 	{ 0x13dd15, 0x99, 0xe },
1954 | 	{ 0x13dd16, 0xf7, 0xa1 },
1955 | 	{ 0x13dd17, 0xf9, 0xc4 },
1956 | 	{ 0x13dd18, 0x99, 0xfa },
1957 | 	{ 0x13dd19, 0x52, 0x58 },
1958 | 	{ 0x13dd1a, 0x50, 0x0 },
1959 | 	{ 0x13dd1c, 0x45, 0x0 },
1960 | 	{ 0x13dd1d, 0xf0, 0xc7 },
1961 | 	{ 0x13dd1e, 0x8b, 0x40 },
1962 | 	{ 0x13dd1f, 0x55, 0x8 },
1963 | 	{ 0x13dd20, 0xf4, 0x1 },
1964 | 	{ 0x13dd21, 0x2b, 0x0 },
1965 | 	{ 0x13dd22, 0x45, 0x0 },
1966 | 	{ 0x13dd23, 0xf8, 0x0 },
1967 | 	{ 0x13dd24, 0x1b, 0xa1 },
1968 | 	{ 0x13dd25, 0x55, 0xc4 },
1969 | 	{ 0x13dd26, 0xfc, 0xfa },
1970 | 	{ 0x13dd27, 0x29, 0x58 },
1971 | 	{ 0x13dd28, 0x4, 0x0 },
1972 | 	{ 0x13dd29, 0x24, 0x8b },
1973 | 	{ 0x13dd2a, 0x19, 0x0 },
1974 | 	{ 0x13dd2b, 0x54, 0xff },
1975 | 	{ 0x13dd2c, 0x24, 0x70 },
1976 | 	{ 0x13dd2d, 0x4, 0x8 },
1977 | 	{ 0x13dd2e, 0x58, 0xb8 },
1978 | 	{ 0x13dd2f, 0x5a, 0x40 },
1979 | 	{ 0x13dd30, 0x89, 0x42 },
1980 | 	{ 0x13dd31, 0x45, 0xf },
1981 | 	{ 0x13dd32, 0xd0, 0x0 },
1982 | 	{ 0x13dd33, 0x89, 0x5a },
1983 | 	{ 0x13dd34, 0x55, 0x8b },
1984 | 	{ 0x13dd35, 0xd4, 0xca },
1985 | 	{ 0x13dd36, 0x83, 0x99 },
1986 | 	{ 0x13dd37, 0x7d, 0xf7 },
1987 | 	{ 0x13dd38, 0xd4, 0xf9 },
1988 | 	{ 0x13dd39, 0x0, 0x99 },
1989 | 	{ 0x13dd3a, 0x75, 0x52 },
1990 | 	{ 0x13dd3b, 0x8, 0x50 },
1991 | 	{ 0x13dd3c, 0x83, 0x8b },
1992 | 	{ 0x13dd3d, 0x7d, 0x45 },
1993 | 	{ 0x13dd3e, 0xd0, 0xf0 },
1994 | 	{ 0x13dd3f, 0x0, 0x8b },
1995 | 	{ 0x13dd40, 0x73, 0x55 },
1996 | 	{ 0x13dd41, 0x14, 0xf4 },
1997 | 	{ 0x13dd42, 0xeb, 0x2b },
1998 | 	{ 0x13dd43, 0x2, 0x45 },
1999 | 	{ 0x13dd44, 0x7d, 0xf8 },
2000 | 	{ 0x13dd45, 0x10, 0x1b },
2001 | 	{ 0x13dd46, 0xc7, 0x55 },
2002 | 	{ 0x13dd47, 0x45, 0xfc },
2003 | 	{ 0x13dd48, 0xc8, 0x29 },
2004 | 	{ 0x13dd49, 0x0, 0x4 },
2005 | 	{ 0x13dd4a, 0x0, 0x24 },
2006 | 	{ 0x13dd4b, 0x0, 0x19 },
2007 | 	{ 0x13dd4c, 0x0, 0x54 },
2008 | 	{ 0x13dd4d, 0xc7, 0x24 },
2009 | 	{ 0x13dd4e, 0x45, 0x4 },
2010 | 	{ 0x13dd4f, 0xcc, 0x58 },
2011 | 	{ 0x13dd50, 0x0, 0x5a },
2012 | 	{ 0x13dd51, 0x0, 0x89 },
2013 | 	{ 0x13dd52, 0x0, 0x45 },
2014 | 	{ 0x13dd53, 0x0, 0xd0 },
2015 | 	{ 0x13dd54, 0xeb, 0x89 },
2016 | 	{ 0x13dd55, 0xc, 0x55 },
2017 | 	{ 0x13dd56, 0x8b, 0xd4 },
2018 | 	{ 0x13dd57, 0x45, 0x83 },
2019 | 	{ 0x13dd58, 0xd0, 0x7d },
2020 | 	{ 0x13dd59, 0x89, 0xd4 },
2021 | 	{ 0x13dd5a, 0x45, 0x0 },
2022 | 	{ 0x13dd5b, 0xc8, 0x75 },
2023 | 	{ 0x13dd5c, 0x8b, 0x8 },
2024 | 	{ 0x13dd5d, 0x45, 0x83 },
2025 | 	{ 0x13dd5e, 0xd4, 0x7d },
2026 | 	{ 0x13dd5f, 0x89, 0xd0 },
2027 | 	{ 0x13dd60, 0x45, 0x0 },
2028 | 	{ 0x13dd61, 0xcc, 0x73 },
2029 | 	{ 0x13dd62, 0x8b, 0x14 },
2030 | 	{ 0x13dd63, 0x45, 0xeb },
2031 | 	{ 0x13dd64, 0xc8, 0x2 },
2032 | 	{ 0x13dd65, 0x89, 0x7d },
2033 | 	{ 0x13dd66, 0x45, 0x10 },
2034 | 	{ 0x13dd67, 0xe8, 0xc7 },
2035 | 	{ 0x13dd68, 0x8b, 0x45 },
2036 | 	{ 0x13dd69, 0x45, 0xc8 },
2037 | 	{ 0x13dd6a, 0xcc, 0x0 },
2038 | 	{ 0x13dd6b, 0x89, 0x0 },
2039 | 	{ 0x13dd6c, 0x45, 0x0 },
2040 | 	{ 0x13dd6d, 0xec, 0x0 },
2041 | 	{ 0x13dd6e, 0x83, 0xc7 },
2042 | 	{ 0x13dd6f, 0x7d, 0x45 },
2043 | 	{ 0x13dd70, 0xec, 0xcc },
2044 | 	{ 0x13dd72, 0x75, 0x0 },
2045 | 	{ 0x13dd73, 0xb, 0x0 },
2046 | 	{ 0x13dd74, 0x81, 0x0 },
2047 | 	{ 0x13dd75, 0x7d, 0xeb },
2048 | 	{ 0x13dd76, 0xe8, 0xc },
2049 | 	{ 0x13dd77, 0x40, 0x8b },
2050 | 	{ 0x13dd78, 0x42, 0x45 },
2051 | 	{ 0x13dd79, 0xf, 0xd0 },
2052 | 	{ 0x13dd7a, 0x0, 0x89 },
2053 | 	{ 0x13dd7b, 0x73, 0x45 },
2054 | 	{ 0x13dd7c, 0x12, 0xc8 },
2055 | 	{ 0x13dd7d, 0xeb, 0x8b },
2056 | 	{ 0x13dd7e, 0x2, 0x45 },
2057 | 	{ 0x13dd7f, 0x7d, 0xd4 },
2058 | 	{ 0x13dd80, 0xe, 0x89 },
2059 | 	{ 0x13dd81, 0x8b, 0x45 },
2060 | 	{ 0x13dd82, 0x45, 0xcc },
2061 | 	{ 0x13dd83, 0xe8, 0x8b },
2062 | 	{ 0x13dd84, 0x89, 0x45 },
2063 | 	{ 0x13dd85, 0x45, 0xc8 },
2064 | 	{ 0x13dd86, 0xc0, 0x89 },
2065 | 	{ 0x13dd87, 0x8b, 0x45 },
2066 | 	{ 0x13dd88, 0x45, 0xe8 },
2067 | 	{ 0x13dd89, 0xec, 0x8b },
2068 | 	{ 0x13dd8a, 0x89, 0x45 },
2069 | 	{ 0x13dd8b, 0x45, 0xcc },
2070 | 	{ 0x13dd8c, 0xc4, 0x89 },
2071 | 	{ 0x13dd8d, 0xeb, 0x45 },
2072 | 	{ 0x13dd8e, 0xe, 0xec },
2073 | 	{ 0x13dd8f, 0xc7, 0x83 },
2074 | 	{ 0x13dd90, 0x45, 0x7d },
2075 | 	{ 0x13dd91, 0xc0, 0xec },
2076 | 	{ 0x13dd92, 0x40, 0x0 },
2077 | 	{ 0x13dd93, 0x42, 0x75 },
2078 | 	{ 0x13dd94, 0xf, 0xb },
2079 | 	{ 0x13dd95, 0x0, 0x81 },
2080 | 	{ 0x13dd96, 0xc7, 0x7d },
2081 | 	{ 0x13dd97, 0x45, 0xe8 },
2082 | 	{ 0x13dd98, 0xc4, 0x40 },
2083 | 	{ 0x13dd99, 0x0, 0x42 },
2084 | 	{ 0x13dd9a, 0x0, 0xf },
2085 | 	{ 0x13dd9c, 0x0, 0x73 },
2086 | 	{ 0x13dd9d, 0x8b, 0x12 },
2087 | 	{ 0x13dd9e, 0x45, 0xeb },
2088 | 	{ 0x13dd9f, 0xc0, 0x2 },
2089 | 	{ 0x13dda0, 0x89, 0x7d },
2090 | 	{ 0x13dda1, 0x45, 0xe },
2091 | 	{ 0x13dda2, 0xe8, 0x8b },
2092 | 	{ 0x13dda3, 0x8b, 0x45 },
2093 | 	{ 0x13dda4, 0x45, 0xe8 },
2094 | 	{ 0x13dda5, 0xc4, 0x89 },
2095 | 	{ 0x13dda6, 0x89, 0x45 },
2096 | 	{ 0x13dda7, 0x45, 0xc0 },
2097 | 	{ 0x13dda8, 0xec, 0x8b },
2098 | 	{ 0x13dda9, 0xff, 0x45 },
2099 | 	{ 0x13ddaa, 0x75, 0xec },
2100 | 	{ 0x13ddab, 0xec, 0x89 },
2101 | 	{ 0x13ddac, 0xff, 0x45 },
2102 | 	{ 0x13ddad, 0x75, 0xc4 },
2103 | 	{ 0x13ddae, 0xe8, 0xeb },
2104 | 	{ 0x13ddaf, 0xe8, 0xe },
2105 | 	{ 0x13ddb0, 0x98, 0xc7 },
2106 | 	{ 0x13ddb1, 0xbc, 0x45 },
2107 | 	{ 0x13ddb2, 0xf5, 0xc0 },
2108 | 	{ 0x13ddb3, 0xff, 0x40 },
2109 | 	{ 0x13ddb4, 0x8b, 0x42 },
2110 | 	{ 0x13ddb5, 0x45, 0xf },
2111 | 	{ 0x13ddb6, 0xf0, 0x0 },
2112 | 	{ 0x13ddb7, 0x8b, 0xc7 },
2113 | 	{ 0x13ddb8, 0x55, 0x45 },
2114 | 	{ 0x13ddb9, 0xf4, 0xc4 },
2115 | 	{ 0x13ddba, 0x3, 0x0 },
2116 | 	{ 0x13ddbb, 0x45, 0x0 },
2117 | 	{ 0x13ddbc, 0xe8, 0x0 },
2118 | 	{ 0x13ddbd, 0x13, 0x0 },
2119 | 	{ 0x13ddbe, 0x55, 0x8b },
2120 | 	{ 0x13ddbf, 0xec, 0x45 },
2121 | 	{ 0x13ddc0, 0x89, 0xc0 },
2122 | 	{ 0x13ddc1, 0x45, 0x89 },
2123 | 	{ 0x13ddc2, 0xf8, 0x45 },
2124 | 	{ 0x13ddc3, 0x89, 0xe8 },
2125 | 	{ 0x13ddc4, 0x55, 0x8b },
2126 | 	{ 0x13ddc5, 0xfc, 0x45 },
2127 | 	{ 0x13ddc6, 0x8b, 0xc4 },
2128 | 	{ 0x13ddc7, 0x45, 0x89 },
2129 | 	{ 0x13ddc8, 0xf8, 0x45 },
2130 | 	{ 0x13ddc9, 0x8b, 0xec },
2131 | 	{ 0x13ddca, 0x55, 0xff },
2132 | 	{ 0x13ddcb, 0xfc, 0x75 },
2133 | 	{ 0x13ddcc, 0x3b, 0xec },
2134 | 	{ 0x13ddcd, 0x55, 0xff },
2135 | 	{ 0x13ddce, 0xe4, 0x75 },
2136 | 	{ 0x13ddcf, 0x75, 0xe8 },
2137 | 	{ 0x13ddd0, 0x7, 0xe8 },
2138 | 	{ 0x13ddd1, 0x3b, 0x77 },
2139 | 	{ 0x13ddd2, 0x45, 0xbc },
2140 | 	{ 0x13ddd3, 0xe0, 0xf5 },
2141 | 	{ 0x13ddd4, 0x73, 0xff },
2142 | 	{ 0x13ddd5, 0x10, 0x8b },
2143 | 	{ 0x13ddd6, 0xeb, 0x45 },
2144 | 	{ 0x13ddd7, 0x2, 0xf0 },
2145 | 	{ 0x13ddd8, 0x7d, 0x8b },
2146 | 	{ 0x13ddd9, 0xc, 0x55 },
2147 | 	{ 0x13ddda, 0x8b, 0xf4 },
2148 | 	{ 0x13dddb, 0x45, 0x3 },
2149 | 	{ 0x13dddc, 0xf8, 0x45 },
2150 | 	{ 0x13dddd, 0x89, 0xe8 },
2151 | 	{ 0x13ddde, 0x45, 0x13 },
2152 | 	{ 0x13dddf, 0xe0, 0x55 },
2153 | 	{ 0x13dde0, 0x8b, 0xec },
2154 | 	{ 0x13dde1, 0x45, 0x89 },
2155 | 	{ 0x13dde2, 0xfc, 0x45 },
2156 | 	{ 0x13dde3, 0x89, 0xf8 },
2157 | 	{ 0x13dde4, 0x45, 0x89 },
2158 | 	{ 0x13dde5, 0xe4, 0x55 },
2159 | 	{ 0x13dde6, 0x6a, 0xfc },
2160 | 	{ 0x13dde7, 0x0, 0x8b },
2161 | 	{ 0x13dde8, 0x68, 0x45 },
2162 | 	{ 0x13dde9, 0x40, 0xf8 },
2163 | 	{ 0x13ddea, 0x42, 0x8b },
2164 | 	{ 0x13ddeb, 0xf, 0x55 },
2165 | 	{ 0x13ddec, 0x0, 0xfc },
2166 | 	{ 0x13dded, 0x8b, 0x3b },
2167 | 	{ 0x13ddee, 0x45, 0x55 },
2168 | 	{ 0x13ddef, 0xf8, 0xe4 },
2169 | 	{ 0x13ddf0, 0x8b, 0x75 },
2170 | 	{ 0x13ddf1, 0x55, 0x7 },
2171 | 	{ 0x13ddf2, 0xfc, 0x3b },
2172 | 	{ 0x13ddf3, 0xe8, 0x45 },
2173 | 	{ 0x13ddf4, 0x4, 0xe0 },
2174 | 	{ 0x13ddf5, 0x80, 0x73 },
2175 | 	{ 0x13ddf6, 0xec, 0x10 },
2176 | 	{ 0x13ddf7, 0xff, 0xeb },
2177 | 	{ 0x13ddf8, 0x52, 0x2 },
2178 | 	{ 0x13ddf9, 0x50, 0x7d },
2179 | 	{ 0x13ddfa, 0x6a, 0xc },
2180 | 	{ 0x13ddfb, 0x0, 0x8b },
2181 | 	{ 0x13ddfc, 0x68, 0x45 },
2182 | 	{ 0x13ddfd, 0x40, 0xf8 },
2183 | 	{ 0x13ddfe, 0x42, 0x89 },
2184 | 	{ 0x13ddff, 0xf, 0x45 },
2185 | 	{ 0x13de00, 0x0, 0xe0 },
2186 | 	{ 0x13de03, 0xe0, 0xfc },
2187 | 	{ 0x13de04, 0x8b, 0x89 },
2188 | 	{ 0x13de05, 0x55, 0x45 },
2189 | 	{ 0x13de07, 0xe8, 0x6a },
2190 | 	{ 0x13de08, 0xf0, 0x0 },
2191 | 	{ 0x13de09, 0x7f, 0x68 },
2192 | 	{ 0x13de0a, 0xec, 0x40 },
2193 | 	{ 0x13de0b, 0xff, 0x42 },
2194 | 	{ 0x13de0c, 0x3b, 0xf },
2195 | 	{ 0x13de0d, 0x54, 0x0 },
2196 | 	{ 0x13de0e, 0x24, 0x8b },
2197 | 	{ 0x13de0f, 0x4, 0x45 },
2198 | 	{ 0x13de10, 0x75, 0xf8 },
2199 | 	{ 0x13de11, 0x9, 0x8b },
2200 | 	{ 0x13de12, 0x3b, 0x55 },
2201 | 	{ 0x13de13, 0x4, 0xfc },
2202 | 	{ 0x13de14, 0x24, 0xe8 },
2203 | 	{ 0x13de15, 0x5a, 0xe3 },
2204 | 	{ 0x13de16, 0x58, 0x7f },
2205 | 	{ 0x13de17, 0x73, 0xec },
2206 | 	{ 0x13de18, 0x21, 0xff },
2207 | 	{ 0x13de19, 0xeb, 0x52 },
2208 | 	{ 0x13de1a, 0x4, 0x50 },
2209 | 	{ 0x13de1b, 0x5a, 0x6a },
2210 | 	{ 0x13de1c, 0x58, 0x0 },
2211 | 	{ 0x13de1d, 0x7d, 0x68 },
2212 | 	{ 0x13de1e, 0x1b, 0x40 },
2213 | 	{ 0x13de1f, 0xa1, 0x42 },
2214 | 	{ 0x13de20, 0xd8, 0xf },
2215 | 	{ 0x13de21, 0xf3, 0x0 },
2216 | 	{ 0x13de22, 0x58, 0x8b },
2217 | 	{ 0x13de23, 0x0, 0x45 },
2218 | 	{ 0x13de24, 0x8b, 0xe0 },
2219 | 	{ 0x13de25, 0x55, 0x8b },
2220 | 	{ 0x13de26, 0xdc, 0x55 },
2221 | 	{ 0x13de27, 0x89, 0xe4 },
2222 | 	{ 0x13de28, 0x10, 0xe8 },
2223 | 	{ 0x13de29, 0x33, 0xcf },
2224 | 	{ 0x13de2a, 0xc0, 0x7f },
2225 | 	{ 0x13de2b, 0x89, 0xec },
2226 | 	{ 0x13de2c, 0x45, 0xff },
2227 | 	{ 0x13de2d, 0xdc, 0x3b },
2228 | 	{ 0x13de2e, 0x8b, 0x54 },
2229 | 	{ 0x13de2f, 0x45, 0x24 },
2230 | 	{ 0x13de30, 0xf8, 0x4 },
2231 | 	{ 0x13de31, 0x89, 0x75 },
2232 | 	{ 0x13de32, 0x45, 0x9 },
2233 | 	{ 0x13de33, 0xe0, 0x3b },
2234 | 	{ 0x13de34, 0x8b, 0x4 },
2235 | 	{ 0x13de35, 0x45, 0x24 },
2236 | 	{ 0x13de36, 0xfc, 0x5a },
2237 | 	{ 0x13de37, 0x89, 0x58 },
2238 | 	{ 0x13de38, 0x45, 0x73 },
2239 | 	{ 0x13de39, 0xe4, 0x21 },
2240 | 	{ 0x13de3a, 0xff, 0xeb },
2241 | 	{ 0x13de3b, 0x45, 0x4 },
2242 | 	{ 0x13de3c, 0xdc, 0x5a },
2243 | 	{ 0x13de3d, 0xa1, 0x58 },
2244 | 	{ 0x13de3e, 0x4, 0x7d },
2245 | 	{ 0x13de3f, 0xf6, 0x1b },
2246 | 	{ 0x13de40, 0x58, 0xa1 },
2247 | 	{ 0x13de41, 0x0, 0xd8 },
2248 | 	{ 0x13de42, 0x83, 0xf3 },
2249 | 	{ 0x13de43, 0x38, 0x58 },
2250 | 	{ 0x13de44, 0xff, 0x0 },
2251 | 	{ 0x13de45, 0x75, 0x8b },
2252 | 	{ 0x13de46, 0x14, 0x55 },
2253 | 	{ 0x13de47, 0xa1, 0xdc },
2254 | 	{ 0x13de48, 0x84, 0x89 },
2255 | 	{ 0x13de49, 0xf9, 0x10 },
2256 | 	{ 0x13de4a, 0x58, 0x33 },
2257 | 	{ 0x13de4b, 0x0, 0xc0 },
2258 | 	{ 0x13de4c, 0x80, 0x89 },
2259 | 	{ 0x13de4d, 0x38, 0x45 },
2260 | 	{ 0x13de4e, 0x0, 0xdc },
2261 | 	{ 0x13de4f, 0x74, 0x8b },
2262 | 	{ 0x13de50, 0xa, 0x45 },
2263 | 	{ 0x13de51, 0xe8, 0xf8 },
2264 | 	{ 0x13de52, 0xb2, 0x89 },
2265 | 	{ 0x13de53, 0x3c, 0x45 },
2266 | 	{ 0x13de54, 0xf6, 0xe0 },
2267 | 	{ 0x13de55, 0xff, 0x8b },
2268 | 	{ 0x13de56, 0xe8, 0x45 },
2269 | 	{ 0x13de57, 0x8d, 0xfc },
2270 | 	{ 0x13de58, 0x3c, 0x89 },
2271 | 	{ 0x13de59, 0xf6, 0x45 },
2272 | 	{ 0x13de5a, 0xff, 0xe4 },
2273 | 	{-1,0,0}
2274 | };
2275 | 
2276 | PatchByte inputlagpatch_81_65[] = {
2277 | 	{ 0x1d45eb, 0xe8, 0xa1 },
2278 | 	{ 0x1d45ec, 0x0, 0x78 },
2279 | 	{ 0x1d45ed, 0x8c, 0x9d },
2280 | 	{ 0x1d45ee, 0xf5, 0x64 },
2281 | 	{ 0x1d45ef, 0xff, 0x0 },
2282 | 	{ 0x1d45f0, 0x89, 0x83 },
2283 | 	{ 0x1d45f1, 0x45, 0x38 },
2284 | 	{ 0x1d45f2, 0xf0, 0xff },
2285 | 	{ 0x1d45f3, 0x89, 0x75 },
2286 | 	{ 0x1d45f4, 0x55, 0x14 },
2287 | 	{ 0x1d45f5, 0xf4, 0xa1 },
2288 | 	{ 0x1d45f6, 0x8b, 0xb0 },
2289 | 	{ 0x1d45f7, 0x45, 0xa1 },
2290 | 	{ 0x1d45f8, 0xf0, 0x64 },
2291 | 	{ 0x1d45f9, 0x8b, 0x0 },
2292 | 	{ 0x1d45fa, 0x55, 0x80 },
2293 | 	{ 0x1d45fb, 0xf4, 0x38 },
2294 | 	{ 0x1d45fc, 0x3b, 0x0 },
2295 | 	{ 0x1d45fd, 0x55, 0x74 },
2296 | 	{ 0x1d45fe, 0xfc, 0xa },
2297 | 	{ 0x1d45ff, 0x75, 0xe8 },
2298 | 	{ 0x1d4600, 0x7, 0x8c },
2299 | 	{ 0x1d4601, 0x3b, 0x12 },
2300 | 	{ 0x1d4602, 0x45, 0xf6 },
2301 | 	{ 0x1d4603, 0xf8, 0xff },
2302 | 	{ 0x1d4604, 0x73, 0xe8 },
2303 | 	{ 0x1d4605, 0x10, 0x67 },
2304 | 	{ 0x1d4606, 0xeb, 0x12 },
2305 | 	{ 0x1d4607, 0x2, 0xf6 },
2306 | 	{ 0x1d4608, 0x7d, 0xff },
2307 | 	{ 0x1d4609, 0xc, 0xe8 },
2308 | 	{ 0x1d460a, 0x8b, 0xe2 },
2309 | 	{ 0x1d460b, 0x45, 0x8b },
2310 | 	{ 0x1d460c, 0xf0, 0xf5 },
2311 | 	{ 0x1d460d, 0x89, 0xff },
2312 | 	{ 0x1d460e, 0x45, 0x89 },
2313 | 	{ 0x1d460f, 0xf8, 0x45 },
2314 | 	{ 0x1d4610, 0x8b, 0xf0 },
2315 | 	{ 0x1d4611, 0x45, 0x89 },
2316 | 	{ 0x1d4612, 0xf4, 0x55 },
2317 | 	{ 0x1d4613, 0x89, 0xf4 },
2318 | 	{ 0x1d4614, 0x45, 0x8b },
2319 | 	{ 0x1d4615, 0xfc, 0x45 },
2320 | 	{ 0x1d4616, 0xa1, 0xf0 },
2321 | 	{ 0x1d4617, 0x18, 0x8b },
2322 | 	{ 0x1d4618, 0xa3, 0x55 },
2323 | 	{ 0x1d4619, 0x64, 0xf4 },
2324 | 	{ 0x1d461a, 0x0, 0x3b },
2325 | 	{ 0x1d461b, 0x8b, 0x55 },
2326 | 	{ 0x1d461c, 0x0, 0xfc },
2327 | 	{ 0x1d461d, 0x83, 0x75 },
2328 | 	{ 0x1d461e, 0x78, 0x7 },
2329 | 	{ 0x1d461f, 0x8, 0x3b },
2330 | 	{ 0x1d4620, 0x0, 0x45 },
2331 | 	{ 0x1d4621, 0x7f, 0xf8 },
2332 | 	{ 0x1d4622, 0xe, 0x73 },
2333 | 	{ 0x1d4623, 0xa1, 0x10 },
2334 | 	{ 0x1d4624, 0x18, 0xeb },
2335 | 	{ 0x1d4625, 0xa3, 0x2 },
2336 | 	{ 0x1d4626, 0x64, 0x7d },
2337 | 	{ 0x1d4627, 0x0, 0xc },
2338 | 	{ 0x1d4629, 0x0, 0x45 },
2339 | 	{ 0x1d462a, 0xc7, 0xf0 },
2340 | 	{ 0x1d462b, 0x40, 0x89 },
2341 | 	{ 0x1d462c, 0x8, 0x45 },
2342 | 	{ 0x1d462d, 0x1, 0xf8 },
2343 | 	{ 0x1d462e, 0x0, 0x8b },
2344 | 	{ 0x1d462f, 0x0, 0x45 },
2345 | 	{ 0x1d4630, 0x0, 0xf4 },
2346 | 	{ 0x1d4631, 0xa1, 0x89 },
2347 | 	{ 0x1d4632, 0x18, 0x45 },
2348 | 	{ 0x1d4633, 0xa3, 0xfc },
2349 | 	{ 0x1d4634, 0x64, 0xa1 },
2350 | 	{ 0x1d4635, 0x0, 0x18 },
2351 | 	{ 0x1d4636, 0x8b, 0xa3 },
2352 | 	{ 0x1d4637, 0x0, 0x64 },
2353 | 	{ 0x1d4638, 0xff, 0x0 },
2354 | 	{ 0x1d4639, 0x70, 0x8b },
2355 | 	{ 0x1d463a, 0x8, 0x0 },
2356 | 	{ 0x1d463b, 0xb8, 0x83 },
2357 | 	{ 0x1d463c, 0x40, 0x78 },
2358 | 	{ 0x1d463d, 0x42, 0x8 },
2359 | 	{ 0x1d463e, 0xf, 0x0 },
2360 | 	{ 0x1d463f, 0x0, 0x7f },
2361 | 	{ 0x1d4640, 0x5a, 0xe },
2362 | 	{ 0x1d4641, 0x8b, 0xa1 },
2363 | 	{ 0x1d4642, 0xca, 0x18 },
2364 | 	{ 0x1d4643, 0x99, 0xa3 },
2365 | 	{ 0x1d4644, 0xf7, 0x64 },
2366 | 	{ 0x1d4645, 0xf9, 0x0 },
2367 | 	{ 0x1d4646, 0x99, 0x8b },
2368 | 	{ 0x1d4647, 0x52, 0x0 },
2369 | 	{ 0x1d4648, 0x50, 0xc7 },
2370 | 	{ 0x1d4649, 0x8b, 0x40 },
2371 | 	{ 0x1d464a, 0x45, 0x8 },
2372 | 	{ 0x1d464b, 0xf0, 0x1 },
2373 | 	{ 0x1d464c, 0x8b, 0x0 },
2374 | 	{ 0x1d464d, 0x55, 0x0 },
2375 | 	{ 0x1d464e, 0xf4, 0x0 },
2376 | 	{ 0x1d464f, 0x2b, 0xa1 },
2377 | 	{ 0x1d4650, 0x45, 0x18 },
2378 | 	{ 0x1d4651, 0xf8, 0xa3 },
2379 | 	{ 0x1d4652, 0x1b, 0x64 },
2380 | 	{ 0x1d4653, 0x55, 0x0 },
2381 | 	{ 0x1d4654, 0xfc, 0x8b },
2382 | 	{ 0x1d4655, 0x29, 0x0 },
2383 | 	{ 0x1d4656, 0x4, 0xff },
2384 | 	{ 0x1d4657, 0x24, 0x70 },
2385 | 	{ 0x1d4658, 0x19, 0x8 },
2386 | 	{ 0x1d4659, 0x54, 0xb8 },
2387 | 	{ 0x1d465a, 0x24, 0x40 },
2388 | 	{ 0x1d465b, 0x4, 0x42 },
2389 | 	{ 0x1d465c, 0x58, 0xf },
2390 | 	{ 0x1d465d, 0x5a, 0x0 },
2391 | 	{ 0x1d465e, 0x89, 0x5a },
2392 | 	{ 0x1d465f, 0x45, 0x8b },
2393 | 	{ 0x1d4660, 0xd0, 0xca },
2394 | 	{ 0x1d4661, 0x89, 0x99 },
2395 | 	{ 0x1d4662, 0x55, 0xf7 },
2396 | 	{ 0x1d4663, 0xd4, 0xf9 },
2397 | 	{ 0x1d4664, 0x83, 0x99 },
2398 | 	{ 0x1d4665, 0x7d, 0x52 },
2399 | 	{ 0x1d4666, 0xd4, 0x50 },
2400 | 	{ 0x1d4667, 0x0, 0x8b },
2401 | 	{ 0x1d4668, 0x75, 0x45 },
2402 | 	{ 0x1d4669, 0x8, 0xf0 },
2403 | 	{ 0x1d466a, 0x83, 0x8b },
2404 | 	{ 0x1d466b, 0x7d, 0x55 },
2405 | 	{ 0x1d466c, 0xd0, 0xf4 },
2406 | 	{ 0x1d466d, 0x0, 0x2b },
2407 | 	{ 0x1d466e, 0x73, 0x45 },
2408 | 	{ 0x1d466f, 0x14, 0xf8 },
2409 | 	{ 0x1d4670, 0xeb, 0x1b },
2410 | 	{ 0x1d4671, 0x2, 0x55 },
2411 | 	{ 0x1d4672, 0x7d, 0xfc },
2412 | 	{ 0x1d4673, 0x10, 0x29 },
2413 | 	{ 0x1d4674, 0xc7, 0x4 },
2414 | 	{ 0x1d4675, 0x45, 0x24 },
2415 | 	{ 0x1d4676, 0xc8, 0x19 },
2416 | 	{ 0x1d4677, 0x0, 0x54 },
2417 | 	{ 0x1d4678, 0x0, 0x24 },
2418 | 	{ 0x1d4679, 0x0, 0x4 },
2419 | 	{ 0x1d467a, 0x0, 0x58 },
2420 | 	{ 0x1d467b, 0xc7, 0x5a },
2421 | 	{ 0x1d467c, 0x45, 0x89 },
2422 | 	{ 0x1d467d, 0xcc, 0x45 },
2423 | 	{ 0x1d467e, 0x0, 0xd0 },
2424 | 	{ 0x1d467f, 0x0, 0x89 },
2425 | 	{ 0x1d4680, 0x0, 0x55 },
2426 | 	{ 0x1d4681, 0x0, 0xd4 },
2427 | 	{ 0x1d4682, 0xeb, 0x83 },
2428 | 	{ 0x1d4683, 0xc, 0x7d },
2429 | 	{ 0x1d4684, 0x8b, 0xd4 },
2430 | 	{ 0x1d4685, 0x45, 0x0 },
2431 | 	{ 0x1d4686, 0xd0, 0x75 },
2432 | 	{ 0x1d4687, 0x89, 0x8 },
2433 | 	{ 0x1d4688, 0x45, 0x83 },
2434 | 	{ 0x1d4689, 0xc8, 0x7d },
2435 | 	{ 0x1d468a, 0x8b, 0xd0 },
2436 | 	{ 0x1d468b, 0x45, 0x0 },
2437 | 	{ 0x1d468c, 0xd4, 0x73 },
2438 | 	{ 0x1d468d, 0x89, 0x14 },
2439 | 	{ 0x1d468e, 0x45, 0xeb },
2440 | 	{ 0x1d468f, 0xcc, 0x2 },
2441 | 	{ 0x1d4690, 0x8b, 0x7d },
2442 | 	{ 0x1d4691, 0x45, 0x10 },
2443 | 	{ 0x1d4692, 0xc8, 0xc7 },
2444 | 	{ 0x1d4693, 0x89, 0x45 },
2445 | 	{ 0x1d4694, 0x45, 0xc8 },
2446 | 	{ 0x1d4695, 0xe8, 0x0 },
2447 | 	{ 0x1d4696, 0x8b, 0x0 },
2448 | 	{ 0x1d4697, 0x45, 0x0 },
2449 | 	{ 0x1d4698, 0xcc, 0x0 },
2450 | 	{ 0x1d4699, 0x89, 0xc7 },
2451 | 	{ 0x1d469b, 0xec, 0xcc },
2452 | 	{ 0x1d469c, 0x83, 0x0 },
2453 | 	{ 0x1d469d, 0x7d, 0x0 },
2454 | 	{ 0x1d469e, 0xec, 0x0 },
2455 | 	{ 0x1d46a0, 0x75, 0xeb },
2456 | 	{ 0x1d46a1, 0xb, 0xc },
2457 | 	{ 0x1d46a2, 0x81, 0x8b },
2458 | 	{ 0x1d46a3, 0x7d, 0x45 },
2459 | 	{ 0x1d46a4, 0xe8, 0xd0 },
2460 | 	{ 0x1d46a5, 0x40, 0x89 },
2461 | 	{ 0x1d46a6, 0x42, 0x45 },
2462 | 	{ 0x1d46a7, 0xf, 0xc8 },
2463 | 	{ 0x1d46a8, 0x0, 0x8b },
2464 | 	{ 0x1d46a9, 0x73, 0x45 },
2465 | 	{ 0x1d46aa, 0x12, 0xd4 },
2466 | 	{ 0x1d46ab, 0xeb, 0x89 },
2467 | 	{ 0x1d46ac, 0x2, 0x45 },
2468 | 	{ 0x1d46ad, 0x7d, 0xcc },
2469 | 	{ 0x1d46ae, 0xe, 0x8b },
2470 | 	{ 0x1d46af, 0x8b, 0x45 },
2471 | 	{ 0x1d46b0, 0x45, 0xc8 },
2472 | 	{ 0x1d46b1, 0xe8, 0x89 },
2473 | 	{ 0x1d46b2, 0x89, 0x45 },
2474 | 	{ 0x1d46b3, 0x45, 0xe8 },
2475 | 	{ 0x1d46b4, 0xc0, 0x8b },
2476 | 	{ 0x1d46b5, 0x8b, 0x45 },
2477 | 	{ 0x1d46b6, 0x45, 0xcc },
2478 | 	{ 0x1d46b7, 0xec, 0x89 },
2479 | 	{ 0x1d46b8, 0x89, 0x45 },
2480 | 	{ 0x1d46b9, 0x45, 0xec },
2481 | 	{ 0x1d46ba, 0xc4, 0x83 },
2482 | 	{ 0x1d46bb, 0xeb, 0x7d },
2483 | 	{ 0x1d46bc, 0xe, 0xec },
2484 | 	{ 0x1d46bd, 0xc7, 0x0 },
2485 | 	{ 0x1d46be, 0x45, 0x75 },
2486 | 	{ 0x1d46bf, 0xc0, 0xb },
2487 | 	{ 0x1d46c0, 0x40, 0x81 },
2488 | 	{ 0x1d46c1, 0x42, 0x7d },
2489 | 	{ 0x1d46c2, 0xf, 0xe8 },
2490 | 	{ 0x1d46c3, 0x0, 0x40 },
2491 | 	{ 0x1d46c4, 0xc7, 0x42 },
2492 | 	{ 0x1d46c5, 0x45, 0xf },
2493 | 	{ 0x1d46c6, 0xc4, 0x0 },
2494 | 	{ 0x1d46c7, 0x0, 0x73 },
2495 | 	{ 0x1d46c8, 0x0, 0x12 },
2496 | 	{ 0x1d46c9, 0x0, 0xeb },
2497 | 	{ 0x1d46ca, 0x0, 0x2 },
2498 | 	{ 0x1d46cb, 0x8b, 0x7d },
2499 | 	{ 0x1d46cc, 0x45, 0xe },
2500 | 	{ 0x1d46cd, 0xc0, 0x8b },
2501 | 	{ 0x1d46ce, 0x89, 0x45 },
2502 | 	{ 0x1d46cf, 0x45, 0xe8 },
2503 | 	{ 0x1d46d0, 0xe8, 0x89 },
2504 | 	{ 0x1d46d1, 0x8b, 0x45 },
2505 | 	{ 0x1d46d2, 0x45, 0xc0 },
2506 | 	{ 0x1d46d3, 0xc4, 0x8b },
2507 | 	{ 0x1d46d4, 0x89, 0x45 },
2508 | 	{ 0x1d46d5, 0x45, 0xec },
2509 | 	{ 0x1d46d6, 0xec, 0x89 },
2510 | 	{ 0x1d46d7, 0xff, 0x45 },
2511 | 	{ 0x1d46d8, 0x75, 0xc4 },
2512 | 	{ 0x1d46d9, 0xec, 0xeb },
2513 | 	{ 0x1d46da, 0xff, 0xe },
2514 | 	{ 0x1d46db, 0x75, 0xc7 },
2515 | 	{ 0x1d46dc, 0xe8, 0x45 },
2516 | 	{ 0x1d46dd, 0xe8, 0xc0 },
2517 | 	{ 0x1d46de, 0x9a, 0x40 },
2518 | 	{ 0x1d46df, 0x8b, 0x42 },
2519 | 	{ 0x1d46e0, 0xf5, 0xf },
2520 | 	{ 0x1d46e1, 0xff, 0x0 },
2521 | 	{ 0x1d46e2, 0x8b, 0xc7 },
2522 | 	{ 0x1d46e4, 0xf0, 0xc4 },
2523 | 	{ 0x1d46e5, 0x8b, 0x0 },
2524 | 	{ 0x1d46e6, 0x55, 0x0 },
2525 | 	{ 0x1d46e7, 0xf4, 0x0 },
2526 | 	{ 0x1d46e8, 0x3, 0x0 },
2527 | 	{ 0x1d46e9, 0x45, 0x8b },
2528 | 	{ 0x1d46ea, 0xe8, 0x45 },
2529 | 	{ 0x1d46eb, 0x13, 0xc0 },
2530 | 	{ 0x1d46ec, 0x55, 0x89 },
2531 | 	{ 0x1d46ed, 0xec, 0x45 },
2532 | 	{ 0x1d46ee, 0x89, 0xe8 },
2533 | 	{ 0x1d46ef, 0x45, 0x8b },
2534 | 	{ 0x1d46f0, 0xf8, 0x45 },
2535 | 	{ 0x1d46f1, 0x89, 0xc4 },
2536 | 	{ 0x1d46f2, 0x55, 0x89 },
2537 | 	{ 0x1d46f3, 0xfc, 0x45 },
2538 | 	{ 0x1d46f4, 0x8b, 0xec },
2539 | 	{ 0x1d46f5, 0x45, 0xff },
2540 | 	{ 0x1d46f6, 0xf8, 0x75 },
2541 | 	{ 0x1d46f7, 0x8b, 0xec },
2542 | 	{ 0x1d46f8, 0x55, 0xff },
2543 | 	{ 0x1d46f9, 0xfc, 0x75 },
2544 | 	{ 0x1d46fa, 0x3b, 0xe8 },
2545 | 	{ 0x1d46fb, 0x55, 0xe8 },
2546 | 	{ 0x1d46fc, 0xe4, 0x7c },
2547 | 	{ 0x1d46fd, 0x75, 0x8b },
2548 | 	{ 0x1d46fe, 0x7, 0xf5 },
2549 | 	{ 0x1d46ff, 0x3b, 0xff },
2550 | 	{ 0x1d4700, 0x45, 0x8b },
2551 | 	{ 0x1d4701, 0xe0, 0x45 },
2552 | 	{ 0x1d4702, 0x73, 0xf0 },
2553 | 	{ 0x1d4703, 0x10, 0x8b },
2554 | 	{ 0x1d4704, 0xeb, 0x55 },
2555 | 	{ 0x1d4705, 0x2, 0xf4 },
2556 | 	{ 0x1d4706, 0x7d, 0x3 },
2557 | 	{ 0x1d4707, 0xc, 0x45 },
2558 | 	{ 0x1d4708, 0x8b, 0xe8 },
2559 | 	{ 0x1d4709, 0x45, 0x13 },
2560 | 	{ 0x1d470a, 0xf8, 0x55 },
2561 | 	{ 0x1d470b, 0x89, 0xec },
2562 | 	{ 0x1d470c, 0x45, 0x89 },
2563 | 	{ 0x1d470d, 0xe0, 0x45 },
2564 | 	{ 0x1d470e, 0x8b, 0xf8 },
2565 | 	{ 0x1d470f, 0x45, 0x89 },
2566 | 	{ 0x1d4710, 0xfc, 0x55 },
2567 | 	{ 0x1d4711, 0x89, 0xfc },
2568 | 	{ 0x1d4712, 0x45, 0x8b },
2569 | 	{ 0x1d4713, 0xe4, 0x45 },
2570 | 	{ 0x1d4714, 0x6a, 0xf8 },
2571 | 	{ 0x1d4715, 0x0, 0x8b },
2572 | 	{ 0x1d4716, 0x68, 0x55 },
2573 | 	{ 0x1d4717, 0x40, 0xfc },
2574 | 	{ 0x1d4718, 0x42, 0x3b },
2575 | 	{ 0x1d4719, 0xf, 0x55 },
2576 | 	{ 0x1d471a, 0x0, 0xe4 },
2577 | 	{ 0x1d471b, 0x8b, 0x75 },
2578 | 	{ 0x1d471c, 0x45, 0x7 },
2579 | 	{ 0x1d471d, 0xf8, 0x3b },
2580 | 	{ 0x1d471e, 0x8b, 0x45 },
2581 | 	{ 0x1d471f, 0x55, 0xe0 },
2582 | 	{ 0x1d4720, 0xfc, 0x73 },
2583 | 	{ 0x1d4721, 0xe8, 0x10 },
2584 | 	{ 0x1d4722, 0x2a, 0xeb },
2585 | 	{ 0x1d4723, 0x40, 0x2 },
2586 | 	{ 0x1d4724, 0xe3, 0x7d },
2587 | 	{ 0x1d4725, 0xff, 0xc },
2588 | 	{ 0x1d4726, 0x52, 0x8b },
2589 | 	{ 0x1d4727, 0x50, 0x45 },
2590 | 	{ 0x1d4728, 0x6a, 0xf8 },
2591 | 	{ 0x1d4729, 0x0, 0x89 },
2592 | 	{ 0x1d472a, 0x68, 0x45 },
2593 | 	{ 0x1d472b, 0x40, 0xe0 },
2594 | 	{ 0x1d472c, 0x42, 0x8b },
2595 | 	{ 0x1d472d, 0xf, 0x45 },
2596 | 	{ 0x1d472e, 0x0, 0xfc },
2597 | 	{ 0x1d472f, 0x8b, 0x89 },
2598 | 	{ 0x1d4731, 0xe0, 0xe4 },
2599 | 	{ 0x1d4732, 0x8b, 0x6a },
2600 | 	{ 0x1d4733, 0x55, 0x0 },
2601 | 	{ 0x1d4734, 0xe4, 0x68 },
2602 | 	{ 0x1d4735, 0xe8, 0x40 },
2603 | 	{ 0x1d4736, 0x16, 0x42 },
2604 | 	{ 0x1d4737, 0x40, 0xf },
2605 | 	{ 0x1d4738, 0xe3, 0x0 },
2606 | 	{ 0x1d4739, 0xff, 0x8b },
2607 | 	{ 0x1d473a, 0x3b, 0x45 },
2608 | 	{ 0x1d473b, 0x54, 0xf8 },
2609 | 	{ 0x1d473c, 0x24, 0x8b },
2610 | 	{ 0x1d473d, 0x4, 0x55 },
2611 | 	{ 0x1d473e, 0x75, 0xfc },
2612 | 	{ 0x1d473f, 0x9, 0xe8 },
2613 | 	{ 0x1d4740, 0x3b, 0xc },
2614 | 	{ 0x1d4741, 0x4, 0x40 },
2615 | 	{ 0x1d4742, 0x24, 0xe3 },
2616 | 	{ 0x1d4743, 0x5a, 0xff },
2617 | 	{ 0x1d4744, 0x58, 0x52 },
2618 | 	{ 0x1d4745, 0x73, 0x50 },
2619 | 	{ 0x1d4746, 0x21, 0x6a },
2620 | 	{ 0x1d4747, 0xeb, 0x0 },
2621 | 	{ 0x1d4748, 0x4, 0x68 },
2622 | 	{ 0x1d4749, 0x5a, 0x40 },
2623 | 	{ 0x1d474a, 0x58, 0x42 },
2624 | 	{ 0x1d474b, 0x7d, 0xf },
2625 | 	{ 0x1d474c, 0x1b, 0x0 },
2626 | 	{ 0x1d474d, 0xa1, 0x8b },
2627 | 	{ 0x1d474e, 0x10, 0x45 },
2628 | 	{ 0x1d474f, 0x9b, 0xe0 },
2629 | 	{ 0x1d4750, 0x64, 0x8b },
2630 | 	{ 0x1d4751, 0x0, 0x55 },
2631 | 	{ 0x1d4752, 0x8b, 0xe4 },
2632 | 	{ 0x1d4753, 0x55, 0xe8 },
2633 | 	{ 0x1d4754, 0xdc, 0xf8 },
2634 | 	{ 0x1d4755, 0x89, 0x3f },
2635 | 	{ 0x1d4756, 0x10, 0xe3 },
2636 | 	{ 0x1d4757, 0x33, 0xff },
2637 | 	{ 0x1d4758, 0xc0, 0x3b },
2638 | 	{ 0x1d4759, 0x89, 0x54 },
2639 | 	{ 0x1d475a, 0x45, 0x24 },
2640 | 	{ 0x1d475b, 0xdc, 0x4 },
2641 | 	{ 0x1d475c, 0x8b, 0x75 },
2642 | 	{ 0x1d475d, 0x45, 0x9 },
2643 | 	{ 0x1d475e, 0xf8, 0x3b },
2644 | 	{ 0x1d475f, 0x89, 0x4 },
2645 | 	{ 0x1d4760, 0x45, 0x24 },
2646 | 	{ 0x1d4761, 0xe0, 0x5a },
2647 | 	{ 0x1d4762, 0x8b, 0x58 },
2648 | 	{ 0x1d4763, 0x45, 0x73 },
2649 | 	{ 0x1d4764, 0xfc, 0x21 },
2650 | 	{ 0x1d4765, 0x89, 0xeb },
2651 | 	{ 0x1d4766, 0x45, 0x4 },
2652 | 	{ 0x1d4767, 0xe4, 0x5a },
2653 | 	{ 0x1d4768, 0xff, 0x58 },
2654 | 	{ 0x1d4769, 0x45, 0x7d },
2655 | 	{ 0x1d476a, 0xdc, 0x1b },
2656 | 	{ 0x1d476c, 0x78, 0x10 },
2657 | 	{ 0x1d476d, 0x9d, 0x9b },
2658 | 	{ 0x1d4770, 0x83, 0x8b },
2659 | 	{ 0x1d4771, 0x38, 0x55 },
2660 | 	{ 0x1d4772, 0xff, 0xdc },
2661 | 	{ 0x1d4773, 0x75, 0x89 },
2662 | 	{ 0x1d4774, 0x14, 0x10 },
2663 | 	{ 0x1d4775, 0xa1, 0x33 },
2664 | 	{ 0x1d4776, 0xb0, 0xc0 },
2665 | 	{ 0x1d4777, 0xa1, 0x89 },
2666 | 	{ 0x1d4778, 0x64, 0x45 },
2667 | 	{ 0x1d4779, 0x0, 0xdc },
2668 | 	{ 0x1d477a, 0x80, 0x8b },
2669 | 	{ 0x1d477b, 0x38, 0x45 },
2670 | 	{ 0x1d477c, 0x0, 0xf8 },
2671 | 	{ 0x1d477d, 0x74, 0x89 },
2672 | 	{ 0x1d477e, 0xa, 0x45 },
2673 | 	{ 0x1d477f, 0xe8, 0xe0 },
2674 | 	{ 0x1d4780, 0xc, 0x8b },
2675 | 	{ 0x1d4781, 0x11, 0x45 },
2676 | 	{ 0x1d4782, 0xf6, 0xfc },
2677 | 	{ 0x1d4783, 0xff, 0x89 },
2678 | 	{ 0x1d4784, 0xe8, 0x45 },
2679 | 	{ 0x1d4785, 0xe7, 0xe4 },
2680 | 	{ 0x1d4786, 0x10, 0xff },
2681 | 	{ 0x1d4787, 0xf6, 0x45 },
2682 | 	{ 0x1d4788, 0xff, 0xdc },
2683 | 	{-1,0,0}
2684 | };
2685 | 
2686 | PatchByte inputlagpatch_81_71[] = {
2687 | 	{ 0x1d4733, 0xe8, 0xa1 },
2688 | 	{ 0x1d4734, 0xb8, 0x80 },
2689 | 	{ 0x1d4735, 0x8a, 0x9d },
2690 | 	{ 0x1d4736, 0xf5, 0x64 },
2691 | 	{ 0x1d4737, 0xff, 0x0 },
2692 | 	{ 0x1d4738, 0x89, 0x83 },
2693 | 	{ 0x1d4739, 0x45, 0x38 },
2694 | 	{ 0x1d473a, 0xf0, 0xff },
2695 | 	{ 0x1d473b, 0x89, 0x75 },
2696 | 	{ 0x1d473c, 0x55, 0x14 },
2697 | 	{ 0x1d473d, 0xf4, 0xa1 },
2698 | 	{ 0x1d473e, 0x8b, 0xb8 },
2699 | 	{ 0x1d473f, 0x45, 0xa1 },
2700 | 	{ 0x1d4740, 0xf0, 0x64 },
2701 | 	{ 0x1d4741, 0x8b, 0x0 },
2702 | 	{ 0x1d4742, 0x55, 0x80 },
2703 | 	{ 0x1d4743, 0xf4, 0x38 },
2704 | 	{ 0x1d4744, 0x3b, 0x0 },
2705 | 	{ 0x1d4745, 0x55, 0x74 },
2706 | 	{ 0x1d4746, 0xfc, 0xa },
2707 | 	{ 0x1d4747, 0x75, 0xe8 },
2708 | 	{ 0x1d4748, 0x7, 0x44 },
2709 | 	{ 0x1d4749, 0x3b, 0x11 },
2710 | 	{ 0x1d474a, 0x45, 0xf6 },
2711 | 	{ 0x1d474b, 0xf8, 0xff },
2712 | 	{ 0x1d474c, 0x73, 0xe8 },
2713 | 	{ 0x1d474d, 0x10, 0x1f },
2714 | 	{ 0x1d474e, 0xeb, 0x11 },
2715 | 	{ 0x1d474f, 0x2, 0xf6 },
2716 | 	{ 0x1d4750, 0x7d, 0xff },
2717 | 	{ 0x1d4751, 0xc, 0xe8 },
2718 | 	{ 0x1d4752, 0x8b, 0x9a },
2719 | 	{ 0x1d4753, 0x45, 0x8a },
2720 | 	{ 0x1d4754, 0xf0, 0xf5 },
2721 | 	{ 0x1d4755, 0x89, 0xff },
2722 | 	{ 0x1d4756, 0x45, 0x89 },
2723 | 	{ 0x1d4757, 0xf8, 0x45 },
2724 | 	{ 0x1d4758, 0x8b, 0xf0 },
2725 | 	{ 0x1d4759, 0x45, 0x89 },
2726 | 	{ 0x1d475a, 0xf4, 0x55 },
2727 | 	{ 0x1d475b, 0x89, 0xf4 },
2728 | 	{ 0x1d475c, 0x45, 0x8b },
2729 | 	{ 0x1d475d, 0xfc, 0x45 },
2730 | 	{ 0x1d475e, 0xa1, 0xf0 },
2731 | 	{ 0x1d475f, 0x24, 0x8b },
2732 | 	{ 0x1d4760, 0xa3, 0x55 },
2733 | 	{ 0x1d4761, 0x64, 0xf4 },
2734 | 	{ 0x1d4762, 0x0, 0x3b },
2735 | 	{ 0x1d4763, 0x8b, 0x55 },
2736 | 	{ 0x1d4764, 0x0, 0xfc },
2737 | 	{ 0x1d4765, 0x83, 0x75 },
2738 | 	{ 0x1d4766, 0x78, 0x7 },
2739 | 	{ 0x1d4767, 0x8, 0x3b },
2740 | 	{ 0x1d4768, 0x0, 0x45 },
2741 | 	{ 0x1d4769, 0x7f, 0xf8 },
2742 | 	{ 0x1d476a, 0xe, 0x73 },
2743 | 	{ 0x1d476b, 0xa1, 0x10 },
2744 | 	{ 0x1d476c, 0x24, 0xeb },
2745 | 	{ 0x1d476d, 0xa3, 0x2 },
2746 | 	{ 0x1d476e, 0x64, 0x7d },
2747 | 	{ 0x1d476f, 0x0, 0xc },
2748 | 	{ 0x1d4771, 0x0, 0x45 },
2749 | 	{ 0x1d4772, 0xc7, 0xf0 },
2750 | 	{ 0x1d4773, 0x40, 0x89 },
2751 | 	{ 0x1d4774, 0x8, 0x45 },
2752 | 	{ 0x1d4775, 0x1, 0xf8 },
2753 | 	{ 0x1d4776, 0x0, 0x8b },
2754 | 	{ 0x1d4777, 0x0, 0x45 },
2755 | 	{ 0x1d4778, 0x0, 0xf4 },
2756 | 	{ 0x1d4779, 0xa1, 0x89 },
2757 | 	{ 0x1d477a, 0x24, 0x45 },
2758 | 	{ 0x1d477b, 0xa3, 0xfc },
2759 | 	{ 0x1d477c, 0x64, 0xa1 },
2760 | 	{ 0x1d477d, 0x0, 0x24 },
2761 | 	{ 0x1d477e, 0x8b, 0xa3 },
2762 | 	{ 0x1d477f, 0x0, 0x64 },
2763 | 	{ 0x1d4780, 0xff, 0x0 },
2764 | 	{ 0x1d4781, 0x70, 0x8b },
2765 | 	{ 0x1d4782, 0x8, 0x0 },
2766 | 	{ 0x1d4783, 0xb8, 0x83 },
2767 | 	{ 0x1d4784, 0x40, 0x78 },
2768 | 	{ 0x1d4785, 0x42, 0x8 },
2769 | 	{ 0x1d4786, 0xf, 0x0 },
2770 | 	{ 0x1d4787, 0x0, 0x7f },
2771 | 	{ 0x1d4788, 0x5a, 0xe },
2772 | 	{ 0x1d4789, 0x8b, 0xa1 },
2773 | 	{ 0x1d478a, 0xca, 0x24 },
2774 | 	{ 0x1d478b, 0x99, 0xa3 },
2775 | 	{ 0x1d478c, 0xf7, 0x64 },
2776 | 	{ 0x1d478d, 0xf9, 0x0 },
2777 | 	{ 0x1d478e, 0x99, 0x8b },
2778 | 	{ 0x1d478f, 0x52, 0x0 },
2779 | 	{ 0x1d4790, 0x50, 0xc7 },
2780 | 	{ 0x1d4791, 0x8b, 0x40 },
2781 | 	{ 0x1d4792, 0x45, 0x8 },
2782 | 	{ 0x1d4793, 0xf0, 0x1 },
2783 | 	{ 0x1d4794, 0x8b, 0x0 },
2784 | 	{ 0x1d4795, 0x55, 0x0 },
2785 | 	{ 0x1d4796, 0xf4, 0x0 },
2786 | 	{ 0x1d4797, 0x2b, 0xa1 },
2787 | 	{ 0x1d4798, 0x45, 0x24 },
2788 | 	{ 0x1d4799, 0xf8, 0xa3 },
2789 | 	{ 0x1d479a, 0x1b, 0x64 },
2790 | 	{ 0x1d479b, 0x55, 0x0 },
2791 | 	{ 0x1d479c, 0xfc, 0x8b },
2792 | 	{ 0x1d479d, 0x29, 0x0 },
2793 | 	{ 0x1d479e, 0x4, 0xff },
2794 | 	{ 0x1d479f, 0x24, 0x70 },
2795 | 	{ 0x1d47a0, 0x19, 0x8 },
2796 | 	{ 0x1d47a1, 0x54, 0xb8 },
2797 | 	{ 0x1d47a2, 0x24, 0x40 },
2798 | 	{ 0x1d47a3, 0x4, 0x42 },
2799 | 	{ 0x1d47a4, 0x58, 0xf },
2800 | 	{ 0x1d47a5, 0x5a, 0x0 },
2801 | 	{ 0x1d47a6, 0x89, 0x5a },
2802 | 	{ 0x1d47a7, 0x45, 0x8b },
2803 | 	{ 0x1d47a8, 0xd0, 0xca },
2804 | 	{ 0x1d47a9, 0x89, 0x99 },
2805 | 	{ 0x1d47aa, 0x55, 0xf7 },
2806 | 	{ 0x1d47ab, 0xd4, 0xf9 },
2807 | 	{ 0x1d47ac, 0x83, 0x99 },
2808 | 	{ 0x1d47ad, 0x7d, 0x52 },
2809 | 	{ 0x1d47ae, 0xd4, 0x50 },
2810 | 	{ 0x1d47af, 0x0, 0x8b },
2811 | 	{ 0x1d47b0, 0x75, 0x45 },
2812 | 	{ 0x1d47b1, 0x8, 0xf0 },
2813 | 	{ 0x1d47b2, 0x83, 0x8b },
2814 | 	{ 0x1d47b3, 0x7d, 0x55 },
2815 | 	{ 0x1d47b4, 0xd0, 0xf4 },
2816 | 	{ 0x1d47b5, 0x0, 0x2b },
2817 | 	{ 0x1d47b6, 0x73, 0x45 },
2818 | 	{ 0x1d47b7, 0x14, 0xf8 },
2819 | 	{ 0x1d47b8, 0xeb, 0x1b },
2820 | 	{ 0x1d47b9, 0x2, 0x55 },
2821 | 	{ 0x1d47ba, 0x7d, 0xfc },
2822 | 	{ 0x1d47bb, 0x10, 0x29 },
2823 | 	{ 0x1d47bc, 0xc7, 0x4 },
2824 | 	{ 0x1d47bd, 0x45, 0x24 },
2825 | 	{ 0x1d47be, 0xc8, 0x19 },
2826 | 	{ 0x1d47bf, 0x0, 0x54 },
2827 | 	{ 0x1d47c0, 0x0, 0x24 },
2828 | 	{ 0x1d47c1, 0x0, 0x4 },
2829 | 	{ 0x1d47c2, 0x0, 0x58 },
2830 | 	{ 0x1d47c3, 0xc7, 0x5a },
2831 | 	{ 0x1d47c4, 0x45, 0x89 },
2832 | 	{ 0x1d47c5, 0xcc, 0x45 },
2833 | 	{ 0x1d47c6, 0x0, 0xd0 },
2834 | 	{ 0x1d47c7, 0x0, 0x89 },
2835 | 	{ 0x1d47c8, 0x0, 0x55 },
2836 | 	{ 0x1d47c9, 0x0, 0xd4 },
2837 | 	{ 0x1d47ca, 0xeb, 0x83 },
2838 | 	{ 0x1d47cb, 0xc, 0x7d },
2839 | 	{ 0x1d47cc, 0x8b, 0xd4 },
2840 | 	{ 0x1d47cd, 0x45, 0x0 },
2841 | 	{ 0x1d47ce, 0xd0, 0x75 },
2842 | 	{ 0x1d47cf, 0x89, 0x8 },
2843 | 	{ 0x1d47d0, 0x45, 0x83 },
2844 | 	{ 0x1d47d1, 0xc8, 0x7d },
2845 | 	{ 0x1d47d2, 0x8b, 0xd0 },
2846 | 	{ 0x1d47d3, 0x45, 0x0 },
2847 | 	{ 0x1d47d4, 0xd4, 0x73 },
2848 | 	{ 0x1d47d5, 0x89, 0x14 },
2849 | 	{ 0x1d47d6, 0x45, 0xeb },
2850 | 	{ 0x1d47d7, 0xcc, 0x2 },
2851 | 	{ 0x1d47d8, 0x8b, 0x7d },
2852 | 	{ 0x1d47d9, 0x45, 0x10 },
2853 | 	{ 0x1d47da, 0xc8, 0xc7 },
2854 | 	{ 0x1d47db, 0x89, 0x45 },
2855 | 	{ 0x1d47dc, 0x45, 0xc8 },
2856 | 	{ 0x1d47dd, 0xe8, 0x0 },
2857 | 	{ 0x1d47de, 0x8b, 0x0 },
2858 | 	{ 0x1d47df, 0x45, 0x0 },
2859 | 	{ 0x1d47e0, 0xcc, 0x0 },
2860 | 	{ 0x1d47e1, 0x89, 0xc7 },
2861 | 	{ 0x1d47e3, 0xec, 0xcc },
2862 | 	{ 0x1d47e4, 0x83, 0x0 },
2863 | 	{ 0x1d47e5, 0x7d, 0x0 },
2864 | 	{ 0x1d47e6, 0xec, 0x0 },
2865 | 	{ 0x1d47e8, 0x75, 0xeb },
2866 | 	{ 0x1d47e9, 0xb, 0xc },
2867 | 	{ 0x1d47ea, 0x81, 0x8b },
2868 | 	{ 0x1d47eb, 0x7d, 0x45 },
2869 | 	{ 0x1d47ec, 0xe8, 0xd0 },
2870 | 	{ 0x1d47ed, 0x40, 0x89 },
2871 | 	{ 0x1d47ee, 0x42, 0x45 },
2872 | 	{ 0x1d47ef, 0xf, 0xc8 },
2873 | 	{ 0x1d47f0, 0x0, 0x8b },
2874 | 	{ 0x1d47f1, 0x73, 0x45 },
2875 | 	{ 0x1d47f2, 0x12, 0xd4 },
2876 | 	{ 0x1d47f3, 0xeb, 0x89 },
2877 | 	{ 0x1d47f4, 0x2, 0x45 },
2878 | 	{ 0x1d47f5, 0x7d, 0xcc },
2879 | 	{ 0x1d47f6, 0xe, 0x8b },
2880 | 	{ 0x1d47f7, 0x8b, 0x45 },
2881 | 	{ 0x1d47f8, 0x45, 0xc8 },
2882 | 	{ 0x1d47f9, 0xe8, 0x89 },
2883 | 	{ 0x1d47fa, 0x89, 0x45 },
2884 | 	{ 0x1d47fb, 0x45, 0xe8 },
2885 | 	{ 0x1d47fc, 0xc0, 0x8b },
2886 | 	{ 0x1d47fd, 0x8b, 0x45 },
2887 | 	{ 0x1d47fe, 0x45, 0xcc },
2888 | 	{ 0x1d47ff, 0xec, 0x89 },
2889 | 	{ 0x1d4800, 0x89, 0x45 },
2890 | 	{ 0x1d4801, 0x45, 0xec },
2891 | 	{ 0x1d4802, 0xc4, 0x83 },
2892 | 	{ 0x1d4803, 0xeb, 0x7d },
2893 | 	{ 0x1d4804, 0xe, 0xec },
2894 | 	{ 0x1d4805, 0xc7, 0x0 },
2895 | 	{ 0x1d4806, 0x45, 0x75 },
2896 | 	{ 0x1d4807, 0xc0, 0xb },
2897 | 	{ 0x1d4808, 0x40, 0x81 },
2898 | 	{ 0x1d4809, 0x42, 0x7d },
2899 | 	{ 0x1d480a, 0xf, 0xe8 },
2900 | 	{ 0x1d480b, 0x0, 0x40 },
2901 | 	{ 0x1d480c, 0xc7, 0x42 },
2902 | 	{ 0x1d480d, 0x45, 0xf },
2903 | 	{ 0x1d480e, 0xc4, 0x0 },
2904 | 	{ 0x1d480f, 0x0, 0x73 },
2905 | 	{ 0x1d4810, 0x0, 0x12 },
2906 | 	{ 0x1d4811, 0x0, 0xeb },
2907 | 	{ 0x1d4812, 0x0, 0x2 },
2908 | 	{ 0x1d4813, 0x8b, 0x7d },
2909 | 	{ 0x1d4814, 0x45, 0xe },
2910 | 	{ 0x1d4815, 0xc0, 0x8b },
2911 | 	{ 0x1d4816, 0x89, 0x45 },
2912 | 	{ 0x1d4817, 0x45, 0xe8 },
2913 | 	{ 0x1d4818, 0xe8, 0x89 },
2914 | 	{ 0x1d4819, 0x8b, 0x45 },
2915 | 	{ 0x1d481a, 0x45, 0xc0 },
2916 | 	{ 0x1d481b, 0xc4, 0x8b },
2917 | 	{ 0x1d481c, 0x89, 0x45 },
2918 | 	{ 0x1d481d, 0x45, 0xec },
2919 | 	{ 0x1d481e, 0xec, 0x89 },
2920 | 	{ 0x1d481f, 0xff, 0x45 },
2921 | 	{ 0x1d4820, 0x75, 0xc4 },
2922 | 	{ 0x1d4821, 0xec, 0xeb },
2923 | 	{ 0x1d4822, 0xff, 0xe },
2924 | 	{ 0x1d4823, 0x75, 0xc7 },
2925 | 	{ 0x1d4824, 0xe8, 0x45 },
2926 | 	{ 0x1d4825, 0xe8, 0xc0 },
2927 | 	{ 0x1d4826, 0x52, 0x40 },
2928 | 	{ 0x1d4827, 0x8a, 0x42 },
2929 | 	{ 0x1d4828, 0xf5, 0xf },
2930 | 	{ 0x1d4829, 0xff, 0x0 },
2931 | 	{ 0x1d482a, 0x8b, 0xc7 },
2932 | 	{ 0x1d482c, 0xf0, 0xc4 },
2933 | 	{ 0x1d482d, 0x8b, 0x0 },
2934 | 	{ 0x1d482e, 0x55, 0x0 },
2935 | 	{ 0x1d482f, 0xf4, 0x0 },
2936 | 	{ 0x1d4830, 0x3, 0x0 },
2937 | 	{ 0x1d4831, 0x45, 0x8b },
2938 | 	{ 0x1d4832, 0xe8, 0x45 },
2939 | 	{ 0x1d4833, 0x13, 0xc0 },
2940 | 	{ 0x1d4834, 0x55, 0x89 },
2941 | 	{ 0x1d4835, 0xec, 0x45 },
2942 | 	{ 0x1d4836, 0x89, 0xe8 },
2943 | 	{ 0x1d4837, 0x45, 0x8b },
2944 | 	{ 0x1d4838, 0xf8, 0x45 },
2945 | 	{ 0x1d4839, 0x89, 0xc4 },
2946 | 	{ 0x1d483a, 0x55, 0x89 },
2947 | 	{ 0x1d483b, 0xfc, 0x45 },
2948 | 	{ 0x1d483c, 0x8b, 0xec },
2949 | 	{ 0x1d483d, 0x45, 0xff },
2950 | 	{ 0x1d483e, 0xf8, 0x75 },
2951 | 	{ 0x1d483f, 0x8b, 0xec },
2952 | 	{ 0x1d4840, 0x55, 0xff },
2953 | 	{ 0x1d4841, 0xfc, 0x75 },
2954 | 	{ 0x1d4842, 0x3b, 0xe8 },
2955 | 	{ 0x1d4843, 0x55, 0xe8 },
2956 | 	{ 0x1d4844, 0xe4, 0x34 },
2957 | 	{ 0x1d4845, 0x75, 0x8a },
2958 | 	{ 0x1d4846, 0x7, 0xf5 },
2959 | 	{ 0x1d4847, 0x3b, 0xff },
2960 | 	{ 0x1d4848, 0x45, 0x8b },
2961 | 	{ 0x1d4849, 0xe0, 0x45 },
2962 | 	{ 0x1d484a, 0x73, 0xf0 },
2963 | 	{ 0x1d484b, 0x10, 0x8b },
2964 | 	{ 0x1d484c, 0xeb, 0x55 },
2965 | 	{ 0x1d484d, 0x2, 0xf4 },
2966 | 	{ 0x1d484e, 0x7d, 0x3 },
2967 | 	{ 0x1d484f, 0xc, 0x45 },
2968 | 	{ 0x1d4850, 0x8b, 0xe8 },
2969 | 	{ 0x1d4851, 0x45, 0x13 },
2970 | 	{ 0x1d4852, 0xf8, 0x55 },
2971 | 	{ 0x1d4853, 0x89, 0xec },
2972 | 	{ 0x1d4854, 0x45, 0x89 },
2973 | 	{ 0x1d4855, 0xe0, 0x45 },
2974 | 	{ 0x1d4856, 0x8b, 0xf8 },
2975 | 	{ 0x1d4857, 0x45, 0x89 },
2976 | 	{ 0x1d4858, 0xfc, 0x55 },
2977 | 	{ 0x1d4859, 0x89, 0xfc },
2978 | 	{ 0x1d485a, 0x45, 0x8b },
2979 | 	{ 0x1d485b, 0xe4, 0x45 },
2980 | 	{ 0x1d485c, 0x6a, 0xf8 },
2981 | 	{ 0x1d485d, 0x0, 0x8b },
2982 | 	{ 0x1d485e, 0x68, 0x55 },
2983 | 	{ 0x1d485f, 0x40, 0xfc },
2984 | 	{ 0x1d4860, 0x42, 0x3b },
2985 | 	{ 0x1d4861, 0xf, 0x55 },
2986 | 	{ 0x1d4862, 0x0, 0xe4 },
2987 | 	{ 0x1d4863, 0x8b, 0x75 },
2988 | 	{ 0x1d4864, 0x45, 0x7 },
2989 | 	{ 0x1d4865, 0xf8, 0x3b },
2990 | 	{ 0x1d4866, 0x8b, 0x45 },
2991 | 	{ 0x1d4867, 0x55, 0xe0 },
2992 | 	{ 0x1d4868, 0xfc, 0x73 },
2993 | 	{ 0x1d4869, 0xe8, 0x10 },
2994 | 	{ 0x1d486a, 0xe2, 0xeb },
2995 | 	{ 0x1d486b, 0x3e, 0x2 },
2996 | 	{ 0x1d486c, 0xe3, 0x7d },
2997 | 	{ 0x1d486d, 0xff, 0xc },
2998 | 	{ 0x1d486e, 0x52, 0x8b },
2999 | 	{ 0x1d486f, 0x50, 0x45 },
3000 | 	{ 0x1d4870, 0x6a, 0xf8 },
3001 | 	{ 0x1d4871, 0x0, 0x89 },
3002 | 	{ 0x1d4872, 0x68, 0x45 },
3003 | 	{ 0x1d4873, 0x40, 0xe0 },
3004 | 	{ 0x1d4874, 0x42, 0x8b },
3005 | 	{ 0x1d4875, 0xf, 0x45 },
3006 | 	{ 0x1d4876, 0x0, 0xfc },
3007 | 	{ 0x1d4877, 0x8b, 0x89 },
3008 | 	{ 0x1d4879, 0xe0, 0xe4 },
3009 | 	{ 0x1d487a, 0x8b, 0x6a },
3010 | 	{ 0x1d487b, 0x55, 0x0 },
3011 | 	{ 0x1d487c, 0xe4, 0x68 },
3012 | 	{ 0x1d487d, 0xe8, 0x40 },
3013 | 	{ 0x1d487e, 0xce, 0x42 },
3014 | 	{ 0x1d487f, 0x3e, 0xf },
3015 | 	{ 0x1d4880, 0xe3, 0x0 },
3016 | 	{ 0x1d4881, 0xff, 0x8b },
3017 | 	{ 0x1d4882, 0x3b, 0x45 },
3018 | 	{ 0x1d4883, 0x54, 0xf8 },
3019 | 	{ 0x1d4884, 0x24, 0x8b },
3020 | 	{ 0x1d4885, 0x4, 0x55 },
3021 | 	{ 0x1d4886, 0x75, 0xfc },
3022 | 	{ 0x1d4887, 0x9, 0xe8 },
3023 | 	{ 0x1d4888, 0x3b, 0xc4 },
3024 | 	{ 0x1d4889, 0x4, 0x3e },
3025 | 	{ 0x1d488a, 0x24, 0xe3 },
3026 | 	{ 0x1d488b, 0x5a, 0xff },
3027 | 	{ 0x1d488c, 0x58, 0x52 },
3028 | 	{ 0x1d488d, 0x73, 0x50 },
3029 | 	{ 0x1d488e, 0x21, 0x6a },
3030 | 	{ 0x1d488f, 0xeb, 0x0 },
3031 | 	{ 0x1d4890, 0x4, 0x68 },
3032 | 	{ 0x1d4891, 0x5a, 0x40 },
3033 | 	{ 0x1d4892, 0x58, 0x42 },
3034 | 	{ 0x1d4893, 0x7d, 0xf },
3035 | 	{ 0x1d4894, 0x1b, 0x0 },
3036 | 	{ 0x1d4895, 0xa1, 0x8b },
3037 | 	{ 0x1d4896, 0x18, 0x45 },
3038 | 	{ 0x1d4897, 0x9b, 0xe0 },
3039 | 	{ 0x1d4898, 0x64, 0x8b },
3040 | 	{ 0x1d4899, 0x0, 0x55 },
3041 | 	{ 0x1d489a, 0x8b, 0xe4 },
3042 | 	{ 0x1d489b, 0x55, 0xe8 },
3043 | 	{ 0x1d489c, 0xdc, 0xb0 },
3044 | 	{ 0x1d489d, 0x89, 0x3e },
3045 | 	{ 0x1d489e, 0x10, 0xe3 },
3046 | 	{ 0x1d489f, 0x33, 0xff },
3047 | 	{ 0x1d48a0, 0xc0, 0x3b },
3048 | 	{ 0x1d48a1, 0x89, 0x54 },
3049 | 	{ 0x1d48a2, 0x45, 0x24 },
3050 | 	{ 0x1d48a3, 0xdc, 0x4 },
3051 | 	{ 0x1d48a4, 0x8b, 0x75 },
3052 | 	{ 0x1d48a5, 0x45, 0x9 },
3053 | 	{ 0x1d48a6, 0xf8, 0x3b },
3054 | 	{ 0x1d48a7, 0x89, 0x4 },
3055 | 	{ 0x1d48a8, 0x45, 0x24 },
3056 | 	{ 0x1d48a9, 0xe0, 0x5a },
3057 | 	{ 0x1d48aa, 0x8b, 0x58 },
3058 | 	{ 0x1d48ab, 0x45, 0x73 },
3059 | 	{ 0x1d48ac, 0xfc, 0x21 },
3060 | 	{ 0x1d48ad, 0x89, 0xeb },
3061 | 	{ 0x1d48ae, 0x45, 0x4 },
3062 | 	{ 0x1d48af, 0xe4, 0x5a },
3063 | 	{ 0x1d48b0, 0xff, 0x58 },
3064 | 	{ 0x1d48b1, 0x45, 0x7d },
3065 | 	{ 0x1d48b2, 0xdc, 0x1b },
3066 | 	{ 0x1d48b4, 0x80, 0x18 },
3067 | 	{ 0x1d48b5, 0x9d, 0x9b },
3068 | 	{ 0x1d48b8, 0x83, 0x8b },
3069 | 	{ 0x1d48b9, 0x38, 0x55 },
3070 | 	{ 0x1d48ba, 0xff, 0xdc },
3071 | 	{ 0x1d48bb, 0x75, 0x89 },
3072 | 	{ 0x1d48bc, 0x14, 0x10 },
3073 | 	{ 0x1d48bd, 0xa1, 0x33 },
3074 | 	{ 0x1d48be, 0xb8, 0xc0 },
3075 | 	{ 0x1d48bf, 0xa1, 0x89 },
3076 | 	{ 0x1d48c0, 0x64, 0x45 },
3077 | 	{ 0x1d48c1, 0x0, 0xdc },
3078 | 	{ 0x1d48c2, 0x80, 0x8b },
3079 | 	{ 0x1d48c3, 0x38, 0x45 },
3080 | 	{ 0x1d48c4, 0x0, 0xf8 },
3081 | 	{ 0x1d48c5, 0x74, 0x89 },
3082 | 	{ 0x1d48c6, 0xa, 0x45 },
3083 | 	{ 0x1d48c7, 0xe8, 0xe0 },
3084 | 	{ 0x1d48c8, 0xc4, 0x8b },
3085 | 	{ 0x1d48c9, 0xf, 0x45 },
3086 | 	{ 0x1d48ca, 0xf6, 0xfc },
3087 | 	{ 0x1d48cb, 0xff, 0x89 },
3088 | 	{ 0x1d48cc, 0xe8, 0x45 },
3089 | 	{ 0x1d48cd, 0x9f, 0xe4 },
3090 | 	{ 0x1d48ce, 0xf, 0xff },
3091 | 	{ 0x1d48cf, 0xf6, 0x45 },
3092 | 	{ 0x1d48d0, 0xff, 0xdc },
3093 | 	{-1,0,0}
3094 | };
3095 | 
3096 | PatchByte inputlagpatch_81_91[] = {
3097 | 	{ 0x1d1e6f, 0xe8, 0xa1 },
3098 |     { 0x1d1e70, 0x3c, 0x9c },
3099 |     { 0x1d1e71, 0xb5, 0xbd },
3100 |     { 0x1d1e72, 0xf5, 0x64 },
3101 |     { 0x1d1e73, 0xff, 0x0 },
3102 |     { 0x1d1e74, 0x89, 0x83 },
3103 |     { 0x1d1e75, 0x45, 0x38 },
3104 |     { 0x1d1e76, 0xf0, 0xff },
3105 |     { 0x1d1e77, 0x89, 0x75 },
3106 |     { 0x1d1e78, 0x55, 0x30 },
3107 |     { 0x1d1e79, 0xf4, 0xa1 },
3108 |     { 0x1d1e7a, 0x8b, 0xe4 },
3109 |     { 0x1d1e7b, 0x45, 0xc1 },
3110 |     { 0x1d1e7c, 0xf0, 0x64 },
3111 |     { 0x1d1e7d, 0x8b, 0x0 },
3112 |     { 0x1d1e7e, 0x55, 0x80 },
3113 |     { 0x1d1e7f, 0xf4, 0x38 },
3114 |     { 0x1d1e80, 0x3b, 0x0 },
3115 |     { 0x1d1e81, 0x55, 0x74 },
3116 |     { 0x1d1e82, 0xfc, 0x26 },
3117 |     { 0x1d1e83, 0x75, 0xe8 },
3118 |     { 0x1d1e84, 0x7, 0xf8 },
3119 |     { 0x1d1e85, 0x3b, 0x7e },
3120 |     { 0x1d1e86, 0x45, 0x1 },
3121 |     { 0x1d1e87, 0xf8, 0x0 },
3122 |     { 0x1d1e88, 0x73, 0xa1 },
3123 |     { 0x1d1e89, 0x10, 0xfc },
3124 |     { 0x1d1e8a, 0xeb, 0xbb },
3125 |     { 0x1d1e8b, 0x2, 0x64 },
3126 |     { 0x1d1e8c, 0x7d, 0x0 },
3127 |     { 0x1d1e8d, 0xc, 0x80 },
3128 |     { 0x1d1e8e, 0x8b, 0x38 },
3129 |     { 0x1d1e8f, 0x45, 0x0 },
3130 |     { 0x1d1e90, 0xf0, 0x74 },
3131 |     { 0x1d1e91, 0x89, 0x12 },
3132 |     { 0x1d1e92, 0x45, 0xe8 },
3133 |     { 0x1d1e93, 0xf8, 0xa1 },
3134 |     { 0x1d1e94, 0x8b, 0xbb },
3135 |     { 0x1d1e95, 0x45, 0xf5 },
3136 |     { 0x1d1e96, 0xf4, 0xff },
3137 |     { 0x1d1e97, 0x89, 0xe8 },
3138 |     { 0x1d1e98, 0x45, 0x90 },
3139 |     { 0x1d1e99, 0xfc, 0x79 },
3140 |     { 0x1d1e9a, 0xa1, 0x1 },
3141 |     { 0x1d1e9b, 0x50, 0x0 },
3142 |     { 0x1d1e9c, 0xc3, 0xa1 },
3143 |     { 0x1d1e9d, 0x64, 0xfc },
3144 |     { 0x1d1e9e, 0x0, 0xbb },
3145 |     { 0x1d1e9f, 0x8b, 0x64 },
3146 |     { 0x1d1ea1, 0x83, 0xc6 },
3147 |     { 0x1d1ea2, 0x78, 0x0 },
3148 |     { 0x1d1ea3, 0x8, 0x0 },
3149 |     { 0x1d1ea4, 0x0, 0xe8 },
3150 |     { 0x1d1ea5, 0x7f, 0xb7 },
3151 |     { 0x1d1ea6, 0xe, 0x7e },
3152 |     { 0x1d1ea7, 0xa1, 0x1 },
3153 |     { 0x1d1ea8, 0x50, 0x0 },
3154 |     { 0x1d1ea9, 0xc3, 0xe8 },
3155 |     { 0x1d1eaa, 0x64, 0x2 },
3156 |     { 0x1d1eab, 0x0, 0xb5 },
3157 |     { 0x1d1eac, 0x8b, 0xf5 },
3158 |     { 0x1d1ead, 0x0, 0xff },
3159 |     { 0x1d1eae, 0xc7, 0x89 },
3160 |     { 0x1d1eaf, 0x40, 0x45 },
3161 |     { 0x1d1eb0, 0x8, 0xf0 },
3162 |     { 0x1d1eb1, 0x1, 0x89 },
3163 |     { 0x1d1eb2, 0x0, 0x55 },
3164 |     { 0x1d1eb3, 0x0, 0xf4 },
3165 |     { 0x1d1eb4, 0x0, 0x8b },
3166 |     { 0x1d1eb5, 0xa1, 0x45 },
3167 |     { 0x1d1eb6, 0x50, 0xf0 },
3168 |     { 0x1d1eb7, 0xc3, 0x8b },
3169 |     { 0x1d1eb8, 0x64, 0x55 },
3170 |     { 0x1d1eb9, 0x0, 0xf4 },
3171 |     { 0x1d1eba, 0x8b, 0x3b },
3172 |     { 0x1d1ebb, 0x0, 0x55 },
3173 |     { 0x1d1ebc, 0xff, 0xfc },
3174 |     { 0x1d1ebd, 0x70, 0x75 },
3175 |     { 0x1d1ebe, 0x8, 0x7 },
3176 |     { 0x1d1ebf, 0xb8, 0x3b },
3177 |     { 0x1d1ec0, 0x40, 0x45 },
3178 |     { 0x1d1ec1, 0x42, 0xf8 },
3179 |     { 0x1d1ec2, 0xf, 0x73 },
3180 |     { 0x1d1ec3, 0x0, 0x10 },
3181 |     { 0x1d1ec4, 0x5a, 0xeb },
3182 |     { 0x1d1ec5, 0x8b, 0x2 },
3183 |     { 0x1d1ec6, 0xca, 0x7d },
3184 |     { 0x1d1ec7, 0x99, 0xc },
3185 |     { 0x1d1ec8, 0xf7, 0x8b },
3186 |     { 0x1d1ec9, 0xf9, 0x45 },
3187 |     { 0x1d1eca, 0x99, 0xf0 },
3188 |     { 0x1d1ecb, 0x52, 0x89 },
3189 |     { 0x1d1ecc, 0x50, 0x45 },
3190 |     { 0x1d1ecd, 0x8b, 0xf8 },
3191 |     { 0x1d1ece, 0x45, 0x8b },
3192 |     { 0x1d1ecf, 0xf0, 0x45 },
3193 |     { 0x1d1ed0, 0x8b, 0xf4 },
3194 |     { 0x1d1ed1, 0x55, 0x89 },
3195 |     { 0x1d1ed2, 0xf4, 0x45 },
3196 |     { 0x1d1ed3, 0x2b, 0xfc },
3197 |     { 0x1d1ed4, 0x45, 0xa1 },
3198 |     { 0x1d1ed5, 0xf8, 0x50 },
3199 |     { 0x1d1ed6, 0x1b, 0xc3 },
3200 |     { 0x1d1ed7, 0x55, 0x64 },
3201 |     { 0x1d1ed8, 0xfc, 0x0 },
3202 |     { 0x1d1ed9, 0x29, 0x8b },
3203 |     { 0x1d1eda, 0x4, 0x0 },
3204 |     { 0x1d1edb, 0x24, 0x83 },
3205 |     { 0x1d1edc, 0x19, 0x78 },
3206 |     { 0x1d1edd, 0x54, 0x8 },
3207 |     { 0x1d1ede, 0x24, 0x0 },
3208 |     { 0x1d1edf, 0x4, 0x7f },
3209 |     { 0x1d1ee0, 0x58, 0xe },
3210 |     { 0x1d1ee1, 0x5a, 0xa1 },
3211 |     { 0x1d1ee2, 0x89, 0x50 },
3212 |     { 0x1d1ee3, 0x45, 0xc3 },
3213 |     { 0x1d1ee4, 0xd0, 0x64 },
3214 |     { 0x1d1ee5, 0x89, 0x0 },
3215 |     { 0x1d1ee6, 0x55, 0x8b },
3216 |     { 0x1d1ee7, 0xd4, 0x0 },
3217 |     { 0x1d1ee8, 0x83, 0xc7 },
3218 |     { 0x1d1ee9, 0x7d, 0x40 },
3219 |     { 0x1d1eea, 0xd4, 0x8 },
3220 |     { 0x1d1eeb, 0x0, 0x1 },
3221 |     { 0x1d1eec, 0x75, 0x0 },
3222 |     { 0x1d1eed, 0x8, 0x0 },
3223 |     { 0x1d1eee, 0x83, 0x0 },
3224 |     { 0x1d1eef, 0x7d, 0xa1 },
3225 |     { 0x1d1ef0, 0xd0, 0x50 },
3226 |     { 0x1d1ef1, 0x0, 0xc3 },
3227 |     { 0x1d1ef2, 0x73, 0x64 },
3228 |     { 0x1d1ef3, 0x14, 0x0 },
3229 |     { 0x1d1ef4, 0xeb, 0x8b },
3230 |     { 0x1d1ef5, 0x2, 0x0 },
3231 |     { 0x1d1ef6, 0x7d, 0xff },
3232 |     { 0x1d1ef7, 0x10, 0x70 },
3233 |     { 0x1d1ef8, 0xc7, 0x8 },
3234 |     { 0x1d1ef9, 0x45, 0xb8 },
3235 |     { 0x1d1efa, 0xc8, 0x40 },
3236 |     { 0x1d1efb, 0x0, 0x42 },
3237 |     { 0x1d1efc, 0x0, 0xf },
3238 |     { 0x1d1efe, 0x0, 0x5a },
3239 |     { 0x1d1eff, 0xc7, 0x8b },
3240 |     { 0x1d1f00, 0x45, 0xca },
3241 |     { 0x1d1f01, 0xcc, 0x99 },
3242 |     { 0x1d1f02, 0x0, 0xf7 },
3243 |     { 0x1d1f03, 0x0, 0xf9 },
3244 |     { 0x1d1f04, 0x0, 0x99 },
3245 |     { 0x1d1f05, 0x0, 0x52 },
3246 |     { 0x1d1f06, 0xeb, 0x50 },
3247 |     { 0x1d1f07, 0xc, 0x8b },
3248 |     { 0x1d1f08, 0x8b, 0x45 },
3249 |     { 0x1d1f09, 0x45, 0xf0 },
3250 |     { 0x1d1f0a, 0xd0, 0x8b },
3251 |     { 0x1d1f0b, 0x89, 0x55 },
3252 |     { 0x1d1f0c, 0x45, 0xf4 },
3253 |     { 0x1d1f0d, 0xc8, 0x2b },
3254 |     { 0x1d1f0e, 0x8b, 0x45 },
3255 |     { 0x1d1f0f, 0x45, 0xf8 },
3256 |     { 0x1d1f10, 0xd4, 0x1b },
3257 |     { 0x1d1f11, 0x89, 0x55 },
3258 |     { 0x1d1f12, 0x45, 0xfc },
3259 |     { 0x1d1f13, 0xcc, 0x29 },
3260 |     { 0x1d1f14, 0x8b, 0x4 },
3261 |     { 0x1d1f15, 0x45, 0x24 },
3262 |     { 0x1d1f16, 0xc8, 0x19 },
3263 |     { 0x1d1f17, 0x89, 0x54 },
3264 |     { 0x1d1f18, 0x45, 0x24 },
3265 |     { 0x1d1f19, 0xe8, 0x4 },
3266 |     { 0x1d1f1a, 0x8b, 0x58 },
3267 |     { 0x1d1f1b, 0x45, 0x5a },
3268 |     { 0x1d1f1c, 0xcc, 0x89 },
3269 |     { 0x1d1f1d, 0x89, 0x45 },
3270 |     { 0x1d1f1e, 0x45, 0xd0 },
3271 |     { 0x1d1f1f, 0xec, 0x89 },
3272 |     { 0x1d1f20, 0x83, 0x55 },
3273 |     { 0x1d1f21, 0x7d, 0xd4 },
3274 |     { 0x1d1f22, 0xec, 0x83 },
3275 |     { 0x1d1f23, 0x0, 0x7d },
3276 |     { 0x1d1f24, 0x75, 0xd4 },
3277 |     { 0x1d1f25, 0xb, 0x0 },
3278 |     { 0x1d1f26, 0x81, 0x75 },
3279 |     { 0x1d1f27, 0x7d, 0x8 },
3280 |     { 0x1d1f28, 0xe8, 0x83 },
3281 |     { 0x1d1f29, 0x40, 0x7d },
3282 |     { 0x1d1f2a, 0x42, 0xd0 },
3283 |     { 0x1d1f2b, 0xf, 0x0 },
3284 |     { 0x1d1f2c, 0x0, 0x73 },
3285 |     { 0x1d1f2d, 0x73, 0x14 },
3286 |     { 0x1d1f2e, 0x12, 0xeb },
3287 |     { 0x1d1f2f, 0xeb, 0x2 },
3288 |     { 0x1d1f30, 0x2, 0x7d },
3289 |     { 0x1d1f31, 0x7d, 0x10 },
3290 |     { 0x1d1f32, 0xe, 0xc7 },
3291 |     { 0x1d1f33, 0x8b, 0x45 },
3292 |     { 0x1d1f34, 0x45, 0xc8 },
3293 |     { 0x1d1f35, 0xe8, 0x0 },
3294 |     { 0x1d1f36, 0x89, 0x0 },
3295 |     { 0x1d1f37, 0x45, 0x0 },
3296 |     { 0x1d1f38, 0xc0, 0x0 },
3297 |     { 0x1d1f39, 0x8b, 0xc7 },
3298 |     { 0x1d1f3b, 0xec, 0xcc },
3299 |     { 0x1d1f3c, 0x89, 0x0 },
3300 |     { 0x1d1f3d, 0x45, 0x0 },
3301 |     { 0x1d1f3e, 0xc4, 0x0 },
3302 |     { 0x1d1f3f, 0xeb, 0x0 },
3303 |     { 0x1d1f40, 0xe, 0xeb },
3304 |     { 0x1d1f41, 0xc7, 0xc },
3305 |     { 0x1d1f42, 0x45, 0x8b },
3306 |     { 0x1d1f43, 0xc0, 0x45 },
3307 |     { 0x1d1f44, 0x40, 0xd0 },
3308 |     { 0x1d1f45, 0x42, 0x89 },
3309 |     { 0x1d1f46, 0xf, 0x45 },
3310 |     { 0x1d1f47, 0x0, 0xc8 },
3311 |     { 0x1d1f48, 0xc7, 0x8b },
3312 |     { 0x1d1f4a, 0xc4, 0xd4 },
3313 |     { 0x1d1f4b, 0x0, 0x89 },
3314 |     { 0x1d1f4c, 0x0, 0x45 },
3315 |     { 0x1d1f4d, 0x0, 0xcc },
3316 |     { 0x1d1f4e, 0x0, 0x8b },
3317 |     { 0x1d1f4f, 0x8b, 0x45 },
3318 |     { 0x1d1f50, 0x45, 0xc8 },
3319 |     { 0x1d1f51, 0xc0, 0x89 },
3320 |     { 0x1d1f52, 0x89, 0x45 },
3321 |     { 0x1d1f53, 0x45, 0xe8 },
3322 |     { 0x1d1f54, 0xe8, 0x8b },
3323 |     { 0x1d1f55, 0x8b, 0x45 },
3324 |     { 0x1d1f56, 0x45, 0xcc },
3325 |     { 0x1d1f57, 0xc4, 0x89 },
3326 |     { 0x1d1f58, 0x89, 0x45 },
3327 |     { 0x1d1f59, 0x45, 0xec },
3328 |     { 0x1d1f5a, 0xec, 0x83 },
3329 |     { 0x1d1f5b, 0xff, 0x7d },
3330 |     { 0x1d1f5c, 0x75, 0xec },
3331 |     { 0x1d1f5d, 0xec, 0x0 },
3332 |     { 0x1d1f5e, 0xff, 0x75 },
3333 |     { 0x1d1f5f, 0x75, 0xb },
3334 |     { 0x1d1f60, 0xe8, 0x81 },
3335 |     { 0x1d1f61, 0xe8, 0x7d },
3336 |     { 0x1d1f62, 0xd6, 0xe8 },
3337 |     { 0x1d1f63, 0xb4, 0x40 },
3338 |     { 0x1d1f64, 0xf5, 0x42 },
3339 |     { 0x1d1f65, 0xff, 0xf },
3340 |     { 0x1d1f66, 0x8b, 0x0 },
3341 |     { 0x1d1f67, 0x45, 0x73 },
3342 |     { 0x1d1f68, 0xf0, 0x12 },
3343 |     { 0x1d1f69, 0x8b, 0xeb },
3344 |     { 0x1d1f6a, 0x55, 0x2 },
3345 |     { 0x1d1f6b, 0xf4, 0x7d },
3346 |     { 0x1d1f6c, 0x3, 0xe },
3347 |     { 0x1d1f6d, 0x45, 0x8b },
3348 |     { 0x1d1f6e, 0xe8, 0x45 },
3349 |     { 0x1d1f6f, 0x13, 0xe8 },
3350 |     { 0x1d1f70, 0x55, 0x89 },
3351 |     { 0x1d1f71, 0xec, 0x45 },
3352 |     { 0x1d1f72, 0x89, 0xc0 },
3353 |     { 0x1d1f73, 0x45, 0x8b },
3354 |     { 0x1d1f74, 0xf8, 0x45 },
3355 |     { 0x1d1f75, 0x89, 0xec },
3356 |     { 0x1d1f76, 0x55, 0x89 },
3357 |     { 0x1d1f77, 0xfc, 0x45 },
3358 |     { 0x1d1f78, 0x8b, 0xc4 },
3359 |     { 0x1d1f79, 0x45, 0xeb },
3360 |     { 0x1d1f7a, 0xf8, 0xe },
3361 |     { 0x1d1f7b, 0x8b, 0xc7 },
3362 |     { 0x1d1f7c, 0x55, 0x45 },
3363 |     { 0x1d1f7d, 0xfc, 0xc0 },
3364 |     { 0x1d1f7e, 0x3b, 0x40 },
3365 |     { 0x1d1f7f, 0x55, 0x42 },
3366 |     { 0x1d1f80, 0xe4, 0xf },
3367 |     { 0x1d1f81, 0x75, 0x0 },
3368 |     { 0x1d1f82, 0x7, 0xc7 },
3369 |     { 0x1d1f83, 0x3b, 0x45 },
3370 |     { 0x1d1f84, 0x45, 0xc4 },
3371 |     { 0x1d1f85, 0xe0, 0x0 },
3372 |     { 0x1d1f86, 0x73, 0x0 },
3373 |     { 0x1d1f87, 0x10, 0x0 },
3374 |     { 0x1d1f88, 0xeb, 0x0 },
3375 |     { 0x1d1f89, 0x2, 0x8b },
3376 |     { 0x1d1f8a, 0x7d, 0x45 },
3377 |     { 0x1d1f8b, 0xc, 0xc0 },
3378 |     { 0x1d1f8c, 0x8b, 0x89 },
3379 |     { 0x1d1f8e, 0xf8, 0xe8 },
3380 |     { 0x1d1f8f, 0x89, 0x8b },
3381 |     { 0x1d1f91, 0xe0, 0xc4 },
3382 |     { 0x1d1f92, 0x8b, 0x89 },
3383 |     { 0x1d1f94, 0xfc, 0xec },
3384 |     { 0x1d1f95, 0x89, 0xff },
3385 |     { 0x1d1f96, 0x45, 0x75 },
3386 |     { 0x1d1f97, 0xe4, 0xec },
3387 |     { 0x1d1f98, 0x6a, 0xff },
3388 |     { 0x1d1f99, 0x0, 0x75 },
3389 |     { 0x1d1f9a, 0x68, 0xe8 },
3390 |     { 0x1d1f9b, 0x40, 0xe8 },
3391 |     { 0x1d1f9c, 0x42, 0x9c },
3392 |     { 0x1d1f9d, 0xf, 0xb4 },
3393 |     { 0x1d1f9e, 0x0, 0xf5 },
3394 |     { 0x1d1f9f, 0x8b, 0xff },
3395 |     { 0x1d1fa0, 0x45, 0x8b },
3396 |     { 0x1d1fa1, 0xf8, 0x45 },
3397 |     { 0x1d1fa2, 0x8b, 0xf0 },
3398 |     { 0x1d1fa3, 0x55, 0x8b },
3399 |     { 0x1d1fa4, 0xfc, 0x55 },
3400 |     { 0x1d1fa5, 0xe8, 0xf4 },
3401 |     { 0x1d1fa6, 0x56, 0x3 },
3402 |     { 0x1d1fa7, 0x68, 0x45 },
3403 |     { 0x1d1fa8, 0xe3, 0xe8 },
3404 |     { 0x1d1fa9, 0xff, 0x13 },
3405 |     { 0x1d1faa, 0x52, 0x55 },
3406 |     { 0x1d1fab, 0x50, 0xec },
3407 |     { 0x1d1fac, 0x6a, 0x89 },
3408 |     { 0x1d1fad, 0x0, 0x45 },
3409 |     { 0x1d1fae, 0x68, 0xf8 },
3410 |     { 0x1d1faf, 0x40, 0x89 },
3411 |     { 0x1d1fb0, 0x42, 0x55 },
3412 |     { 0x1d1fb1, 0xf, 0xfc },
3413 |     { 0x1d1fb2, 0x0, 0x8b },
3414 |     { 0x1d1fb3, 0x8b, 0x45 },
3415 |     { 0x1d1fb4, 0x45, 0xf8 },
3416 |     { 0x1d1fb5, 0xe0, 0x8b },
3417 |     { 0x1d1fb6, 0x8b, 0x55 },
3418 |     { 0x1d1fb7, 0x55, 0xfc },
3419 |     { 0x1d1fb8, 0xe4, 0x3b },
3420 |     { 0x1d1fb9, 0xe8, 0x55 },
3421 |     { 0x1d1fba, 0x42, 0xe4 },
3422 |     { 0x1d1fbb, 0x68, 0x75 },
3423 |     { 0x1d1fbc, 0xe3, 0x7 },
3424 |     { 0x1d1fbd, 0xff, 0x3b },
3425 |     { 0x1d1fbe, 0x3b, 0x45 },
3426 |     { 0x1d1fbf, 0x54, 0xe0 },
3427 |     { 0x1d1fc0, 0x24, 0x73 },
3428 |     { 0x1d1fc1, 0x4, 0x10 },
3429 |     { 0x1d1fc2, 0x75, 0xeb },
3430 |     { 0x1d1fc3, 0x9, 0x2 },
3431 |     { 0x1d1fc4, 0x3b, 0x7d },
3432 |     { 0x1d1fc5, 0x4, 0xc },
3433 |     { 0x1d1fc6, 0x24, 0x8b },
3434 |     { 0x1d1fc7, 0x5a, 0x45 },
3435 |     { 0x1d1fc8, 0x58, 0xf8 },
3436 |     { 0x1d1fc9, 0x73, 0x89 },
3437 |     { 0x1d1fca, 0x21, 0x45 },
3438 |     { 0x1d1fcb, 0xeb, 0xe0 },
3439 |     { 0x1d1fcc, 0x4, 0x8b },
3440 |     { 0x1d1fcd, 0x5a, 0x45 },
3441 |     { 0x1d1fce, 0x58, 0xfc },
3442 |     { 0x1d1fcf, 0x7d, 0x89 },
3443 |     { 0x1d1fd0, 0x1b, 0x45 },
3444 |     { 0x1d1fd1, 0xa1, 0xe4 },
3445 |     { 0x1d1fd2, 0x2c, 0x6a },
3446 |     { 0x1d1fd3, 0xbb, 0x0 },
3447 |     { 0x1d1fd4, 0x64, 0x68 },
3448 |     { 0x1d1fd5, 0x0, 0x40 },
3449 |     { 0x1d1fd6, 0x8b, 0x42 },
3450 |     { 0x1d1fd7, 0x55, 0xf },
3451 |     { 0x1d1fd8, 0xdc, 0x0 },
3452 |     { 0x1d1fd9, 0x89, 0x8b },
3453 |     { 0x1d1fda, 0x10, 0x45 },
3454 |     { 0x1d1fdb, 0x33, 0xf8 },
3455 |     { 0x1d1fdc, 0xc0, 0x8b },
3456 |     { 0x1d1fdd, 0x89, 0x55 },
3457 |     { 0x1d1fde, 0x45, 0xfc },
3458 |     { 0x1d1fdf, 0xdc, 0xe8 },
3459 |     { 0x1d1fe0, 0x8b, 0x1c },
3460 |     { 0x1d1fe1, 0x45, 0x68 },
3461 |     { 0x1d1fe2, 0xf8, 0xe3 },
3462 |     { 0x1d1fe3, 0x89, 0xff },
3463 |     { 0x1d1fe4, 0x45, 0x52 },
3464 |     { 0x1d1fe5, 0xe0, 0x50 },
3465 |     { 0x1d1fe6, 0x8b, 0x6a },
3466 |     { 0x1d1fe7, 0x45, 0x0 },
3467 |     { 0x1d1fe8, 0xfc, 0x68 },
3468 |     { 0x1d1fe9, 0x89, 0x40 },
3469 |     { 0x1d1fea, 0x45, 0x42 },
3470 |     { 0x1d1feb, 0xe4, 0xf },
3471 |     { 0x1d1fec, 0xff, 0x0 },
3472 |     { 0x1d1fed, 0x45, 0x8b },
3473 |     { 0x1d1fee, 0xdc, 0x45 },
3474 |     { 0x1d1fef, 0xa1, 0xe0 },
3475 |     { 0x1d1ff0, 0x9c, 0x8b },
3476 |     { 0x1d1ff1, 0xbd, 0x55 },
3477 |     { 0x1d1ff2, 0x64, 0xe4 },
3478 |     { 0x1d1ff3, 0x0, 0xe8 },
3479 |     { 0x1d1ff4, 0x83, 0x8 },
3480 |     { 0x1d1ff5, 0x38, 0x68 },
3481 |     { 0x1d1ff6, 0xff, 0xe3 },
3482 |     { 0x1d1ff7, 0x75, 0xff },
3483 |     { 0x1d1ff8, 0x30, 0x3b },
3484 |     { 0x1d1ff9, 0xa1, 0x54 },
3485 |     { 0x1d1ffa, 0xe4, 0x24 },
3486 |     { 0x1d1ffb, 0xc1, 0x4 },
3487 |     { 0x1d1ffc, 0x64, 0x75 },
3488 |     { 0x1d1ffd, 0x0, 0x9 },
3489 |     { 0x1d1ffe, 0x80, 0x3b },
3490 |     { 0x1d1fff, 0x38, 0x4 },
3491 |     { 0x1d2000, 0x0, 0x24 },
3492 |     { 0x1d2001, 0x74, 0x5a },
3493 |     { 0x1d2002, 0x26, 0x58 },
3494 |     { 0x1d2003, 0xe8, 0x73 },
3495 |     { 0x1d2004, 0x78, 0x21 },
3496 |     { 0x1d2005, 0x7d, 0xeb },
3497 |     { 0x1d2006, 0x1, 0x4 },
3498 |     { 0x1d2007, 0x0, 0x5a },
3499 |     { 0x1d2008, 0xa1, 0x58 },
3500 |     { 0x1d2009, 0xfc, 0x7d },
3501 |     { 0x1d200a, 0xbb, 0x1b },
3502 |     { 0x1d200b, 0x64, 0xa1 },
3503 |     { 0x1d200c, 0x0, 0x2c },
3504 |     { 0x1d200d, 0x80, 0xbb },
3505 |     { 0x1d200e, 0x38, 0x64 },
3506 |     { 0x1d2010, 0x74, 0x8b },
3507 |     { 0x1d2011, 0x12, 0x55 },
3508 |     { 0x1d2012, 0xe8, 0xdc },
3509 |     { 0x1d2013, 0x21, 0x89 },
3510 |     { 0x1d2014, 0xba, 0x10 },
3511 |     { 0x1d2015, 0xf5, 0x33 },
3512 |     { 0x1d2016, 0xff, 0xc0 },
3513 |     { 0x1d2017, 0xe8, 0x89 },
3514 |     { 0x1d2018, 0x10, 0x45 },
3515 |     { 0x1d2019, 0x78, 0xdc },
3516 |     { 0x1d201a, 0x1, 0x8b },
3517 |     { 0x1d201b, 0x0, 0x45 },
3518 |     { 0x1d201c, 0xa1, 0xf8 },
3519 |     { 0x1d201d, 0xfc, 0x89 },
3520 |     { 0x1d201e, 0xbb, 0x45 },
3521 |     { 0x1d201f, 0x64, 0xe0 },
3522 |     { 0x1d2020, 0x0, 0x8b },
3523 |     { 0x1d2021, 0xc6, 0x45 },
3524 |     { 0x1d2022, 0x0, 0xfc },
3525 |     { 0x1d2023, 0x0, 0x89 },
3526 |     { 0x1d2024, 0xe8, 0x45 },
3527 |     { 0x1d2025, 0x37, 0xe4 },
3528 |     { 0x1d2026, 0x7d, 0xff },
3529 |     { 0x1d2027, 0x1, 0x45 },
3530 |     { 0x1d2028, 0x0, 0xdc },
3531 | 	{-1,0,0}
3532 | };
3533 | 
3534 | PatchByte inputlagpatch_81_135[] = {
3535 | 	{ 0x1d607b, 0xe8, 0xa1 },
3536 | 	{ 0x1d607c, 0x70, 0x44 },
3537 | 	{ 0x1d607d, 0xa8, 0x4c },
3538 | 	{ 0x1d607e, 0xf5, 0x68 },
3539 | 	{ 0x1d607f, 0xff, 0x00 },
3540 | 	{ 0x1d6080, 0x89, 0x83 },
3541 | 	{ 0x1d6081, 0x45, 0x38 },
3542 | 	{ 0x1d6082, 0xf0, 0xff },
3543 | 	{ 0x1d6083, 0x89, 0x75 },
3544 | 	{ 0x1d6084, 0x55, 0x30 },
3545 | 	{ 0x1d6085, 0xf4, 0xa1 },
3546 | 	{ 0x1d6086, 0x8b, 0xc0 },
3547 | 	{ 0x1d6087, 0x45, 0x51 },
3548 | 	{ 0x1d6088, 0xf0, 0x68 },
3549 | 	{ 0x1d6089, 0x8b, 0x00 },
3550 | 	{ 0x1d608a, 0x55, 0x80 },
3551 | 	{ 0x1d608b, 0xf4, 0x38 },
3552 | 	{ 0x1d608c, 0x3b, 0x00 },
3553 | 	{ 0x1d608d, 0x55, 0x74 },
3554 | 	{ 0x1d608e, 0xfc, 0x26 },
3555 | 	{ 0x1d608f, 0x75, 0xe8 },
3556 | 	{ 0x1d6090, 0x07, 0xdc },
3557 | 	{ 0x1d6091, 0x3b, 0x82 },
3558 | 	{ 0x1d6092, 0x45, 0x01 },
3559 | 	{ 0x1d6093, 0xf8, 0x00 },
3560 | 	{ 0x1d6094, 0x73, 0xa1 },
3561 | 	{ 0x1d6095, 0x10, 0x28 },
3562 | 	{ 0x1d6096, 0xeb, 0x4a },
3563 | 	{ 0x1d6097, 0x02, 0x68 },
3564 | 	{ 0x1d6098, 0x7d, 0x00 },
3565 | 	{ 0x1d6099, 0x0c, 0x80 },
3566 | 	{ 0x1d609a, 0x8b, 0x38 },
3567 | 	{ 0x1d609b, 0x45, 0x00 },
3568 | 	{ 0x1d609c, 0xf0, 0x74 },
3569 | 	{ 0x1d609d, 0x89, 0x12 },
3570 | 	{ 0x1d609e, 0x45, 0xe8 },
3571 | 	{ 0x1d609f, 0xf8, 0x59 },
3572 | 	{ 0x1d60a0, 0x8b, 0xb1 },
3573 | 	{ 0x1d60a1, 0x45, 0xf5 },
3574 | 	{ 0x1d60a2, 0xf4, 0xff },
3575 | 	{ 0x1d60a3, 0x89, 0xe8 },
3576 | 	{ 0x1d60a4, 0x45, 0x74 },
3577 | 	{ 0x1d60a5, 0xfc, 0x7d },
3578 | 	{ 0x1d60a6, 0xa1, 0x01 },
3579 | 	{ 0x1d60a7, 0x84, 0x00 },
3580 | 	{ 0x1d60a8, 0x53, 0xa1 },
3581 | 	{ 0x1d60a9, 0x68, 0x28 },
3582 | 	{ 0x1d60aa, 0x00, 0x4a },
3583 | 	{ 0x1d60ab, 0x8b, 0x68 },
3584 | 	{ 0x1d60ad, 0x83, 0xc6 },
3585 | 	{ 0x1d60ae, 0x78, 0x00 },
3586 | 	{ 0x1d60af, 0x08, 0x00 },
3587 | 	{ 0x1d60b0, 0x00, 0xe8 },
3588 | 	{ 0x1d60b1, 0x7f, 0x9b },
3589 | 	{ 0x1d60b2, 0x0e, 0x82 },
3590 | 	{ 0x1d60b3, 0xa1, 0x01 },
3591 | 	{ 0x1d60b4, 0x84, 0x00 },
3592 | 	{ 0x1d60b5, 0x53, 0xe8 },
3593 | 	{ 0x1d60b6, 0x68, 0x36 },
3594 | 	{ 0x1d60b7, 0x00, 0xa8 },
3595 | 	{ 0x1d60b8, 0x8b, 0xf5 },
3596 | 	{ 0x1d60b9, 0x00, 0xff },
3597 | 	{ 0x1d60ba, 0xc7, 0x89 },
3598 | 	{ 0x1d60bb, 0x40, 0x45 },
3599 | 	{ 0x1d60bc, 0x08, 0xf0 },
3600 | 	{ 0x1d60bd, 0x01, 0x89 },
3601 | 	{ 0x1d60be, 0x00, 0x55 },
3602 | 	{ 0x1d60bf, 0x00, 0xf4 },
3603 | 	{ 0x1d60c0, 0x00, 0x8b },
3604 | 	{ 0x1d60c1, 0xa1, 0x45 },
3605 | 	{ 0x1d60c2, 0x84, 0xf0 },
3606 | 	{ 0x1d60c3, 0x53, 0x8b },
3607 | 	{ 0x1d60c4, 0x68, 0x55 },
3608 | 	{ 0x1d60c5, 0x00, 0xf4 },
3609 | 	{ 0x1d60c6, 0x8b, 0x3b },
3610 | 	{ 0x1d60c7, 0x00, 0x55 },
3611 | 	{ 0x1d60c8, 0xff, 0xfc },
3612 | 	{ 0x1d60c9, 0x70, 0x75 },
3613 | 	{ 0x1d60ca, 0x08, 0x07 },
3614 | 	{ 0x1d60cb, 0xb8, 0x3b },
3615 | 	{ 0x1d60cc, 0x40, 0x45 },
3616 | 	{ 0x1d60cd, 0x42, 0xf8 },
3617 | 	{ 0x1d60ce, 0x0f, 0x73 },
3618 | 	{ 0x1d60cf, 0x00, 0x10 },
3619 | 	{ 0x1d60d0, 0x5a, 0xeb },
3620 | 	{ 0x1d60d1, 0x8b, 0x02 },
3621 | 	{ 0x1d60d2, 0xca, 0x7d },
3622 | 	{ 0x1d60d3, 0x99, 0x0c },
3623 | 	{ 0x1d60d4, 0xf7, 0x8b },
3624 | 	{ 0x1d60d5, 0xf9, 0x45 },
3625 | 	{ 0x1d60d6, 0x99, 0xf0 },
3626 | 	{ 0x1d60d7, 0x52, 0x89 },
3627 | 	{ 0x1d60d8, 0x50, 0x45 },
3628 | 	{ 0x1d60d9, 0x8b, 0xf8 },
3629 | 	{ 0x1d60da, 0x45, 0x8b },
3630 | 	{ 0x1d60db, 0xf0, 0x45 },
3631 | 	{ 0x1d60dc, 0x8b, 0xf4 },
3632 | 	{ 0x1d60dd, 0x55, 0x89 },
3633 | 	{ 0x1d60de, 0xf4, 0x45 },
3634 | 	{ 0x1d60df, 0x2b, 0xfc },
3635 | 	{ 0x1d60e0, 0x45, 0xa1 },
3636 | 	{ 0x1d60e1, 0xf8, 0x84 },
3637 | 	{ 0x1d60e2, 0x1b, 0x53 },
3638 | 	{ 0x1d60e3, 0x55, 0x68 },
3639 | 	{ 0x1d60e4, 0xfc, 0x00 },
3640 | 	{ 0x1d60e5, 0x29, 0x8b },
3641 | 	{ 0x1d60e6, 0x04, 0x00 },
3642 | 	{ 0x1d60e7, 0x24, 0x83 },
3643 | 	{ 0x1d60e8, 0x19, 0x78 },
3644 | 	{ 0x1d60e9, 0x54, 0x08 },
3645 | 	{ 0x1d60ea, 0x24, 0x00 },
3646 | 	{ 0x1d60eb, 0x04, 0x7f },
3647 | 	{ 0x1d60ec, 0x58, 0x0e },
3648 | 	{ 0x1d60ed, 0x5a, 0xa1 },
3649 | 	{ 0x1d60ee, 0x89, 0x84 },
3650 | 	{ 0x1d60ef, 0x45, 0x53 },
3651 | 	{ 0x1d60f0, 0xd0, 0x68 },
3652 | 	{ 0x1d60f1, 0x89, 0x00 },
3653 | 	{ 0x1d60f2, 0x55, 0x8b },
3654 | 	{ 0x1d60f3, 0xd4, 0x00 },
3655 | 	{ 0x1d60f4, 0x83, 0xc7 },
3656 | 	{ 0x1d60f5, 0x7d, 0x40 },
3657 | 	{ 0x1d60f6, 0xd4, 0x08 },
3658 | 	{ 0x1d60f7, 0x00, 0x01 },
3659 | 	{ 0x1d60f8, 0x75, 0x00 },
3660 | 	{ 0x1d60f9, 0x08, 0x00 },
3661 | 	{ 0x1d60fa, 0x83, 0x00 },
3662 | 	{ 0x1d60fb, 0x7d, 0xa1 },
3663 | 	{ 0x1d60fc, 0xd0, 0x84 },
3664 | 	{ 0x1d60fd, 0x00, 0x53 },
3665 | 	{ 0x1d60fe, 0x73, 0x68 },
3666 | 	{ 0x1d60ff, 0x14, 0x00 },
3667 | 	{ 0x1d6100, 0xeb, 0x8b },
3668 | 	{ 0x1d6101, 0x02, 0x00 },
3669 | 	{ 0x1d6102, 0x7d, 0xff },
3670 | 	{ 0x1d6103, 0x10, 0x70 },
3671 | 	{ 0x1d6104, 0xc7, 0x08 },
3672 | 	{ 0x1d6105, 0x45, 0xb8 },
3673 | 	{ 0x1d6106, 0xc8, 0x40 },
3674 | 	{ 0x1d6107, 0x00, 0x42 },
3675 | 	{ 0x1d6108, 0x00, 0x0f },
3676 | 	{ 0x1d610a, 0x00, 0x5a },
3677 | 	{ 0x1d610b, 0xc7, 0x8b },
3678 | 	{ 0x1d610c, 0x45, 0xca },
3679 | 	{ 0x1d610d, 0xcc, 0x99 },
3680 | 	{ 0x1d610e, 0x00, 0xf7 },
3681 | 	{ 0x1d610f, 0x00, 0xf9 },
3682 | 	{ 0x1d6110, 0x00, 0x99 },
3683 | 	{ 0x1d6111, 0x00, 0x52 },
3684 | 	{ 0x1d6112, 0xeb, 0x50 },
3685 | 	{ 0x1d6113, 0x0c, 0x8b },
3686 | 	{ 0x1d6114, 0x8b, 0x45 },
3687 | 	{ 0x1d6115, 0x45, 0xf0 },
3688 | 	{ 0x1d6116, 0xd0, 0x8b },
3689 | 	{ 0x1d6117, 0x89, 0x55 },
3690 | 	{ 0x1d6118, 0x45, 0xf4 },
3691 | 	{ 0x1d6119, 0xc8, 0x2b },
3692 | 	{ 0x1d611a, 0x8b, 0x45 },
3693 | 	{ 0x1d611b, 0x45, 0xf8 },
3694 | 	{ 0x1d611c, 0xd4, 0x1b },
3695 | 	{ 0x1d611d, 0x89, 0x55 },
3696 | 	{ 0x1d611e, 0x45, 0xfc },
3697 | 	{ 0x1d611f, 0xcc, 0x29 },
3698 | 	{ 0x1d6120, 0x8b, 0x04 },
3699 | 	{ 0x1d6121, 0x45, 0x24 },
3700 | 	{ 0x1d6122, 0xc8, 0x19 },
3701 | 	{ 0x1d6123, 0x89, 0x54 },
3702 | 	{ 0x1d6124, 0x45, 0x24 },
3703 | 	{ 0x1d6125, 0xe8, 0x04 },
3704 | 	{ 0x1d6126, 0x8b, 0x58 },
3705 | 	{ 0x1d6127, 0x45, 0x5a },
3706 | 	{ 0x1d6128, 0xcc, 0x89 },
3707 | 	{ 0x1d6129, 0x89, 0x45 },
3708 | 	{ 0x1d612a, 0x45, 0xd0 },
3709 | 	{ 0x1d612b, 0xec, 0x89 },
3710 | 	{ 0x1d612c, 0x83, 0x55 },
3711 | 	{ 0x1d612d, 0x7d, 0xd4 },
3712 | 	{ 0x1d612e, 0xec, 0x83 },
3713 | 	{ 0x1d612f, 0x00, 0x7d },
3714 | 	{ 0x1d6130, 0x75, 0xd4 },
3715 | 	{ 0x1d6131, 0x0b, 0x00 },
3716 | 	{ 0x1d6132, 0x81, 0x75 },
3717 | 	{ 0x1d6133, 0x7d, 0x08 },
3718 | 	{ 0x1d6134, 0xe8, 0x83 },
3719 | 	{ 0x1d6135, 0x40, 0x7d },
3720 | 	{ 0x1d6136, 0x42, 0xd0 },
3721 | 	{ 0x1d6137, 0x0f, 0x00 },
3722 | 	{ 0x1d6138, 0x00, 0x73 },
3723 | 	{ 0x1d6139, 0x73, 0x14 },
3724 | 	{ 0x1d613a, 0x12, 0xeb },
3725 | 	{ 0x1d613b, 0xeb, 0x02 },
3726 | 	{ 0x1d613c, 0x02, 0x7d },
3727 | 	{ 0x1d613d, 0x7d, 0x10 },
3728 | 	{ 0x1d613e, 0x0e, 0xc7 },
3729 | 	{ 0x1d613f, 0x8b, 0x45 },
3730 | 	{ 0x1d6140, 0x45, 0xc8 },
3731 | 	{ 0x1d6141, 0xe8, 0x00 },
3732 | 	{ 0x1d6142, 0x89, 0x00 },
3733 | 	{ 0x1d6143, 0x45, 0x00 },
3734 | 	{ 0x1d6144, 0xc0, 0x00 },
3735 | 	{ 0x1d6145, 0x8b, 0xc7 },
3736 | 	{ 0x1d6147, 0xec, 0xcc },
3737 | 	{ 0x1d6148, 0x89, 0x00 },
3738 | 	{ 0x1d6149, 0x45, 0x00 },
3739 | 	{ 0x1d614a, 0xc4, 0x00 },
3740 | 	{ 0x1d614b, 0xeb, 0x00 },
3741 | 	{ 0x1d614c, 0x0e, 0xeb },
3742 | 	{ 0x1d614d, 0xc7, 0x0c },
3743 | 	{ 0x1d614e, 0x45, 0x8b },
3744 | 	{ 0x1d614f, 0xc0, 0x45 },
3745 | 	{ 0x1d6150, 0x40, 0xd0 },
3746 | 	{ 0x1d6151, 0x42, 0x89 },
3747 | 	{ 0x1d6152, 0x0f, 0x45 },
3748 | 	{ 0x1d6153, 0x00, 0xc8 },
3749 | 	{ 0x1d6154, 0xc7, 0x8b },
3750 | 	{ 0x1d6156, 0xc4, 0xd4 },
3751 | 	{ 0x1d6157, 0x00, 0x89 },
3752 | 	{ 0x1d6158, 0x00, 0x45 },
3753 | 	{ 0x1d6159, 0x00, 0xcc },
3754 | 	{ 0x1d615a, 0x00, 0x8b },
3755 | 	{ 0x1d615b, 0x8b, 0x45 },
3756 | 	{ 0x1d615c, 0x45, 0xc8 },
3757 | 	{ 0x1d615d, 0xc0, 0x89 },
3758 | 	{ 0x1d615e, 0x89, 0x45 },
3759 | 	{ 0x1d615f, 0x45, 0xe8 },
3760 | 	{ 0x1d6160, 0xe8, 0x8b },
3761 | 	{ 0x1d6161, 0x8b, 0x45 },
3762 | 	{ 0x1d6162, 0x45, 0xcc },
3763 | 	{ 0x1d6163, 0xc4, 0x89 },
3764 | 	{ 0x1d6164, 0x89, 0x45 },
3765 | 	{ 0x1d6165, 0x45, 0xec },
3766 | 	{ 0x1d6166, 0xec, 0x83 },
3767 | 	{ 0x1d6167, 0xff, 0x7d },
3768 | 	{ 0x1d6168, 0x75, 0xec },
3769 | 	{ 0x1d6169, 0xec, 0x00 },
3770 | 	{ 0x1d616a, 0xff, 0x75 },
3771 | 	{ 0x1d616b, 0x75, 0x0b },
3772 | 	{ 0x1d616c, 0xe8, 0x81 },
3773 | 	{ 0x1d616d, 0xe8, 0x7d },
3774 | 	{ 0x1d616e, 0x0a, 0xe8 },
3775 | 	{ 0x1d616f, 0xa8, 0x40 },
3776 | 	{ 0x1d6170, 0xf5, 0x42 },
3777 | 	{ 0x1d6171, 0xff, 0x0f },
3778 | 	{ 0x1d6172, 0x8b, 0x00 },
3779 | 	{ 0x1d6173, 0x45, 0x73 },
3780 | 	{ 0x1d6174, 0xf0, 0x12 },
3781 | 	{ 0x1d6175, 0x8b, 0xeb },
3782 | 	{ 0x1d6176, 0x55, 0x02 },
3783 | 	{ 0x1d6177, 0xf4, 0x7d },
3784 | 	{ 0x1d6178, 0x03, 0x0e },
3785 | 	{ 0x1d6179, 0x45, 0x8b },
3786 | 	{ 0x1d617a, 0xe8, 0x45 },
3787 | 	{ 0x1d617b, 0x13, 0xe8 },
3788 | 	{ 0x1d617c, 0x55, 0x89 },
3789 | 	{ 0x1d617d, 0xec, 0x45 },
3790 | 	{ 0x1d617e, 0x89, 0xc0 },
3791 | 	{ 0x1d617f, 0x45, 0x8b },
3792 | 	{ 0x1d6180, 0xf8, 0x45 },
3793 | 	{ 0x1d6181, 0x89, 0xec },
3794 | 	{ 0x1d6182, 0x55, 0x89 },
3795 | 	{ 0x1d6183, 0xfc, 0x45 },
3796 | 	{ 0x1d6184, 0x8b, 0xc4 },
3797 | 	{ 0x1d6185, 0x45, 0xeb },
3798 | 	{ 0x1d6186, 0xf8, 0x0e },
3799 | 	{ 0x1d6187, 0x8b, 0xc7 },
3800 | 	{ 0x1d6188, 0x55, 0x45 },
3801 | 	{ 0x1d6189, 0xfc, 0xc0 },
3802 | 	{ 0x1d618a, 0x3b, 0x40 },
3803 | 	{ 0x1d618b, 0x55, 0x42 },
3804 | 	{ 0x1d618c, 0xe4, 0x0f },
3805 | 	{ 0x1d618d, 0x75, 0x00 },
3806 | 	{ 0x1d618e, 0x07, 0xc7 },
3807 | 	{ 0x1d618f, 0x3b, 0x45 },
3808 | 	{ 0x1d6190, 0x45, 0xc4 },
3809 | 	{ 0x1d6191, 0xe0, 0x00 },
3810 | 	{ 0x1d6192, 0x73, 0x00 },
3811 | 	{ 0x1d6193, 0x10, 0x00 },
3812 | 	{ 0x1d6194, 0xeb, 0x00 },
3813 | 	{ 0x1d6195, 0x02, 0x8b },
3814 | 	{ 0x1d6196, 0x7d, 0x45 },
3815 | 	{ 0x1d6197, 0x0c, 0xc0 },
3816 | 	{ 0x1d6198, 0x8b, 0x89 },
3817 | 	{ 0x1d619a, 0xf8, 0xe8 },
3818 | 	{ 0x1d619b, 0x89, 0x8b },
3819 | 	{ 0x1d619d, 0xe0, 0xc4 },
3820 | 	{ 0x1d619e, 0x8b, 0x89 },
3821 | 	{ 0x1d61a0, 0xfc, 0xec },
3822 | 	{ 0x1d61a1, 0x89, 0xff },
3823 | 	{ 0x1d61a2, 0x45, 0x75 },
3824 | 	{ 0x1d61a3, 0xe4, 0xec },
3825 | 	{ 0x1d61a4, 0x6a, 0xff },
3826 | 	{ 0x1d61a5, 0x00, 0x75 },
3827 | 	{ 0x1d61a6, 0x68, 0xe8 },
3828 | 	{ 0x1d61a7, 0x40, 0xe8 },
3829 | 	{ 0x1d61a8, 0x42, 0xd0 },
3830 | 	{ 0x1d61a9, 0x0f, 0xa7 },
3831 | 	{ 0x1d61aa, 0x00, 0xf5 },
3832 | 	{ 0x1d61ab, 0x8b, 0xff },
3833 | 	{ 0x1d61ac, 0x45, 0x8b },
3834 | 	{ 0x1d61ad, 0xf8, 0x45 },
3835 | 	{ 0x1d61ae, 0x8b, 0xf0 },
3836 | 	{ 0x1d61af, 0x55, 0x8b },
3837 | 	{ 0x1d61b0, 0xfc, 0x55 },
3838 | 	{ 0x1d61b1, 0xe8, 0xf4 },
3839 | 	{ 0x1d61b2, 0xb6, 0x03 },
3840 | 	{ 0x1d61b3, 0x29, 0x45 },
3841 | 	{ 0x1d61b4, 0xe3, 0xe8 },
3842 | 	{ 0x1d61b5, 0xff, 0x13 },
3843 | 	{ 0x1d61b6, 0x52, 0x55 },
3844 | 	{ 0x1d61b7, 0x50, 0xec },
3845 | 	{ 0x1d61b8, 0x6a, 0x89 },
3846 | 	{ 0x1d61b9, 0x00, 0x45 },
3847 | 	{ 0x1d61ba, 0x68, 0xf8 },
3848 | 	{ 0x1d61bb, 0x40, 0x89 },
3849 | 	{ 0x1d61bc, 0x42, 0x55 },
3850 | 	{ 0x1d61bd, 0x0f, 0xfc },
3851 | 	{ 0x1d61be, 0x00, 0x8b },
3852 | 	{ 0x1d61bf, 0x8b, 0x45 },
3853 | 	{ 0x1d61c0, 0x45, 0xf8 },
3854 | 	{ 0x1d61c1, 0xe0, 0x8b },
3855 | 	{ 0x1d61c2, 0x8b, 0x55 },
3856 | 	{ 0x1d61c3, 0x55, 0xfc },
3857 | 	{ 0x1d61c4, 0xe4, 0x3b },
3858 | 	{ 0x1d61c5, 0xe8, 0x55 },
3859 | 	{ 0x1d61c6, 0xa2, 0xe4 },
3860 | 	{ 0x1d61c7, 0x29, 0x75 },
3861 | 	{ 0x1d61c8, 0xe3, 0x07 },
3862 | 	{ 0x1d61c9, 0xff, 0x3b },
3863 | 	{ 0x1d61ca, 0x3b, 0x45 },
3864 | 	{ 0x1d61cb, 0x54, 0xe0 },
3865 | 	{ 0x1d61cc, 0x24, 0x73 },
3866 | 	{ 0x1d61cd, 0x04, 0x10 },
3867 | 	{ 0x1d61ce, 0x75, 0xeb },
3868 | 	{ 0x1d61cf, 0x09, 0x02 },
3869 | 	{ 0x1d61d0, 0x3b, 0x7d },
3870 | 	{ 0x1d61d1, 0x04, 0x0c },
3871 | 	{ 0x1d61d2, 0x24, 0x8b },
3872 | 	{ 0x1d61d3, 0x5a, 0x45 },
3873 | 	{ 0x1d61d4, 0x58, 0xf8 },
3874 | 	{ 0x1d61d5, 0x73, 0x89 },
3875 | 	{ 0x1d61d6, 0x21, 0x45 },
3876 | 	{ 0x1d61d7, 0xeb, 0xe0 },
3877 | 	{ 0x1d61d8, 0x04, 0x8b },
3878 | 	{ 0x1d61d9, 0x5a, 0x45 },
3879 | 	{ 0x1d61da, 0x58, 0xfc },
3880 | 	{ 0x1d61db, 0x7d, 0x89 },
3881 | 	{ 0x1d61dc, 0x1b, 0x45 },
3882 | 	{ 0x1d61dd, 0xa1, 0xe4 },
3883 | 	{ 0x1d61de, 0x24, 0x6a },
3884 | 	{ 0x1d61df, 0x49, 0x00 },
3885 | 	{ 0x1d61e1, 0x00, 0x40 },
3886 | 	{ 0x1d61e2, 0x8b, 0x42 },
3887 | 	{ 0x1d61e3, 0x55, 0x0f },
3888 | 	{ 0x1d61e4, 0xdc, 0x00 },
3889 | 	{ 0x1d61e5, 0x89, 0x8b },
3890 | 	{ 0x1d61e6, 0x10, 0x45 },
3891 | 	{ 0x1d61e7, 0x33, 0xf8 },
3892 | 	{ 0x1d61e8, 0xc0, 0x8b },
3893 | 	{ 0x1d61e9, 0x89, 0x55 },
3894 | 	{ 0x1d61ea, 0x45, 0xfc },
3895 | 	{ 0x1d61eb, 0xdc, 0xe8 },
3896 | 	{ 0x1d61ec, 0x8b, 0x7c },
3897 | 	{ 0x1d61ed, 0x45, 0x29 },
3898 | 	{ 0x1d61ee, 0xf8, 0xe3 },
3899 | 	{ 0x1d61ef, 0x89, 0xff },
3900 | 	{ 0x1d61f0, 0x45, 0x52 },
3901 | 	{ 0x1d61f1, 0xe0, 0x50 },
3902 | 	{ 0x1d61f2, 0x8b, 0x6a },
3903 | 	{ 0x1d61f3, 0x45, 0x00 },
3904 | 	{ 0x1d61f4, 0xfc, 0x68 },
3905 | 	{ 0x1d61f5, 0x89, 0x40 },
3906 | 	{ 0x1d61f6, 0x45, 0x42 },
3907 | 	{ 0x1d61f7, 0xe4, 0x0f },
3908 | 	{ 0x1d61f8, 0xff, 0x00 },
3909 | 	{ 0x1d61f9, 0x45, 0x8b },
3910 | 	{ 0x1d61fa, 0xdc, 0x45 },
3911 | 	{ 0x1d61fb, 0xa1, 0xe0 },
3912 | 	{ 0x1d61fc, 0x44, 0x8b },
3913 | 	{ 0x1d61fd, 0x4c, 0x55 },
3914 | 	{ 0x1d61fe, 0x68, 0xe4 },
3915 | 	{ 0x1d61ff, 0x00, 0xe8 },
3916 | 	{ 0x1d6200, 0x83, 0x68 },
3917 | 	{ 0x1d6201, 0x38, 0x29 },
3918 | 	{ 0x1d6202, 0xff, 0xe3 },
3919 | 	{ 0x1d6203, 0x75, 0xff },
3920 | 	{ 0x1d6204, 0x30, 0x3b },
3921 | 	{ 0x1d6205, 0xa1, 0x54 },
3922 | 	{ 0x1d6206, 0xc0, 0x24 },
3923 | 	{ 0x1d6207, 0x51, 0x04 },
3924 | 	{ 0x1d6208, 0x68, 0x75 },
3925 | 	{ 0x1d6209, 0x00, 0x09 },
3926 | 	{ 0x1d620a, 0x80, 0x3b },
3927 | 	{ 0x1d620b, 0x38, 0x04 },
3928 | 	{ 0x1d620c, 0x00, 0x24 },
3929 | 	{ 0x1d620d, 0x74, 0x5a },
3930 | 	{ 0x1d620e, 0x26, 0x58 },
3931 | 	{ 0x1d620f, 0xe8, 0x73 },
3932 | 	{ 0x1d6210, 0x5c, 0x21 },
3933 | 	{ 0x1d6211, 0x81, 0xeb },
3934 | 	{ 0x1d6212, 0x01, 0x04 },
3935 | 	{ 0x1d6213, 0x00, 0x5a },
3936 | 	{ 0x1d6214, 0xa1, 0x58 },
3937 | 	{ 0x1d6215, 0x28, 0x7d },
3938 | 	{ 0x1d6216, 0x4a, 0x1b },
3939 | 	{ 0x1d6217, 0x68, 0xa1 },
3940 | 	{ 0x1d6218, 0x00, 0x24 },
3941 | 	{ 0x1d6219, 0x80, 0x49 },
3942 | 	{ 0x1d621a, 0x38, 0x68 },
3943 | 	{ 0x1d621c, 0x74, 0x8b },
3944 | 	{ 0x1d621d, 0x12, 0x55 },
3945 | 	{ 0x1d621e, 0xe8, 0xdc },
3946 | 	{ 0x1d621f, 0xd9, 0x89 },
3947 | 	{ 0x1d6220, 0xaf, 0x10 },
3948 | 	{ 0x1d6221, 0xf5, 0x33 },
3949 | 	{ 0x1d6222, 0xff, 0xc0 },
3950 | 	{ 0x1d6223, 0xe8, 0x89 },
3951 | 	{ 0x1d6224, 0xf4, 0x45 },
3952 | 	{ 0x1d6225, 0x7b, 0xdc },
3953 | 	{ 0x1d6226, 0x01, 0x8b },
3954 | 	{ 0x1d6227, 0x00, 0x45 },
3955 | 	{ 0x1d6228, 0xa1, 0xf8 },
3956 | 	{ 0x1d6229, 0x28, 0x89 },
3957 | 	{ 0x1d622a, 0x4a, 0x45 },
3958 | 	{ 0x1d622b, 0x68, 0xe0 },
3959 | 	{ 0x1d622c, 0x00, 0x8b },
3960 | 	{ 0x1d622d, 0xc6, 0x45 },
3961 | 	{ 0x1d622e, 0x00, 0xfc },
3962 | 	{ 0x1d622f, 0x00, 0x89 },
3963 | 	{ 0x1d6230, 0xe8, 0x45 },
3964 | 	{ 0x1d6231, 0x1b, 0xe4 },
3965 | 	{ 0x1d6232, 0x81, 0xff },
3966 | 	{ 0x1d6233, 0x01, 0x45 },
3967 | 	{ 0x1d6234, 0x00, 0xdc },
3968 | 	{-1,0,0}
3969 | };
3970 | 
3971 | PatchByte inputlagpatch_81_140[] = {
3972 | 	{ 0x206cff, 0xe8, 0xa1 },
3973 | 	{ 0x206d00, 0x24, 0x48 },
3974 | 	{ 0x206d01, 0x98, 0x8c },
3975 | 	{ 0x206d02, 0xf5, 0x68 },
3976 | 	{ 0x206d03, 0xff, 0x0 },
3977 | 	{ 0x206d04, 0x89, 0x83 },
3978 | 	{ 0x206d05, 0x45, 0x38 },
3979 | 	{ 0x206d06, 0xf0, 0xff },
3980 | 	{ 0x206d07, 0x89, 0x75 },
3981 | 	{ 0x206d08, 0x55, 0x30 },
3982 | 	{ 0x206d09, 0xf4, 0xa1 },
3983 | 	{ 0x206d0a, 0x8b, 0xcc },
3984 | 	{ 0x206d0b, 0x45, 0x91 },
3985 | 	{ 0x206d0c, 0xf0, 0x68 },
3986 | 	{ 0x206d0d, 0x8b, 0x0 },
3987 | 	{ 0x206d0e, 0x55, 0x80 },
3988 | 	{ 0x206d0f, 0xf4, 0x38 },
3989 | 	{ 0x206d10, 0x3b, 0x0 },
3990 | 	{ 0x206d11, 0x55, 0x74 },
3991 | 	{ 0x206d12, 0xfc, 0x26 },
3992 | 	{ 0x206d13, 0x75, 0xe8 },
3993 | 	{ 0x206d14, 0x7, 0xc0 },
3994 | 	{ 0x206d15, 0x3b, 0x85 },
3995 | 	{ 0x206d16, 0x45, 0x1 },
3996 | 	{ 0x206d17, 0xf8, 0x0 },
3997 | 	{ 0x206d18, 0x73, 0xa1 },
3998 | 	{ 0x206d19, 0x10, 0x38 },
3999 | 	{ 0x206d1a, 0xeb, 0x8a },
4000 | 	{ 0x206d1b, 0x2, 0x68 },
4001 | 	{ 0x206d1c, 0x7d, 0x0 },
4002 | 	{ 0x206d1d, 0xc, 0x80 },
4003 | 	{ 0x206d1e, 0x8b, 0x38 },
4004 | 	{ 0x206d1f, 0x45, 0x0 },
4005 | 	{ 0x206d20, 0xf0, 0x74 },
4006 | 	{ 0x206d21, 0x89, 0x12 },
4007 | 	{ 0x206d22, 0x45, 0xe8 },
4008 | 	{ 0x206d23, 0xf8, 0x19 },
4009 | 	{ 0x206d24, 0x8b, 0xa2 },
4010 | 	{ 0x206d25, 0x45, 0xf5 },
4011 | 	{ 0x206d26, 0xf4, 0xff },
4012 | 	{ 0x206d27, 0x89, 0xe8 },
4013 | 	{ 0x206d28, 0x45, 0x58 },
4014 | 	{ 0x206d29, 0xfc, 0x80 },
4015 | 	{ 0x206d2a, 0xa1, 0x1 },
4016 | 	{ 0x206d2b, 0x98, 0x0 },
4017 | 	{ 0x206d2c, 0x93, 0xa1 },
4018 | 	{ 0x206d2d, 0x68, 0x38 },
4019 | 	{ 0x206d2e, 0x0, 0x8a },
4020 | 	{ 0x206d2f, 0x8b, 0x68 },
4021 | 	{ 0x206d31, 0x83, 0xc6 },
4022 | 	{ 0x206d32, 0x78, 0x0 },
4023 | 	{ 0x206d33, 0x8, 0x0 },
4024 | 	{ 0x206d34, 0x0, 0xe8 },
4025 | 	{ 0x206d36, 0xe, 0x85 },
4026 | 	{ 0x206d37, 0xa1, 0x1 },
4027 | 	{ 0x206d38, 0x98, 0x0 },
4028 | 	{ 0x206d39, 0x93, 0xe8 },
4029 | 	{ 0x206d3a, 0x68, 0xea },
4030 | 	{ 0x206d3b, 0x0, 0x97 },
4031 | 	{ 0x206d3c, 0x8b, 0xf5 },
4032 | 	{ 0x206d3d, 0x0, 0xff },
4033 | 	{ 0x206d3e, 0xc7, 0x89 },
4034 | 	{ 0x206d3f, 0x40, 0x45 },
4035 | 	{ 0x206d40, 0x8, 0xf0 },
4036 | 	{ 0x206d41, 0x1, 0x89 },
4037 | 	{ 0x206d42, 0x0, 0x55 },
4038 | 	{ 0x206d43, 0x0, 0xf4 },
4039 | 	{ 0x206d44, 0x0, 0x8b },
4040 | 	{ 0x206d45, 0xa1, 0x45 },
4041 | 	{ 0x206d46, 0x98, 0xf0 },
4042 | 	{ 0x206d47, 0x93, 0x8b },
4043 | 	{ 0x206d48, 0x68, 0x55 },
4044 | 	{ 0x206d49, 0x0, 0xf4 },
4045 | 	{ 0x206d4a, 0x8b, 0x3b },
4046 | 	{ 0x206d4b, 0x0, 0x55 },
4047 | 	{ 0x206d4c, 0xff, 0xfc },
4048 | 	{ 0x206d4d, 0x70, 0x75 },
4049 | 	{ 0x206d4e, 0x8, 0x7 },
4050 | 	{ 0x206d4f, 0xb8, 0x3b },
4051 | 	{ 0x206d50, 0x40, 0x45 },
4052 | 	{ 0x206d51, 0x42, 0xf8 },
4053 | 	{ 0x206d52, 0xf, 0x73 },
4054 | 	{ 0x206d53, 0x0, 0x10 },
4055 | 	{ 0x206d54, 0x5a, 0xeb },
4056 | 	{ 0x206d55, 0x8b, 0x2 },
4057 | 	{ 0x206d56, 0xca, 0x7d },
4058 | 	{ 0x206d57, 0x99, 0xc },
4059 | 	{ 0x206d58, 0xf7, 0x8b },
4060 | 	{ 0x206d59, 0xf9, 0x45 },
4061 | 	{ 0x206d5a, 0x99, 0xf0 },
4062 | 	{ 0x206d5b, 0x52, 0x89 },
4063 | 	{ 0x206d5c, 0x50, 0x45 },
4064 | 	{ 0x206d5d, 0x8b, 0xf8 },
4065 | 	{ 0x206d5e, 0x45, 0x8b },
4066 | 	{ 0x206d5f, 0xf0, 0x45 },
4067 | 	{ 0x206d60, 0x8b, 0xf4 },
4068 | 	{ 0x206d61, 0x55, 0x89 },
4069 | 	{ 0x206d62, 0xf4, 0x45 },
4070 | 	{ 0x206d63, 0x2b, 0xfc },
4071 | 	{ 0x206d64, 0x45, 0xa1 },
4072 | 	{ 0x206d65, 0xf8, 0x98 },
4073 | 	{ 0x206d66, 0x1b, 0x93 },
4074 | 	{ 0x206d67, 0x55, 0x68 },
4075 | 	{ 0x206d68, 0xfc, 0x0 },
4076 | 	{ 0x206d69, 0x29, 0x8b },
4077 | 	{ 0x206d6a, 0x4, 0x0 },
4078 | 	{ 0x206d6b, 0x24, 0x83 },
4079 | 	{ 0x206d6c, 0x19, 0x78 },
4080 | 	{ 0x206d6d, 0x54, 0x8 },
4081 | 	{ 0x206d6e, 0x24, 0x0 },
4082 | 	{ 0x206d6f, 0x4, 0x7f },
4083 | 	{ 0x206d70, 0x58, 0xe },
4084 | 	{ 0x206d71, 0x5a, 0xa1 },
4085 | 	{ 0x206d72, 0x89, 0x98 },
4086 | 	{ 0x206d73, 0x45, 0x93 },
4087 | 	{ 0x206d74, 0xd0, 0x68 },
4088 | 	{ 0x206d75, 0x89, 0x0 },
4089 | 	{ 0x206d76, 0x55, 0x8b },
4090 | 	{ 0x206d77, 0xd4, 0x0 },
4091 | 	{ 0x206d78, 0x83, 0xc7 },
4092 | 	{ 0x206d79, 0x7d, 0x40 },
4093 | 	{ 0x206d7a, 0xd4, 0x8 },
4094 | 	{ 0x206d7b, 0x0, 0x1 },
4095 | 	{ 0x206d7c, 0x75, 0x0 },
4096 | 	{ 0x206d7d, 0x8, 0x0 },
4097 | 	{ 0x206d7e, 0x83, 0x0 },
4098 | 	{ 0x206d7f, 0x7d, 0xa1 },
4099 | 	{ 0x206d80, 0xd0, 0x98 },
4100 | 	{ 0x206d81, 0x0, 0x93 },
4101 | 	{ 0x206d82, 0x73, 0x68 },
4102 | 	{ 0x206d83, 0x14, 0x0 },
4103 | 	{ 0x206d84, 0xeb, 0x8b },
4104 | 	{ 0x206d85, 0x2, 0x0 },
4105 | 	{ 0x206d86, 0x7d, 0xff },
4106 | 	{ 0x206d87, 0x10, 0x70 },
4107 | 	{ 0x206d88, 0xc7, 0x8 },
4108 | 	{ 0x206d89, 0x45, 0xb8 },
4109 | 	{ 0x206d8a, 0xc8, 0x40 },
4110 | 	{ 0x206d8b, 0x0, 0x42 },
4111 | 	{ 0x206d8c, 0x0, 0xf },
4112 | 	{ 0x206d8e, 0x0, 0x5a },
4113 | 	{ 0x206d8f, 0xc7, 0x8b },
4114 | 	{ 0x206d90, 0x45, 0xca },
4115 | 	{ 0x206d91, 0xcc, 0x99 },
4116 | 	{ 0x206d92, 0x0, 0xf7 },
4117 | 	{ 0x206d93, 0x0, 0xf9 },
4118 | 	{ 0x206d94, 0x0, 0x99 },
4119 | 	{ 0x206d95, 0x0, 0x52 },
4120 | 	{ 0x206d96, 0xeb, 0x50 },
4121 | 	{ 0x206d97, 0xc, 0x8b },
4122 | 	{ 0x206d98, 0x8b, 0x45 },
4123 | 	{ 0x206d99, 0x45, 0xf0 },
4124 | 	{ 0x206d9a, 0xd0, 0x8b },
4125 | 	{ 0x206d9b, 0x89, 0x55 },
4126 | 	{ 0x206d9c, 0x45, 0xf4 },
4127 | 	{ 0x206d9d, 0xc8, 0x2b },
4128 | 	{ 0x206d9e, 0x8b, 0x45 },
4129 | 	{ 0x206d9f, 0x45, 0xf8 },
4130 | 	{ 0x206da0, 0xd4, 0x1b },
4131 | 	{ 0x206da1, 0x89, 0x55 },
4132 | 	{ 0x206da2, 0x45, 0xfc },
4133 | 	{ 0x206da3, 0xcc, 0x29 },
4134 | 	{ 0x206da4, 0x8b, 0x4 },
4135 | 	{ 0x206da5, 0x45, 0x24 },
4136 | 	{ 0x206da6, 0xc8, 0x19 },
4137 | 	{ 0x206da7, 0x89, 0x54 },
4138 | 	{ 0x206da8, 0x45, 0x24 },
4139 | 	{ 0x206da9, 0xe8, 0x4 },
4140 | 	{ 0x206daa, 0x8b, 0x58 },
4141 | 	{ 0x206dab, 0x45, 0x5a },
4142 | 	{ 0x206dac, 0xcc, 0x89 },
4143 | 	{ 0x206dad, 0x89, 0x45 },
4144 | 	{ 0x206dae, 0x45, 0xd0 },
4145 | 	{ 0x206daf, 0xec, 0x89 },
4146 | 	{ 0x206db0, 0x83, 0x55 },
4147 | 	{ 0x206db1, 0x7d, 0xd4 },
4148 | 	{ 0x206db2, 0xec, 0x83 },
4149 | 	{ 0x206db3, 0x0, 0x7d },
4150 | 	{ 0x206db4, 0x75, 0xd4 },
4151 | 	{ 0x206db5, 0xb, 0x0 },
4152 | 	{ 0x206db6, 0x81, 0x75 },
4153 | 	{ 0x206db7, 0x7d, 0x8 },
4154 | 	{ 0x206db8, 0xe8, 0x83 },
4155 | 	{ 0x206db9, 0x40, 0x7d },
4156 | 	{ 0x206dba, 0x42, 0xd0 },
4157 | 	{ 0x206dbb, 0xf, 0x0 },
4158 | 	{ 0x206dbc, 0x0, 0x73 },
4159 | 	{ 0x206dbd, 0x73, 0x14 },
4160 | 	{ 0x206dbe, 0x12, 0xeb },
4161 | 	{ 0x206dbf, 0xeb, 0x2 },
4162 | 	{ 0x206dc0, 0x2, 0x7d },
4163 | 	{ 0x206dc1, 0x7d, 0x10 },
4164 | 	{ 0x206dc2, 0xe, 0xc7 },
4165 | 	{ 0x206dc3, 0x8b, 0x45 },
4166 | 	{ 0x206dc4, 0x45, 0xc8 },
4167 | 	{ 0x206dc5, 0xe8, 0x0 },
4168 | 	{ 0x206dc6, 0x89, 0x0 },
4169 | 	{ 0x206dc7, 0x45, 0x0 },
4170 | 	{ 0x206dc8, 0xc0, 0x0 },
4171 | 	{ 0x206dc9, 0x8b, 0xc7 },
4172 | 	{ 0x206dcb, 0xec, 0xcc },
4173 | 	{ 0x206dcc, 0x89, 0x0 },
4174 | 	{ 0x206dcd, 0x45, 0x0 },
4175 | 	{ 0x206dce, 0xc4, 0x0 },
4176 | 	{ 0x206dcf, 0xeb, 0x0 },
4177 | 	{ 0x206dd0, 0xe, 0xeb },
4178 | 	{ 0x206dd1, 0xc7, 0xc },
4179 | 	{ 0x206dd2, 0x45, 0x8b },
4180 | 	{ 0x206dd3, 0xc0, 0x45 },
4181 | 	{ 0x206dd4, 0x40, 0xd0 },
4182 | 	{ 0x206dd5, 0x42, 0x89 },
4183 | 	{ 0x206dd6, 0xf, 0x45 },
4184 | 	{ 0x206dd7, 0x0, 0xc8 },
4185 | 	{ 0x206dd8, 0xc7, 0x8b },
4186 | 	{ 0x206dda, 0xc4, 0xd4 },
4187 | 	{ 0x206ddb, 0x0, 0x89 },
4188 | 	{ 0x206ddc, 0x0, 0x45 },
4189 | 	{ 0x206ddd, 0x0, 0xcc },
4190 | 	{ 0x206dde, 0x0, 0x8b },
4191 | 	{ 0x206ddf, 0x8b, 0x45 },
4192 | 	{ 0x206de0, 0x45, 0xc8 },
4193 | 	{ 0x206de1, 0xc0, 0x89 },
4194 | 	{ 0x206de2, 0x89, 0x45 },
4195 | 	{ 0x206de3, 0x45, 0xe8 },
4196 | 	{ 0x206de4, 0xe8, 0x8b },
4197 | 	{ 0x206de5, 0x8b, 0x45 },
4198 | 	{ 0x206de6, 0x45, 0xcc },
4199 | 	{ 0x206de7, 0xc4, 0x89 },
4200 | 	{ 0x206de8, 0x89, 0x45 },
4201 | 	{ 0x206de9, 0x45, 0xec },
4202 | 	{ 0x206dea, 0xec, 0x83 },
4203 | 	{ 0x206deb, 0xff, 0x7d },
4204 | 	{ 0x206dec, 0x75, 0xec },
4205 | 	{ 0x206ded, 0xec, 0x0 },
4206 | 	{ 0x206dee, 0xff, 0x75 },
4207 | 	{ 0x206def, 0x75, 0xb },
4208 | 	{ 0x206df0, 0xe8, 0x81 },
4209 | 	{ 0x206df1, 0xe8, 0x7d },
4210 | 	{ 0x206df2, 0xbe, 0xe8 },
4211 | 	{ 0x206df3, 0x97, 0x40 },
4212 | 	{ 0x206df4, 0xf5, 0x42 },
4213 | 	{ 0x206df5, 0xff, 0xf },
4214 | 	{ 0x206df6, 0x8b, 0x0 },
4215 | 	{ 0x206df7, 0x45, 0x73 },
4216 | 	{ 0x206df8, 0xf0, 0x12 },
4217 | 	{ 0x206df9, 0x8b, 0xeb },
4218 | 	{ 0x206dfa, 0x55, 0x2 },
4219 | 	{ 0x206dfb, 0xf4, 0x7d },
4220 | 	{ 0x206dfc, 0x3, 0xe },
4221 | 	{ 0x206dfd, 0x45, 0x8b },
4222 | 	{ 0x206dfe, 0xe8, 0x45 },
4223 | 	{ 0x206dff, 0x13, 0xe8 },
4224 | 	{ 0x206e00, 0x55, 0x89 },
4225 | 	{ 0x206e01, 0xec, 0x45 },
4226 | 	{ 0x206e02, 0x89, 0xc0 },
4227 | 	{ 0x206e03, 0x45, 0x8b },
4228 | 	{ 0x206e04, 0xf8, 0x45 },
4229 | 	{ 0x206e05, 0x89, 0xec },
4230 | 	{ 0x206e06, 0x55, 0x89 },
4231 | 	{ 0x206e07, 0xfc, 0x45 },
4232 | 	{ 0x206e08, 0x8b, 0xc4 },
4233 | 	{ 0x206e09, 0x45, 0xeb },
4234 | 	{ 0x206e0a, 0xf8, 0xe },
4235 | 	{ 0x206e0b, 0x8b, 0xc7 },
4236 | 	{ 0x206e0c, 0x55, 0x45 },
4237 | 	{ 0x206e0d, 0xfc, 0xc0 },
4238 | 	{ 0x206e0e, 0x3b, 0x40 },
4239 | 	{ 0x206e0f, 0x55, 0x42 },
4240 | 	{ 0x206e10, 0xe4, 0xf },
4241 | 	{ 0x206e11, 0x75, 0x0 },
4242 | 	{ 0x206e12, 0x7, 0xc7 },
4243 | 	{ 0x206e13, 0x3b, 0x45 },
4244 | 	{ 0x206e14, 0x45, 0xc4 },
4245 | 	{ 0x206e15, 0xe0, 0x0 },
4246 | 	{ 0x206e16, 0x73, 0x0 },
4247 | 	{ 0x206e17, 0x10, 0x0 },
4248 | 	{ 0x206e18, 0xeb, 0x0 },
4249 | 	{ 0x206e19, 0x2, 0x8b },
4250 | 	{ 0x206e1a, 0x7d, 0x45 },
4251 | 	{ 0x206e1b, 0xc, 0xc0 },
4252 | 	{ 0x206e1c, 0x8b, 0x89 },
4253 | 	{ 0x206e1e, 0xf8, 0xe8 },
4254 | 	{ 0x206e1f, 0x89, 0x8b },
4255 | 	{ 0x206e21, 0xe0, 0xc4 },
4256 | 	{ 0x206e22, 0x8b, 0x89 },
4257 | 	{ 0x206e24, 0xfc, 0xec },
4258 | 	{ 0x206e25, 0x89, 0xff },
4259 | 	{ 0x206e26, 0x45, 0x75 },
4260 | 	{ 0x206e27, 0xe4, 0xec },
4261 | 	{ 0x206e28, 0x6a, 0xff },
4262 | 	{ 0x206e29, 0x0, 0x75 },
4263 | 	{ 0x206e2a, 0x68, 0xe8 },
4264 | 	{ 0x206e2b, 0x40, 0xe8 },
4265 | 	{ 0x206e2c, 0x42, 0x84 },
4266 | 	{ 0x206e2d, 0xf, 0x97 },
4267 | 	{ 0x206e2e, 0x0, 0xf5 },
4268 | 	{ 0x206e2f, 0x8b, 0xff },
4269 | 	{ 0x206e30, 0x45, 0x8b },
4270 | 	{ 0x206e31, 0xf8, 0x45 },
4271 | 	{ 0x206e32, 0x8b, 0xf0 },
4272 | 	{ 0x206e33, 0x55, 0x8b },
4273 | 	{ 0x206e34, 0xfc, 0x55 },
4274 | 	{ 0x206e35, 0xe8, 0xf4 },
4275 | 	{ 0x206e36, 0x32, 0x3 },
4276 | 	{ 0x206e37, 0x1d, 0x45 },
4277 | 	{ 0x206e38, 0xe0, 0xe8 },
4278 | 	{ 0x206e39, 0xff, 0x13 },
4279 | 	{ 0x206e3a, 0x52, 0x55 },
4280 | 	{ 0x206e3b, 0x50, 0xec },
4281 | 	{ 0x206e3c, 0x6a, 0x89 },
4282 | 	{ 0x206e3d, 0x0, 0x45 },
4283 | 	{ 0x206e3e, 0x68, 0xf8 },
4284 | 	{ 0x206e3f, 0x40, 0x89 },
4285 | 	{ 0x206e40, 0x42, 0x55 },
4286 | 	{ 0x206e41, 0xf, 0xfc },
4287 | 	{ 0x206e42, 0x0, 0x8b },
4288 | 	{ 0x206e43, 0x8b, 0x45 },
4289 | 	{ 0x206e44, 0x45, 0xf8 },
4290 | 	{ 0x206e45, 0xe0, 0x8b },
4291 | 	{ 0x206e46, 0x8b, 0x55 },
4292 | 	{ 0x206e47, 0x55, 0xfc },
4293 | 	{ 0x206e48, 0xe4, 0x3b },
4294 | 	{ 0x206e49, 0xe8, 0x55 },
4295 | 	{ 0x206e4a, 0x1e, 0xe4 },
4296 | 	{ 0x206e4b, 0x1d, 0x75 },
4297 | 	{ 0x206e4c, 0xe0, 0x7 },
4298 | 	{ 0x206e4d, 0xff, 0x3b },
4299 | 	{ 0x206e4e, 0x3b, 0x45 },
4300 | 	{ 0x206e4f, 0x54, 0xe0 },
4301 | 	{ 0x206e50, 0x24, 0x73 },
4302 | 	{ 0x206e51, 0x4, 0x10 },
4303 | 	{ 0x206e52, 0x75, 0xeb },
4304 | 	{ 0x206e53, 0x9, 0x2 },
4305 | 	{ 0x206e54, 0x3b, 0x7d },
4306 | 	{ 0x206e55, 0x4, 0xc },
4307 | 	{ 0x206e56, 0x24, 0x8b },
4308 | 	{ 0x206e57, 0x5a, 0x45 },
4309 | 	{ 0x206e58, 0x58, 0xf8 },
4310 | 	{ 0x206e59, 0x73, 0x89 },
4311 | 	{ 0x206e5a, 0x21, 0x45 },
4312 | 	{ 0x206e5b, 0xeb, 0xe0 },
4313 | 	{ 0x206e5c, 0x4, 0x8b },
4314 | 	{ 0x206e5d, 0x5a, 0x45 },
4315 | 	{ 0x206e5e, 0x58, 0xfc },
4316 | 	{ 0x206e5f, 0x7d, 0x89 },
4317 | 	{ 0x206e60, 0x1b, 0x45 },
4318 | 	{ 0x206e61, 0xa1, 0xe4 },
4319 | 	{ 0x206e62, 0x2c, 0x6a },
4320 | 	{ 0x206e63, 0x89, 0x0 },
4321 | 	{ 0x206e65, 0x0, 0x40 },
4322 | 	{ 0x206e66, 0x8b, 0x42 },
4323 | 	{ 0x206e67, 0x55, 0xf },
4324 | 	{ 0x206e68, 0xdc, 0x0 },
4325 | 	{ 0x206e69, 0x89, 0x8b },
4326 | 	{ 0x206e6a, 0x10, 0x45 },
4327 | 	{ 0x206e6b, 0x33, 0xf8 },
4328 | 	{ 0x206e6c, 0xc0, 0x8b },
4329 | 	{ 0x206e6d, 0x89, 0x55 },
4330 | 	{ 0x206e6e, 0x45, 0xfc },
4331 | 	{ 0x206e6f, 0xdc, 0xe8 },
4332 | 	{ 0x206e70, 0x8b, 0xf8 },
4333 | 	{ 0x206e71, 0x45, 0x1c },
4334 | 	{ 0x206e72, 0xf8, 0xe0 },
4335 | 	{ 0x206e73, 0x89, 0xff },
4336 | 	{ 0x206e74, 0x45, 0x52 },
4337 | 	{ 0x206e75, 0xe0, 0x50 },
4338 | 	{ 0x206e76, 0x8b, 0x6a },
4339 | 	{ 0x206e77, 0x45, 0x0 },
4340 | 	{ 0x206e78, 0xfc, 0x68 },
4341 | 	{ 0x206e79, 0x89, 0x40 },
4342 | 	{ 0x206e7a, 0x45, 0x42 },
4343 | 	{ 0x206e7b, 0xe4, 0xf },
4344 | 	{ 0x206e7c, 0xff, 0x0 },
4345 | 	{ 0x206e7d, 0x45, 0x8b },
4346 | 	{ 0x206e7e, 0xdc, 0x45 },
4347 | 	{ 0x206e7f, 0xa1, 0xe0 },
4348 | 	{ 0x206e80, 0x48, 0x8b },
4349 | 	{ 0x206e81, 0x8c, 0x55 },
4350 | 	{ 0x206e82, 0x68, 0xe4 },
4351 | 	{ 0x206e83, 0x0, 0xe8 },
4352 | 	{ 0x206e84, 0x83, 0xe4 },
4353 | 	{ 0x206e85, 0x38, 0x1c },
4354 | 	{ 0x206e86, 0xff, 0xe0 },
4355 | 	{ 0x206e87, 0x75, 0xff },
4356 | 	{ 0x206e88, 0x30, 0x3b },
4357 | 	{ 0x206e89, 0xa1, 0x54 },
4358 | 	{ 0x206e8a, 0xcc, 0x24 },
4359 | 	{ 0x206e8b, 0x91, 0x4 },
4360 | 	{ 0x206e8c, 0x68, 0x75 },
4361 | 	{ 0x206e8d, 0x0, 0x9 },
4362 | 	{ 0x206e8e, 0x80, 0x3b },
4363 | 	{ 0x206e8f, 0x38, 0x4 },
4364 | 	{ 0x206e90, 0x0, 0x24 },
4365 | 	{ 0x206e91, 0x74, 0x5a },
4366 | 	{ 0x206e92, 0x26, 0x58 },
4367 | 	{ 0x206e93, 0xe8, 0x73 },
4368 | 	{ 0x206e94, 0x40, 0x21 },
4369 | 	{ 0x206e95, 0x84, 0xeb },
4370 | 	{ 0x206e96, 0x1, 0x4 },
4371 | 	{ 0x206e97, 0x0, 0x5a },
4372 | 	{ 0x206e98, 0xa1, 0x58 },
4373 | 	{ 0x206e99, 0x38, 0x7d },
4374 | 	{ 0x206e9a, 0x8a, 0x1b },
4375 | 	{ 0x206e9b, 0x68, 0xa1 },
4376 | 	{ 0x206e9c, 0x0, 0x2c },
4377 | 	{ 0x206e9d, 0x80, 0x89 },
4378 | 	{ 0x206e9e, 0x38, 0x68 },
4379 | 	{ 0x206ea0, 0x74, 0x8b },
4380 | 	{ 0x206ea1, 0x12, 0x55 },
4381 | 	{ 0x206ea2, 0xe8, 0xdc },
4382 | 	{ 0x206ea3, 0x99, 0x89 },
4383 | 	{ 0x206ea4, 0xa0, 0x10 },
4384 | 	{ 0x206ea5, 0xf5, 0x33 },
4385 | 	{ 0x206ea6, 0xff, 0xc0 },
4386 | 	{ 0x206ea7, 0xe8, 0x89 },
4387 | 	{ 0x206ea8, 0xd8, 0x45 },
4388 | 	{ 0x206ea9, 0x7e, 0xdc },
4389 | 	{ 0x206eaa, 0x1, 0x8b },
4390 | 	{ 0x206eab, 0x0, 0x45 },
4391 | 	{ 0x206eac, 0xa1, 0xf8 },
4392 | 	{ 0x206ead, 0x38, 0x89 },
4393 | 	{ 0x206eae, 0x8a, 0x45 },
4394 | 	{ 0x206eaf, 0x68, 0xe0 },
4395 | 	{ 0x206eb0, 0x0, 0x8b },
4396 | 	{ 0x206eb1, 0xc6, 0x45 },
4397 | 	{ 0x206eb2, 0x0, 0xfc },
4398 | 	{ 0x206eb3, 0x0, 0x89 },
4399 | 	{ 0x206eb4, 0xe8, 0x45 },
4400 | 	{ 0x206eb5, 0xff, 0xe4 },
4401 | 	{ 0x206eb6, 0x83, 0xff },
4402 | 	{ 0x206eb7, 0x1, 0x45 },
4403 | 	{ 0x206eb8, 0x0, 0xdc },
4404 | 	{-1,0,0}
4405 | };
4406 | 
4407 | PatchByte inputlagpatch_81_141[] = {
4408 | 	{ 0x206d13, 0xe8, 0xa1 },
4409 | 	{ 0x206d14, 0x10, 0x4c },
4410 | 	{ 0x206d15, 0x98, 0x8c },
4411 | 	{ 0x206d16, 0xf5, 0x68 },
4412 | 	{ 0x206d17, 0xff, 0x0 },
4413 | 	{ 0x206d18, 0x89, 0x83 },
4414 | 	{ 0x206d19, 0x45, 0x38 },
4415 | 	{ 0x206d1a, 0xf0, 0xff },
4416 | 	{ 0x206d1b, 0x89, 0x75 },
4417 | 	{ 0x206d1c, 0x55, 0x30 },
4418 | 	{ 0x206d1d, 0xf4, 0xa1 },
4419 | 	{ 0x206d1e, 0x8b, 0xd0 },
4420 | 	{ 0x206d1f, 0x45, 0x91 },
4421 | 	{ 0x206d20, 0xf0, 0x68 },
4422 | 	{ 0x206d21, 0x8b, 0x0 },
4423 | 	{ 0x206d22, 0x55, 0x80 },
4424 | 	{ 0x206d23, 0xf4, 0x38 },
4425 | 	{ 0x206d24, 0x3b, 0x0 },
4426 | 	{ 0x206d25, 0x55, 0x74 },
4427 | 	{ 0x206d26, 0xfc, 0x26 },
4428 | 	{ 0x206d27, 0x75, 0xe8 },
4429 | 	{ 0x206d28, 0x7, 0x30 },
4430 | 	{ 0x206d29, 0x3b, 0x86 },
4431 | 	{ 0x206d2a, 0x45, 0x1 },
4432 | 	{ 0x206d2b, 0xf8, 0x0 },
4433 | 	{ 0x206d2c, 0x73, 0xa1 },
4434 | 	{ 0x206d2d, 0x10, 0x38 },
4435 | 	{ 0x206d2e, 0xeb, 0x8a },
4436 | 	{ 0x206d2f, 0x2, 0x68 },
4437 | 	{ 0x206d30, 0x7d, 0x0 },
4438 | 	{ 0x206d31, 0xc, 0x80 },
4439 | 	{ 0x206d32, 0x8b, 0x38 },
4440 | 	{ 0x206d33, 0x45, 0x0 },
4441 | 	{ 0x206d34, 0xf0, 0x74 },
4442 | 	{ 0x206d35, 0x89, 0x12 },
4443 | 	{ 0x206d36, 0x45, 0xe8 },
4444 | 	{ 0x206d37, 0xf8, 0x5 },
4445 | 	{ 0x206d38, 0x8b, 0xa2 },
4446 | 	{ 0x206d39, 0x45, 0xf5 },
4447 | 	{ 0x206d3a, 0xf4, 0xff },
4448 | 	{ 0x206d3b, 0x89, 0xe8 },
4449 | 	{ 0x206d3c, 0x45, 0xb4 },
4450 | 	{ 0x206d3d, 0xfc, 0x80 },
4451 | 	{ 0x206d3e, 0xa1, 0x1 },
4452 | 	{ 0x206d3f, 0x9c, 0x0 },
4453 | 	{ 0x206d40, 0x93, 0xa1 },
4454 | 	{ 0x206d41, 0x68, 0x38 },
4455 | 	{ 0x206d42, 0x0, 0x8a },
4456 | 	{ 0x206d43, 0x8b, 0x68 },
4457 | 	{ 0x206d45, 0x83, 0xc6 },
4458 | 	{ 0x206d46, 0x78, 0x0 },
4459 | 	{ 0x206d47, 0x8, 0x0 },
4460 | 	{ 0x206d48, 0x0, 0xe8 },
4461 | 	{ 0x206d49, 0x7f, 0xef },
4462 | 	{ 0x206d4a, 0xe, 0x85 },
4463 | 	{ 0x206d4b, 0xa1, 0x1 },
4464 | 	{ 0x206d4c, 0x9c, 0x0 },
4465 | 	{ 0x206d4d, 0x93, 0xe8 },
4466 | 	{ 0x206d4e, 0x68, 0xd6 },
4467 | 	{ 0x206d4f, 0x0, 0x97 },
4468 | 	{ 0x206d50, 0x8b, 0xf5 },
4469 | 	{ 0x206d51, 0x0, 0xff },
4470 | 	{ 0x206d52, 0xc7, 0x89 },
4471 | 	{ 0x206d53, 0x40, 0x45 },
4472 | 	{ 0x206d54, 0x8, 0xf0 },
4473 | 	{ 0x206d55, 0x1, 0x89 },
4474 | 	{ 0x206d56, 0x0, 0x55 },
4475 | 	{ 0x206d57, 0x0, 0xf4 },
4476 | 	{ 0x206d58, 0x0, 0x8b },
4477 | 	{ 0x206d59, 0xa1, 0x45 },
4478 | 	{ 0x206d5a, 0x9c, 0xf0 },
4479 | 	{ 0x206d5b, 0x93, 0x8b },
4480 | 	{ 0x206d5c, 0x68, 0x55 },
4481 | 	{ 0x206d5d, 0x0, 0xf4 },
4482 | 	{ 0x206d5e, 0x8b, 0x3b },
4483 | 	{ 0x206d5f, 0x0, 0x55 },
4484 | 	{ 0x206d60, 0xff, 0xfc },
4485 | 	{ 0x206d61, 0x70, 0x75 },
4486 | 	{ 0x206d62, 0x8, 0x7 },
4487 | 	{ 0x206d63, 0xb8, 0x3b },
4488 | 	{ 0x206d64, 0x40, 0x45 },
4489 | 	{ 0x206d65, 0x42, 0xf8 },
4490 | 	{ 0x206d66, 0xf, 0x73 },
4491 | 	{ 0x206d67, 0x0, 0x10 },
4492 | 	{ 0x206d68, 0x5a, 0xeb },
4493 | 	{ 0x206d69, 0x8b, 0x2 },
4494 | 	{ 0x206d6a, 0xca, 0x7d },
4495 | 	{ 0x206d6b, 0x99, 0xc },
4496 | 	{ 0x206d6c, 0xf7, 0x8b },
4497 | 	{ 0x206d6d, 0xf9, 0x45 },
4498 | 	{ 0x206d6e, 0x99, 0xf0 },
4499 | 	{ 0x206d6f, 0x52, 0x89 },
4500 | 	{ 0x206d70, 0x50, 0x45 },
4501 | 	{ 0x206d71, 0x8b, 0xf8 },
4502 | 	{ 0x206d72, 0x45, 0x8b },
4503 | 	{ 0x206d73, 0xf0, 0x45 },
4504 | 	{ 0x206d74, 0x8b, 0xf4 },
4505 | 	{ 0x206d75, 0x55, 0x89 },
4506 | 	{ 0x206d76, 0xf4, 0x45 },
4507 | 	{ 0x206d77, 0x2b, 0xfc },
4508 | 	{ 0x206d78, 0x45, 0xa1 },
4509 | 	{ 0x206d79, 0xf8, 0x9c },
4510 | 	{ 0x206d7a, 0x1b, 0x93 },
4511 | 	{ 0x206d7b, 0x55, 0x68 },
4512 | 	{ 0x206d7c, 0xfc, 0x0 },
4513 | 	{ 0x206d7d, 0x29, 0x8b },
4514 | 	{ 0x206d7e, 0x4, 0x0 },
4515 | 	{ 0x206d7f, 0x24, 0x83 },
4516 | 	{ 0x206d80, 0x19, 0x78 },
4517 | 	{ 0x206d81, 0x54, 0x8 },
4518 | 	{ 0x206d82, 0x24, 0x0 },
4519 | 	{ 0x206d83, 0x4, 0x7f },
4520 | 	{ 0x206d84, 0x58, 0xe },
4521 | 	{ 0x206d85, 0x5a, 0xa1 },
4522 | 	{ 0x206d86, 0x89, 0x9c },
4523 | 	{ 0x206d87, 0x45, 0x93 },
4524 | 	{ 0x206d88, 0xd0, 0x68 },
4525 | 	{ 0x206d89, 0x89, 0x0 },
4526 | 	{ 0x206d8a, 0x55, 0x8b },
4527 | 	{ 0x206d8b, 0xd4, 0x0 },
4528 | 	{ 0x206d8c, 0x83, 0xc7 },
4529 | 	{ 0x206d8d, 0x7d, 0x40 },
4530 | 	{ 0x206d8e, 0xd4, 0x8 },
4531 | 	{ 0x206d8f, 0x0, 0x1 },
4532 | 	{ 0x206d90, 0x75, 0x0 },
4533 | 	{ 0x206d91, 0x8, 0x0 },
4534 | 	{ 0x206d92, 0x83, 0x0 },
4535 | 	{ 0x206d93, 0x7d, 0xa1 },
4536 | 	{ 0x206d94, 0xd0, 0x9c },
4537 | 	{ 0x206d95, 0x0, 0x93 },
4538 | 	{ 0x206d96, 0x73, 0x68 },
4539 | 	{ 0x206d97, 0x14, 0x0 },
4540 | 	{ 0x206d98, 0xeb, 0x8b },
4541 | 	{ 0x206d99, 0x2, 0x0 },
4542 | 	{ 0x206d9a, 0x7d, 0xff },
4543 | 	{ 0x206d9b, 0x10, 0x70 },
4544 | 	{ 0x206d9c, 0xc7, 0x8 },
4545 | 	{ 0x206d9d, 0x45, 0xb8 },
4546 | 	{ 0x206d9e, 0xc8, 0x40 },
4547 | 	{ 0x206d9f, 0x0, 0x42 },
4548 | 	{ 0x206da0, 0x0, 0xf },
4549 | 	{ 0x206da2, 0x0, 0x5a },
4550 | 	{ 0x206da3, 0xc7, 0x8b },
4551 | 	{ 0x206da4, 0x45, 0xca },
4552 | 	{ 0x206da5, 0xcc, 0x99 },
4553 | 	{ 0x206da6, 0x0, 0xf7 },
4554 | 	{ 0x206da7, 0x0, 0xf9 },
4555 | 	{ 0x206da8, 0x0, 0x99 },
4556 | 	{ 0x206da9, 0x0, 0x52 },
4557 | 	{ 0x206daa, 0xeb, 0x50 },
4558 | 	{ 0x206dab, 0xc, 0x8b },
4559 | 	{ 0x206dac, 0x8b, 0x45 },
4560 | 	{ 0x206dad, 0x45, 0xf0 },
4561 | 	{ 0x206dae, 0xd0, 0x8b },
4562 | 	{ 0x206daf, 0x89, 0x55 },
4563 | 	{ 0x206db0, 0x45, 0xf4 },
4564 | 	{ 0x206db1, 0xc8, 0x2b },
4565 | 	{ 0x206db2, 0x8b, 0x45 },
4566 | 	{ 0x206db3, 0x45, 0xf8 },
4567 | 	{ 0x206db4, 0xd4, 0x1b },
4568 | 	{ 0x206db5, 0x89, 0x55 },
4569 | 	{ 0x206db6, 0x45, 0xfc },
4570 | 	{ 0x206db7, 0xcc, 0x29 },
4571 | 	{ 0x206db8, 0x8b, 0x4 },
4572 | 	{ 0x206db9, 0x45, 0x24 },
4573 | 	{ 0x206dba, 0xc8, 0x19 },
4574 | 	{ 0x206dbb, 0x89, 0x54 },
4575 | 	{ 0x206dbc, 0x45, 0x24 },
4576 | 	{ 0x206dbd, 0xe8, 0x4 },
4577 | 	{ 0x206dbe, 0x8b, 0x58 },
4578 | 	{ 0x206dbf, 0x45, 0x5a },
4579 | 	{ 0x206dc0, 0xcc, 0x89 },
4580 | 	{ 0x206dc1, 0x89, 0x45 },
4581 | 	{ 0x206dc2, 0x45, 0xd0 },
4582 | 	{ 0x206dc3, 0xec, 0x89 },
4583 | 	{ 0x206dc4, 0x83, 0x55 },
4584 | 	{ 0x206dc5, 0x7d, 0xd4 },
4585 | 	{ 0x206dc6, 0xec, 0x83 },
4586 | 	{ 0x206dc7, 0x0, 0x7d },
4587 | 	{ 0x206dc8, 0x75, 0xd4 },
4588 | 	{ 0x206dc9, 0xb, 0x0 },
4589 | 	{ 0x206dca, 0x81, 0x75 },
4590 | 	{ 0x206dcb, 0x7d, 0x8 },
4591 | 	{ 0x206dcc, 0xe8, 0x83 },
4592 | 	{ 0x206dcd, 0x40, 0x7d },
4593 | 	{ 0x206dce, 0x42, 0xd0 },
4594 | 	{ 0x206dcf, 0xf, 0x0 },
4595 | 	{ 0x206dd0, 0x0, 0x73 },
4596 | 	{ 0x206dd1, 0x73, 0x14 },
4597 | 	{ 0x206dd2, 0x12, 0xeb },
4598 | 	{ 0x206dd3, 0xeb, 0x2 },
4599 | 	{ 0x206dd4, 0x2, 0x7d },
4600 | 	{ 0x206dd5, 0x7d, 0x10 },
4601 | 	{ 0x206dd6, 0xe, 0xc7 },
4602 | 	{ 0x206dd7, 0x8b, 0x45 },
4603 | 	{ 0x206dd8, 0x45, 0xc8 },
4604 | 	{ 0x206dd9, 0xe8, 0x0 },
4605 | 	{ 0x206dda, 0x89, 0x0 },
4606 | 	{ 0x206ddb, 0x45, 0x0 },
4607 | 	{ 0x206ddc, 0xc0, 0x0 },
4608 | 	{ 0x206ddd, 0x8b, 0xc7 },
4609 | 	{ 0x206ddf, 0xec, 0xcc },
4610 | 	{ 0x206de0, 0x89, 0x0 },
4611 | 	{ 0x206de1, 0x45, 0x0 },
4612 | 	{ 0x206de2, 0xc4, 0x0 },
4613 | 	{ 0x206de3, 0xeb, 0x0 },
4614 | 	{ 0x206de4, 0xe, 0xeb },
4615 | 	{ 0x206de5, 0xc7, 0xc },
4616 | 	{ 0x206de6, 0x45, 0x8b },
4617 | 	{ 0x206de7, 0xc0, 0x45 },
4618 | 	{ 0x206de8, 0x40, 0xd0 },
4619 | 	{ 0x206de9, 0x42, 0x89 },
4620 | 	{ 0x206dea, 0xf, 0x45 },
4621 | 	{ 0x206deb, 0x0, 0xc8 },
4622 | 	{ 0x206dec, 0xc7, 0x8b },
4623 | 	{ 0x206dee, 0xc4, 0xd4 },
4624 | 	{ 0x206def, 0x0, 0x89 },
4625 | 	{ 0x206df0, 0x0, 0x45 },
4626 | 	{ 0x206df1, 0x0, 0xcc },
4627 | 	{ 0x206df2, 0x0, 0x8b },
4628 | 	{ 0x206df3, 0x8b, 0x45 },
4629 | 	{ 0x206df4, 0x45, 0xc8 },
4630 | 	{ 0x206df5, 0xc0, 0x89 },
4631 | 	{ 0x206df6, 0x89, 0x45 },
4632 | 	{ 0x206df7, 0x45, 0xe8 },
4633 | 	{ 0x206df8, 0xe8, 0x8b },
4634 | 	{ 0x206df9, 0x8b, 0x45 },
4635 | 	{ 0x206dfa, 0x45, 0xcc },
4636 | 	{ 0x206dfb, 0xc4, 0x89 },
4637 | 	{ 0x206dfc, 0x89, 0x45 },
4638 | 	{ 0x206dfd, 0x45, 0xec },
4639 | 	{ 0x206dfe, 0xec, 0x83 },
4640 | 	{ 0x206dff, 0xff, 0x7d },
4641 | 	{ 0x206e00, 0x75, 0xec },
4642 | 	{ 0x206e01, 0xec, 0x0 },
4643 | 	{ 0x206e02, 0xff, 0x75 },
4644 | 	{ 0x206e03, 0x75, 0xb },
4645 | 	{ 0x206e04, 0xe8, 0x81 },
4646 | 	{ 0x206e05, 0xe8, 0x7d },
4647 | 	{ 0x206e06, 0xaa, 0xe8 },
4648 | 	{ 0x206e07, 0x97, 0x40 },
4649 | 	{ 0x206e08, 0xf5, 0x42 },
4650 | 	{ 0x206e09, 0xff, 0xf },
4651 | 	{ 0x206e0a, 0x8b, 0x0 },
4652 | 	{ 0x206e0b, 0x45, 0x73 },
4653 | 	{ 0x206e0c, 0xf0, 0x12 },
4654 | 	{ 0x206e0d, 0x8b, 0xeb },
4655 | 	{ 0x206e0e, 0x55, 0x2 },
4656 | 	{ 0x206e0f, 0xf4, 0x7d },
4657 | 	{ 0x206e10, 0x3, 0xe },
4658 | 	{ 0x206e11, 0x45, 0x8b },
4659 | 	{ 0x206e12, 0xe8, 0x45 },
4660 | 	{ 0x206e13, 0x13, 0xe8 },
4661 | 	{ 0x206e14, 0x55, 0x89 },
4662 | 	{ 0x206e15, 0xec, 0x45 },
4663 | 	{ 0x206e16, 0x89, 0xc0 },
4664 | 	{ 0x206e17, 0x45, 0x8b },
4665 | 	{ 0x206e18, 0xf8, 0x45 },
4666 | 	{ 0x206e19, 0x89, 0xec },
4667 | 	{ 0x206e1a, 0x55, 0x89 },
4668 | 	{ 0x206e1b, 0xfc, 0x45 },
4669 | 	{ 0x206e1c, 0x8b, 0xc4 },
4670 | 	{ 0x206e1d, 0x45, 0xeb },
4671 | 	{ 0x206e1e, 0xf8, 0xe },
4672 | 	{ 0x206e1f, 0x8b, 0xc7 },
4673 | 	{ 0x206e20, 0x55, 0x45 },
4674 | 	{ 0x206e21, 0xfc, 0xc0 },
4675 | 	{ 0x206e22, 0x3b, 0x40 },
4676 | 	{ 0x206e23, 0x55, 0x42 },
4677 | 	{ 0x206e24, 0xe4, 0xf },
4678 | 	{ 0x206e25, 0x75, 0x0 },
4679 | 	{ 0x206e26, 0x7, 0xc7 },
4680 | 	{ 0x206e27, 0x3b, 0x45 },
4681 | 	{ 0x206e28, 0x45, 0xc4 },
4682 | 	{ 0x206e29, 0xe0, 0x0 },
4683 | 	{ 0x206e2a, 0x73, 0x0 },
4684 | 	{ 0x206e2b, 0x10, 0x0 },
4685 | 	{ 0x206e2c, 0xeb, 0x0 },
4686 | 	{ 0x206e2d, 0x2, 0x8b },
4687 | 	{ 0x206e2e, 0x7d, 0x45 },
4688 | 	{ 0x206e2f, 0xc, 0xc0 },
4689 | 	{ 0x206e30, 0x8b, 0x89 },
4690 | 	{ 0x206e32, 0xf8, 0xe8 },
4691 | 	{ 0x206e33, 0x89, 0x8b },
4692 | 	{ 0x206e35, 0xe0, 0xc4 },
4693 | 	{ 0x206e36, 0x8b, 0x89 },
4694 | 	{ 0x206e38, 0xfc, 0xec },
4695 | 	{ 0x206e39, 0x89, 0xff },
4696 | 	{ 0x206e3a, 0x45, 0x75 },
4697 | 	{ 0x206e3b, 0xe4, 0xec },
4698 | 	{ 0x206e3c, 0x6a, 0xff },
4699 | 	{ 0x206e3d, 0x0, 0x75 },
4700 | 	{ 0x206e3e, 0x68, 0xe8 },
4701 | 	{ 0x206e3f, 0x40, 0xe8 },
4702 | 	{ 0x206e40, 0x42, 0x70 },
4703 | 	{ 0x206e41, 0xf, 0x97 },
4704 | 	{ 0x206e42, 0x0, 0xf5 },
4705 | 	{ 0x206e43, 0x8b, 0xff },
4706 | 	{ 0x206e44, 0x45, 0x8b },
4707 | 	{ 0x206e45, 0xf8, 0x45 },
4708 | 	{ 0x206e46, 0x8b, 0xf0 },
4709 | 	{ 0x206e47, 0x55, 0x8b },
4710 | 	{ 0x206e48, 0xfc, 0x55 },
4711 | 	{ 0x206e49, 0xe8, 0xf4 },
4712 | 	{ 0x206e4a, 0x1e, 0x3 },
4713 | 	{ 0x206e4b, 0x1d, 0x45 },
4714 | 	{ 0x206e4c, 0xe0, 0xe8 },
4715 | 	{ 0x206e4d, 0xff, 0x13 },
4716 | 	{ 0x206e4e, 0x52, 0x55 },
4717 | 	{ 0x206e4f, 0x50, 0xec },
4718 | 	{ 0x206e50, 0x6a, 0x89 },
4719 | 	{ 0x206e51, 0x0, 0x45 },
4720 | 	{ 0x206e52, 0x68, 0xf8 },
4721 | 	{ 0x206e53, 0x40, 0x89 },
4722 | 	{ 0x206e54, 0x42, 0x55 },
4723 | 	{ 0x206e55, 0xf, 0xfc },
4724 | 	{ 0x206e56, 0x0, 0x8b },
4725 | 	{ 0x206e57, 0x8b, 0x45 },
4726 | 	{ 0x206e58, 0x45, 0xf8 },
4727 | 	{ 0x206e59, 0xe0, 0x8b },
4728 | 	{ 0x206e5a, 0x8b, 0x55 },
4729 | 	{ 0x206e5b, 0x55, 0xfc },
4730 | 	{ 0x206e5c, 0xe4, 0x3b },
4731 | 	{ 0x206e5d, 0xe8, 0x55 },
4732 | 	{ 0x206e5e, 0xa, 0xe4 },
4733 | 	{ 0x206e5f, 0x1d, 0x75 },
4734 | 	{ 0x206e60, 0xe0, 0x7 },
4735 | 	{ 0x206e61, 0xff, 0x3b },
4736 | 	{ 0x206e62, 0x3b, 0x45 },
4737 | 	{ 0x206e63, 0x54, 0xe0 },
4738 | 	{ 0x206e64, 0x24, 0x73 },
4739 | 	{ 0x206e65, 0x4, 0x10 },
4740 | 	{ 0x206e66, 0x75, 0xeb },
4741 | 	{ 0x206e67, 0x9, 0x2 },
4742 | 	{ 0x206e68, 0x3b, 0x7d },
4743 | 	{ 0x206e69, 0x4, 0xc },
4744 | 	{ 0x206e6a, 0x24, 0x8b },
4745 | 	{ 0x206e6b, 0x5a, 0x45 },
4746 | 	{ 0x206e6c, 0x58, 0xf8 },
4747 | 	{ 0x206e6d, 0x73, 0x89 },
4748 | 	{ 0x206e6e, 0x21, 0x45 },
4749 | 	{ 0x206e6f, 0xeb, 0xe0 },
4750 | 	{ 0x206e70, 0x4, 0x8b },
4751 | 	{ 0x206e71, 0x5a, 0x45 },
4752 | 	{ 0x206e72, 0x58, 0xfc },
4753 | 	{ 0x206e73, 0x7d, 0x89 },
4754 | 	{ 0x206e74, 0x1b, 0x45 },
4755 | 	{ 0x206e75, 0xa1, 0xe4 },
4756 | 	{ 0x206e76, 0x2c, 0x6a },
4757 | 	{ 0x206e77, 0x89, 0x0 },
4758 | 	{ 0x206e79, 0x0, 0x40 },
4759 | 	{ 0x206e7a, 0x8b, 0x42 },
4760 | 	{ 0x206e7b, 0x55, 0xf },
4761 | 	{ 0x206e7c, 0xdc, 0x0 },
4762 | 	{ 0x206e7d, 0x89, 0x8b },
4763 | 	{ 0x206e7e, 0x10, 0x45 },
4764 | 	{ 0x206e7f, 0x33, 0xf8 },
4765 | 	{ 0x206e80, 0xc0, 0x8b },
4766 | 	{ 0x206e81, 0x89, 0x55 },
4767 | 	{ 0x206e82, 0x45, 0xfc },
4768 | 	{ 0x206e83, 0xdc, 0xe8 },
4769 | 	{ 0x206e84, 0x8b, 0xe4 },
4770 | 	{ 0x206e85, 0x45, 0x1c },
4771 | 	{ 0x206e86, 0xf8, 0xe0 },
4772 | 	{ 0x206e87, 0x89, 0xff },
4773 | 	{ 0x206e88, 0x45, 0x52 },
4774 | 	{ 0x206e89, 0xe0, 0x50 },
4775 | 	{ 0x206e8a, 0x8b, 0x6a },
4776 | 	{ 0x206e8b, 0x45, 0x0 },
4777 | 	{ 0x206e8c, 0xfc, 0x68 },
4778 | 	{ 0x206e8d, 0x89, 0x40 },
4779 | 	{ 0x206e8e, 0x45, 0x42 },
4780 | 	{ 0x206e8f, 0xe4, 0xf },
4781 | 	{ 0x206e90, 0xff, 0x0 },
4782 | 	{ 0x206e91, 0x45, 0x8b },
4783 | 	{ 0x206e92, 0xdc, 0x45 },
4784 | 	{ 0x206e93, 0xa1, 0xe0 },
4785 | 	{ 0x206e94, 0x4c, 0x8b },
4786 | 	{ 0x206e95, 0x8c, 0x55 },
4787 | 	{ 0x206e96, 0x68, 0xe4 },
4788 | 	{ 0x206e97, 0x0, 0xe8 },
4789 | 	{ 0x206e98, 0x83, 0xd0 },
4790 | 	{ 0x206e99, 0x38, 0x1c },
4791 | 	{ 0x206e9a, 0xff, 0xe0 },
4792 | 	{ 0x206e9b, 0x75, 0xff },
4793 | 	{ 0x206e9c, 0x30, 0x3b },
4794 | 	{ 0x206e9d, 0xa1, 0x54 },
4795 | 	{ 0x206e9e, 0xd0, 0x24 },
4796 | 	{ 0x206e9f, 0x91, 0x4 },
4797 | 	{ 0x206ea0, 0x68, 0x75 },
4798 | 	{ 0x206ea1, 0x0, 0x9 },
4799 | 	{ 0x206ea2, 0x80, 0x3b },
4800 | 	{ 0x206ea3, 0x38, 0x4 },
4801 | 	{ 0x206ea4, 0x0, 0x24 },
4802 | 	{ 0x206ea5, 0x74, 0x5a },
4803 | 	{ 0x206ea6, 0x26, 0x58 },
4804 | 	{ 0x206ea7, 0xe8, 0x73 },
4805 | 	{ 0x206ea8, 0xb0, 0x21 },
4806 | 	{ 0x206ea9, 0x84, 0xeb },
4807 | 	{ 0x206eaa, 0x1, 0x4 },
4808 | 	{ 0x206eab, 0x0, 0x5a },
4809 | 	{ 0x206eac, 0xa1, 0x58 },
4810 | 	{ 0x206ead, 0x38, 0x7d },
4811 | 	{ 0x206eae, 0x8a, 0x1b },
4812 | 	{ 0x206eaf, 0x68, 0xa1 },
4813 | 	{ 0x206eb0, 0x0, 0x2c },
4814 | 	{ 0x206eb1, 0x80, 0x89 },
4815 | 	{ 0x206eb2, 0x38, 0x68 },
4816 | 	{ 0x206eb4, 0x74, 0x8b },
4817 | 	{ 0x206eb5, 0x12, 0x55 },
4818 | 	{ 0x206eb6, 0xe8, 0xdc },
4819 | 	{ 0x206eb7, 0x85, 0x89 },
4820 | 	{ 0x206eb8, 0xa0, 0x10 },
4821 | 	{ 0x206eb9, 0xf5, 0x33 },
4822 | 	{ 0x206eba, 0xff, 0xc0 },
4823 | 	{ 0x206ebb, 0xe8, 0x89 },
4824 | 	{ 0x206ebc, 0x34, 0x45 },
4825 | 	{ 0x206ebd, 0x7f, 0xdc },
4826 | 	{ 0x206ebe, 0x1, 0x8b },
4827 | 	{ 0x206ebf, 0x0, 0x45 },
4828 | 	{ 0x206ec0, 0xa1, 0xf8 },
4829 | 	{ 0x206ec1, 0x38, 0x89 },
4830 | 	{ 0x206ec2, 0x8a, 0x45 },
4831 | 	{ 0x206ec3, 0x68, 0xe0 },
4832 | 	{ 0x206ec4, 0x0, 0x8b },
4833 | 	{ 0x206ec5, 0xc6, 0x45 },
4834 | 	{ 0x206ec6, 0x0, 0xfc },
4835 | 	{ 0x206ec7, 0x0, 0x89 },
4836 | 	{ 0x206ec8, 0xe8, 0x45 },
4837 | 	{ 0x206ec9, 0x6f, 0xe4 },
4838 | 	{ 0x206eca, 0x84, 0xff },
4839 | 	{ 0x206ecb, 0x1, 0x45 },
4840 | 	{ 0x206ecc, 0x0, 0xdc },
4841 | 	{-1,0,0}
4842 | };
4843 | 
4844 | // DISPLAY RESET PATCH
4845 | // How to create:
4846 | // 1. Find the code for reinitializing Direct3D (search via f.ex. d3d_set_culling)
4847 | // 2. Find the "while old depth buffer list length > 0" block
4848 | // 3. Make it a do-while and add a null check on the condition
4849 | // Note: This is only relevant for 8.1.141, even 8.1.140 isn't affected by this bug.
4850 | 
4851 | PatchByte resetpatch_81_141[] = {
4852 | 	{ 0x21ee8d, 0xeb, 0xe8 },
4853 | 	{ 0x21ee8e, 0x5, 0x2a },
4854 | 	{ 0x21ee8f, 0xe8, 0xbb },
4855 | 	{ 0x21ee90, 0x28, 0xf4 },
4856 | 	{ 0x21ee91, 0xbb, 0xff },
4857 | 	{ 0x21ee92, 0xf4, 0xa1 },
4858 | 	{ 0x21ee93, 0xff, 0xa0 },
4859 | 	{ 0x21ee94, 0xa1, 0x69 },
4860 | 	{ 0x21ee95, 0x94, 0x68 },
4861 | 	{ 0x21ee96, 0x8a, 0x0 },
4862 | 	{ 0x21ee97, 0x68, 0x85 },
4863 | 	{ 0x21ee98, 0x0, 0xc0 },
4864 | 	{ 0x21ee99, 0x8b, 0x74 },
4865 | 	{ 0x21ee9a, 0x0, 0x6 },
4866 | 	{ 0x21eea0, 0xee, 0xec },
4867 | 	{-1,0,0}
4868 | };
4869 | 
4870 | // fix games patched with an earlier broken version oops
4871 | PatchByte resetpatch_fix_81_141[] = {
4872 | 	{ 0x21ee8d, 0xe8, 0xe8 },
4873 | 	{ 0x21ee8e, 0x2a, 0x2a },
4874 | 	{ 0x21ee8f, 0xbb, 0xbb },
4875 | 	{ 0x21ee90, 0xf4, 0xf4 },
4876 | 	{ 0x21ee91, 0xff, 0xff },
4877 | 	{ 0x21ee92, 0xa1, 0xa1 },
4878 | 	{ 0x21ee93, 0xa0, 0xa0 },
4879 | 	{ 0x21ee94, 0x69, 0x69 },
4880 | 	{ 0x21ee9a, 0x4, 0x6 },
4881 | 	{ 0x21eea0, 0xee, 0xec },
4882 | 	{-1,0,0}
4883 | };
4884 | 


--------------------------------------------------------------------------------
/version.rc:
--------------------------------------------------------------------------------
 1 | 1 VERSIONINFO
 2 | FILEVERSION     0,5,9,0
 3 | PRODUCTVERSION  0,5,9,0
 4 | BEGIN
 5 |   BLOCK "StringFileInfo"
 6 |   BEGIN
 7 |     BLOCK "040904E4"
 8 |     BEGIN
 9 |       VALUE "CompanyName", "Floogle @ https://github.com/skyfloogle"
10 |       VALUE "FileDescription", "gm8x_fix"
11 |       VALUE "FileVersion", "0.5.9"
12 |       VALUE "InternalName", "gm8x_fix"
13 |       VALUE "LegalCopyright", ""
14 |       VALUE "OriginalFilename", "gm8x_fix.exe"
15 |       VALUE "ProductName", "gm8x_fix v0.5.9"
16 |       VALUE "ProductVersion", "0.5.9"
17 |     END
18 |   END
19 | 
20 |   BLOCK "VarFileInfo"
21 |   BEGIN
22 |     VALUE "Translation", 0x409, 1252
23 |   END
24 | END


--------------------------------------------------------------------------------