use 32bit extended encoding for mov(reg64, imm)

15 files changed, 6359 insertions, 461 deletions

diff --git a/readme.txt b/readme.txt
index c7174b7..77b4163 100644
--- a/readme.txt
+++ b/readme.txt
@@ -1,5 +1,5 @@
 

-    C++用x86(IA-32), x64(AMD64, x86-64) JITアセンブラ Xbyak version 2.26

+    C++用x86(IA-32), x64(AMD64, x86-64) JITアセンブラ Xbyak version 2.27

 

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

 ◎概要

@@ -199,6 +199,7 @@ sample/{echo,hello}.bfは http://www.kmonos.net/alang/etc/brainfuck.php から
 -----------------------------------------------------------------------------

 ◎履歴

 

+2010/06/01 ver 2.27 support encoding of mov(reg64, imm) like yasm(not nasm)

 2010/05/24 ver 2.26 fix sub(rsp, 1000)

 2010/04/26 ver 2.25 add jc/jnc(I forgot to implement them...)

 2010/04/16 ver 2.24 change the prototype of rewrite() method

diff --git a/readme_e.txt b/readme_e.txt
index f99c425..050e486 100644
--- a/readme_e.txt
+++ b/readme_e.txt
@@ -1,5 +1,5 @@
 
-    Xbyak 2.26 ; JIT assembler for x86(IA32), x64(AMD64, x86-64) by C++
+    Xbyak 2.27 ; JIT assembler for x86(IA32), x64(AMD64, x86-64) by C++
 
 -----------------------------------------------------------------------------
 <Abstract>
@@ -148,6 +148,7 @@ http://www.opensource.org/licenses/bsd-license.php
 -----------------------------------------------------------------------------
 <History>
 
+2010/Jun/01 ver 2.27 support encoding of mov(reg64, imm) like yasm(not nasm)
 2010/May/24 ver 2.26 fix sub(rsp, 1000)
 2010/Apr/26 ver 2.25 add jc/jnc(I forgot to implement them...)
 2010/Apr/16 ver 2.24 change the prototype of rewrite() method
@@ -184,5 +185,5 @@ http://www.opensource.org/licenses/bsd-license.php
 MITSUNARI Shigeo(herumi at nifty dot com)
 
 ---
-$Revision: 1.46 $
-$Date: 2010/05/24 06:13:44 $
+$Revision: 1.47 $
+$Date: 2010/06/01 01:21:39 $
diff --git a/test/Makefile b/test/Makefile
index 5dde116..d8e66ff 100644
--- a/test/Makefile
+++ b/test/Makefile
@@ -20,12 +20,17 @@ normalize_prefix: normalize_prefix.cpp
 	g++ $(CFLAGS) normalize_prefix.cpp -o $@
 test_mmx: test_mmx.cpp
 	g++ $(CFLAGS) test_mmx.cpp -o $@ -lpthread
+jmp: jmp.cpp
+	g++ $(CFLAGS) jmp.cpp -o $@
 
-test: normalize_prefix
+test: normalize_prefix jmp
 	./test_nm.sh
 	./test_nm.sh Y
 	./test_nm.sh 64
 	./test_nm.sh Y64
+	./test_address.sh
+	./test_address.sh 64
+	./jmp
 
 clean:
 	rm -rf *.o $(TARGET)
diff --git a/test/address.cpp b/test/address.cpp
index 0cef961..df8b012 100644
--- a/test/address.cpp
+++ b/test/address.cpp
@@ -5,16 +5,21 @@
 
 void genAddress(bool isJIT, const char regTbl[][5], size_t regTblNum)
 {
+	int count = 0;
+	int funcNum = 1;
+	if (isJIT) {
+		puts("void gen0(){");
+	}
 	for (size_t i = 0; i < regTblNum + 1; i++) {
 		const char *base = regTbl[i];
 		for (size_t j = 0; j < regTblNum + 1; j++) {
 			if (j == 4) continue; /* esp is not index register */
 			const char *index = regTbl[j];
 			static const int scaleTbl[] = { 0, 1, 2, 4, 8 };
-			for (int k = 0; k < NUM_OF_ARRAY(scaleTbl); k++) {
+			for (size_t k = 0; k < NUM_OF_ARRAY(scaleTbl); k++) {
 				int scale = scaleTbl[k];
 				static const int dispTbl[] = { 0, 1, 1000, -1, -1000 };
-				for (int m = 0; m < NUM_OF_ARRAY(dispTbl); m++) {
+				for (size_t m = 0; m < NUM_OF_ARRAY(dispTbl); m++) {
 					int disp = dispTbl[m];
 					bool isFirst = true;
 					if (isJIT) {
@@ -47,10 +52,23 @@ void genAddress(bool isJIT, const char regTbl[][5], size_t regTblNum)
 					} else {
 						printf("]\n");
 					}
+					if (isJIT) {
+						count++;
+						if ((count % 100) == 0) {
+							printf("}\n    void gen%d(){\n", funcNum++);
+						}
+					}
 				}
 			}
 		}
 	}
+	if (isJIT) {
+		printf("}\nvoid gen(){\n");
+		for (int i = 0; i < funcNum; i++) {
+			printf("   gen%d();\n", i);
+		}
+		printf("}\n");
+	}
 }
 
 int main(int argc, char *argv[])
@@ -60,6 +78,7 @@ int main(int argc, char *argv[])
 	bool isJIT = (argc > 1);
 	fprintf(stderr, "phase:%c %s\n", phase ? '1' : '2', isJIT ? "jit" : "asm");
 	if (phase) {
+		fprintf(stderr, "32bit reg\n");
 		static const char reg32Tbl[][5] = {
 			"eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
 #ifdef XBYAK64
@@ -69,6 +88,7 @@ int main(int argc, char *argv[])
 		genAddress(isJIT, reg32Tbl, NUM_OF_ARRAY(reg32Tbl));
 	} else {
 #ifdef XBYAK64
+		fprintf(stderr, "64bit reg\n");
 		static const char reg64Tbl[][5] = {
 			"rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
 		};
diff --git a/test/jmp.cpp b/test/jmp.cpp
index 86d56ff..81a6a18 100644
--- a/test/jmp.cpp
+++ b/test/jmp.cpp
@@ -1,4 +1,5 @@
 #include <stdio.h>
+#include <string.h>
 #include "xbyak/xbyak.h"
 #define NUM_OF_ARRAY(x) (sizeof(x) / sizeof(x[0]))
 
@@ -82,13 +83,13 @@ int main()
 		{ 127, false, true, "EB7F" },
 		{ 128, false, false, "E980000000" },
 	};
-	for (int i = 0; i < NUM_OF_ARRAY(tbl); i++) {
+	for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
 		const Tbl *p = &tbl[i];
 		TestJmp jmp(p->offset, p->isBack, p->isShort);
 		const uint8 *q = (const uint8*)jmp.getCode();
 		char buf[32];
 		if (p->isBack) q += p->offset; /* skip nop */
-		for (int j = 0; j < jmp.getSize() - p->offset; j++) {
+		for (size_t j = 0; j < jmp.getSize() - p->offset; j++) {
 			sprintf(&buf[j * 2], "%02X", q[j]);
 		}
 		if (strcmp(buf, p->result) != 0) {
diff --git a/test/make_nm.cpp b/test/make_nm.cpp
index 67cd15d..105f29a 100644
--- a/test/make_nm.cpp
+++ b/test/make_nm.cpp
@@ -62,6 +62,7 @@ const uint64 NOPARA = 1ULL << (bitEnd - 1);
 
 class Test {
 	const bool isXbyak_;
+	int funcNum_;
 	// check all op1, op2, op3
 	void put(const char *nm, uint64 op1 = NOPARA, uint64 op2 = NOPARA, uint64 op3 = NOPARA) const
 	{
@@ -811,6 +812,31 @@ class Test {
 		put(p, REG8|REG8_3|MEM, REG8|REG8_3);
 		put(p, REG32e|REG16|REG8|REG8_3|EAX|AX|AL|MEM32|MEM16|MEM8, IMM);
 	}
+	void putMov64() const
+	{
+		const struct {
+			const char *a;
+			const char *b;
+		} tbl[] = {
+			{ "0", "dword 0" },
+			{ "0x123", "dword 0x123" },
+			{ "0x12345678", "dword 0x12345678" },
+			{ "0x7fffffff", "dword 0x7fffffff" },
+			{ "0xffffffff", "0xffffffff" },
+			{ "0x80000000", "0x80000000" },
+			{ "2147483648U", "2147483648" },
+			{ "0x80000001", "0x80000001" },
+			{ "0xffffffffffffffff", "dword 0xffffffffffffffff" },
+			{ "-1", "dword -1" },
+			{ "0xffffffff80000000", "dword 0xffffffff80000000" },
+			{ "0xffffffff80000001", "dword 0xffffffff80000001" },
+			{ "0xffffffff12345678", "0xffffffff12345678" },
+		};
+		for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
+			put("mov", REG64, tbl[i].a, tbl[i].b);
+		}
+		put("mov", REG32e|REG16|REG8|RAX|EAX|AX|AL, IMM);
+	}
 	void putEtc() const
 	{
 		const char *p = "ret";
@@ -821,7 +847,7 @@ class Test {
 		put(p, REG64|MEM|MEM_ONLY_DISP, REG64|RAX);
 		put(p, AX|REG16|MEM|MEM_ONLY_DISP, REG16|AX);
 		put(p, AL|REG8|REG8_3|MEM|MEM_ONLY_DISP, REG8|REG8_3|AL);
-		put(p, REG32e|REG16|REG8|RAX|EAX|AX|AL, MEM|IMM|MEM_ONLY_DISP);
+		put(p, REG32e|REG16|REG8|RAX|EAX|AX|AL, MEM|MEM_ONLY_DISP);
 		put(p, MEM32|MEM16|MEM8, IMM);
 		put(p, REG64, "0x1234567890abcdefLL", "0x1234567890abcdef");
 #ifdef XBYAK64
@@ -1117,32 +1143,72 @@ class Test {
 public:
 	Test(bool isXbyak)
 		: isXbyak_(isXbyak)
+		, funcNum_(1)
 	{
+		if (!isXbyak_) return;
+		printf("%s",
+			"    void gen0()\n"
+			"    {\n");
 	}
-	void put() const
+	/*
+		gcc and vc give up to compile this source,
+		so I split functions.
+	*/
+	void separateFunc()
+	{
+		if (!isXbyak_) return;
+		printf(
+			"    }\n"
+			"    void gen%d()\n"
+			"    {\n", funcNum_++);
+	}
+	~Test()
+	{
+		if (!isXbyak_) return;
+		printf("%s",
+			"    }\n"
+			"    void gen()\n"
+			"    {\n");
+		for (int i = 0; i < funcNum_; i++) {
+			printf(
+			"        gen%d();\n", i);
+		}
+		printf(
+			"    }\n");
+	}
+	void put()
 	{
 #ifndef USE_YASM
 		putSIMPLE();
 		putReg1();
 		putRorM();
+		separateFunc();
 		putPushPop();
 		putTest();
+		separateFunc();
 		putEtc();
 		putShift();
 		putShxd();
+
+		separateFunc();
+
 		putBs();
 		putMMX1();
 		putMMX2();
+		separateFunc();
 		putMMX3();
 		putMMX4();
 		putMMX5();
+		separateFunc();
 		putXMM1();
 		putXMM2();
 		putXMM3();
 		putXMM4();
+		separateFunc();
 		putCmov();
 		putFpuMem16_32();
 		putFpuMem32_64();
+		separateFunc();
 		putFpuMem16_32_64();
 		put("clflush", MEM); // current nasm is ok
 		putFpu();
@@ -1150,7 +1216,9 @@ public:
 		putFpuFpu();
 		putSSSE3();
 		putSSE4_1();
+		separateFunc();
 		putSSE4_2();
+		putMov64();
 #endif
 	}
 };
@@ -1160,4 +1228,3 @@ int main(int argc, char *[])
 	Test test(argc > 1);
 	test.put();
 }
-
diff --git a/test/nm.cpp b/test/nm.cpp
index f50c56d..b17405f 100644
--- a/test/nm.cpp
+++ b/test/nm.cpp
@@ -1,404 +1,6185 @@
-fadd (st0, st2); dump();
-fadd (st2, st0); dump();
-faddp (st2, st0); dump();
-fcmovb (st0, st2); dump();
-fcmove (st0, st2); dump();
-fcmovbe (st0, st2); dump();
-fcmovu (st0, st2); dump();
-fcmovnb (st0, st2); dump();
-fcmovne (st0, st2); dump();
-fcmovnbe (st0, st2); dump();
-fcmovnu (st0, st2); dump();
-fcomi (st0, st2); dump();
-fcomip (st0, st2); dump();
-fucomi (st0, st2); dump();
-fucomip (st0, st2); dump();
-fdiv (st0, st2); dump();
-fdiv (st2, st0); dump();
-fdivp (st2, st0); dump();
-fdivr (st0, st2); dump();
-fdivr (st2, st0); dump();
-fdivrp (st2, st0); dump();
-fmul (st0, st2); dump();
-fmul (st2, st0); dump();
-fmulp (st2, st0); dump();
-fsub (st0, st2); dump();
-fsub (st2, st0); dump();
-fsubp (st2, st0); dump();
-fsubr (st0, st2); dump();
-fsubr (st2, st0); dump();
-fsubrp (st2, st0); dump();
-pshufb (xm9, xm4); dump();
-pshufb (xm8, ptr[eax+ecx+3]); dump();
-pshufb (xm6, ptr[rip - 0x13456]); dump();
-pshufb (mm2, mm1); dump();
-pshufb (mm3, ptr[eax+ecx+3]); dump();
-pshufb (mm6, ptr[rdx+r15+0x12]); dump();
-phaddw (xm4, xm10); dump();
-phaddw (xm10, ptr[eax+ecx+3]); dump();
-phaddw (xm10, ptr[rip - 0x13456]); dump();
-phaddw (mm6, mm2); dump();
-phaddw (mm0, ptr[eax+ecx+3]); dump();
-phaddw (mm6, ptr[rdx+r15+0x12]); dump();
-phaddd (xm11, xm4); dump();
-phaddd (xm4, ptr[eax+ecx+3]); dump();
-phaddd (xm10, ptr[rip - 0x13456]); dump();
-phaddd (mm6, mm4); dump();
-phaddd (mm4, ptr[eax+ecx+3]); dump();
-phaddd (mm7, ptr[rdx+r15+0x12]); dump();
-phaddsw (xm4, xm5); dump();
-phaddsw (xm9, ptr[eax+ecx+3]); dump();
-phaddsw (xm4, ptr[rip - 0x13456]); dump();
-phaddsw (mm1, mm1); dump();
-phaddsw (mm6, ptr[eax+ecx+3]); dump();
-phaddsw (mm3, ptr[rdx+r15+0x12]); dump();
-pmaddubsw (xm11, xm11); dump();
-pmaddubsw (xm10, ptr[eax+ecx+3]); dump();
-pmaddubsw (xm10, ptr[rip - 0x13456]); dump();
-pmaddubsw (mm2, mm4); dump();
-pmaddubsw (mm2, ptr[eax+ecx+3]); dump();
-pmaddubsw (mm0, ptr[rdx+r15+0x12]); dump();
-phsubw (xm10, xm8); dump();
-phsubw (xm6, ptr[eax+ecx+3]); dump();
-phsubw (xm9, ptr[rip - 0x13456]); dump();
-phsubw (mm7, mm4); dump();
-phsubw (mm1, ptr[eax+ecx+3]); dump();
-phsubw (mm6, ptr[rdx+r15+0x12]); dump();
-phsubd (xm9, xm10); dump();
-phsubd (xm11, ptr[eax+ecx+3]); dump();
-phsubd (xm6, ptr[rip - 0x13456]); dump();
-phsubd (mm6, mm2); dump();
-phsubd (mm0, ptr[eax+ecx+3]); dump();
-phsubd (mm6, ptr[rdx+r15+0x12]); dump();
-phsubsw (xm10, xm4); dump();
-phsubsw (xm7, ptr[eax+ecx+3]); dump();
-phsubsw (xm7, ptr[rip - 0x13456]); dump();
-phsubsw (mm7, mm1); dump();
-phsubsw (mm7, ptr[eax+ecx+3]); dump();
-phsubsw (mm2, ptr[rdx+r15+0x12]); dump();
-psignb (xm4, xm4); dump();
-psignb (xm11, ptr[eax+ecx+3]); dump();
-psignb (xm7, ptr[rip - 0x13456]); dump();
-psignb (mm0, mm6); dump();
-psignb (mm4, ptr[eax+ecx+3]); dump();
-psignb (mm2, ptr[rdx+r15+0x12]); dump();
-psignw (xm6, xm10); dump();
-psignw (xm11, ptr[eax+ecx+3]); dump();
-psignw (xm5, ptr[rip - 0x13456]); dump();
-psignw (mm0, mm0); dump();
-psignw (mm5, ptr[eax+ecx+3]); dump();
-psignw (mm1, ptr[rdx+r15+0x12]); dump();
-psignd (xm8, xm10); dump();
-psignd (xm11, ptr[eax+ecx+3]); dump();
-psignd (xm11, ptr[rip - 0x13456]); dump();
-psignd (mm7, mm0); dump();
-psignd (mm0, ptr[eax+ecx+3]); dump();
-psignd (mm0, ptr[rdx+r15+0x12]); dump();
-pmulhrsw (xm7, xm4); dump();
-pmulhrsw (xm4, ptr[eax+ecx+3]); dump();
-pmulhrsw (xm4, ptr[rip - 0x13456]); dump();
-pmulhrsw (mm3, mm1); dump();
-pmulhrsw (mm0, ptr[eax+ecx+3]); dump();
-pmulhrsw (mm2, ptr[rdx+r15+0x12]); dump();
-pabsb (xm9, xm4); dump();
-pabsb (xm4, ptr[eax+ecx+3]); dump();
-pabsb (xm6, ptr[rip - 0x13456]); dump();
-pabsb (mm0, mm5); dump();
-pabsb (mm6, ptr[eax+ecx+3]); dump();
-pabsb (mm1, ptr[rdx+r15+0x12]); dump();
-pabsw (xm11, xm10); dump();
-pabsw (xm6, ptr[eax+ecx+3]); dump();
-pabsw (xm7, ptr[rip - 0x13456]); dump();
-pabsw (mm1, mm7); dump();
-pabsw (mm0, ptr[eax+ecx+3]); dump();
-pabsw (mm3, ptr[rdx+r15+0x12]); dump();
-pabsd (xm5, xm8); dump();
-pabsd (xm4, ptr[eax+ecx+3]); dump();
-pabsd (xm7, ptr[rip - 0x13456]); dump();
-pabsd (mm0, mm7); dump();
-pabsd (mm7, ptr[eax+ecx+3]); dump();
-pabsd (mm1, ptr[rdx+r15+0x12]); dump();
-palignr (xm5, xm4, 4); dump();
-palignr (xm10, ptr[eax+ecx+3], 4); dump();
-palignr (xm6, ptr[rip - 0x13456], 4); dump();
-palignr (mm4, mm3, 4); dump();
-palignr (mm5, ptr[eax+ecx+3], 4); dump();
-palignr (mm5, ptr[rdx+r15+0x12], 4); dump();
-blendvpd (xm9, xm8); dump();
-blendvpd (xm5, ptr[eax+ecx+3]); dump();
-blendvpd (xm8, ptr[rip - 0x13456]); dump();
-blendvps (xm6, xm7); dump();
-blendvps (xm6, ptr[eax+ecx+3]); dump();
-blendvps (xm9, ptr[rdx+r15+0x12]); dump();
-packusdw (xm10, xm8); dump();
-packusdw (xm6, ptr[eax+ecx+3]); dump();
-packusdw (xm6, ptr[rip - 0x13456]); dump();
-pblendvb (xm4, xm7); dump();
-pblendvb (xm7, ptr[eax+ecx+3]); dump();
-pblendvb (xm11, ptr[rdx+r15+0x12]); dump();
-pcmpeqq (xm5, xm6); dump();
-pcmpeqq (xm4, ptr[eax+ecx+3]); dump();
-pcmpeqq (xm4, ptr[rip - 0x13456]); dump();
-ptest (xm4, xm8); dump();
-ptest (xm10, ptr[eax+ecx+3]); dump();
-ptest (xm9, ptr[rdx+r15+0x12]); dump();
-pmovsxbw (xm7, xm11); dump();
-pmovsxbw (xm10, ptr[eax+ecx+3]); dump();
-pmovsxbw (xm10, ptr[rip - 0x13456]); dump();
-pmovsxbd (xm8, xm9); dump();
-pmovsxbd (xm10, ptr[eax+ecx+3]); dump();
-pmovsxbd (xm4, ptr[rdx+r15+0x12]); dump();
-pmovsxbq (xm8, xm10); dump();
-pmovsxbq (xm6, ptr[eax+ecx+3]); dump();
-pmovsxbq (xm5, ptr[rip - 0x13456]); dump();
-pmovsxwd (xm8, xm4); dump();
-pmovsxwd (xm4, ptr[eax+ecx+3]); dump();
-pmovsxwd (xm7, ptr[rdx+r15+0x12]); dump();
-pmovsxwq (xm11, xm5); dump();
-pmovsxwq (xm7, ptr[eax+ecx+3]); dump();
-pmovsxwq (xm11, ptr[rip - 0x13456]); dump();
-pmovsxdq (xm11, xm4); dump();
-pmovsxdq (xm8, ptr[eax+ecx+3]); dump();
-pmovsxdq (xm7, ptr[rdx+r15+0x12]); dump();
-pmovzxbw (xm10, xm4); dump();
-pmovzxbw (xm11, ptr[eax+ecx+3]); dump();
-pmovzxbw (xm9, ptr[rip - 0x13456]); dump();
-pmovzxbd (xm11, xm6); dump();
-pmovzxbd (xm7, ptr[eax+ecx+3]); dump();
-pmovzxbd (xm11, ptr[rdx+r15+0x12]); dump();
-pmovzxbq (xm9, xm8); dump();
-pmovzxbq (xm6, ptr[eax+ecx+3]); dump();
-pmovzxbq (xm10, ptr[rip - 0x13456]); dump();
-pmovzxwd (xm9, xm10); dump();
-pmovzxwd (xm9, ptr[eax+ecx+3]); dump();
-pmovzxwd (xm6, ptr[rdx+r15+0x12]); dump();
-pmovzxwq (xm9, xm4); dump();
-pmovzxwq (xm9, ptr[eax+ecx+3]); dump();
-pmovzxwq (xm8, ptr[rip - 0x13456]); dump();
-pmovzxdq (xm7, xm5); dump();
-pmovzxdq (xm4, ptr[eax+ecx+3]); dump();
-pmovzxdq (xm6, ptr[rdx+r15+0x12]); dump();
-pminsb (xm9, xm6); dump();
-pminsb (xm9, ptr[eax+ecx+3]); dump();
-pminsb (xm6, ptr[rip - 0x13456]); dump();
-pminsd (xm6, xm9); dump();
-pminsd (xm11, ptr[eax+ecx+3]); dump();
-pminsd (xm8, ptr[rdx+r15+0x12]); dump();
-pminuw (xm5, xm6); dump();
-pminuw (xm11, ptr[eax+ecx+3]); dump();
-pminuw (xm5, ptr[rip - 0x13456]); dump();
-pminud (xm4, xm9); dump();
-pminud (xm6, ptr[eax+ecx+3]); dump();
-pminud (xm9, ptr[rdx+r15+0x12]); dump();
-pmaxsb (xm8, xm5); dump();
-pmaxsb (xm10, ptr[eax+ecx+3]); dump();
-pmaxsb (xm11, ptr[rip - 0x13456]); dump();
-pmaxsd (xm10, xm9); dump();
-pmaxsd (xm4, ptr[eax+ecx+3]); dump();
-pmaxsd (xm7, ptr[rdx+r15+0x12]); dump();
-pmaxuw (xm9, xm9); dump();
-pmaxuw (xm10, ptr[eax+ecx+3]); dump();
-pmaxuw (xm4, ptr[rip - 0x13456]); dump();
-pmaxud (xm10, xm4); dump();
-pmaxud (xm7, ptr[eax+ecx+3]); dump();
-pmaxud (xm10, ptr[rdx+r15+0x12]); dump();
-pmuldq (xm10, xm11); dump();
-pmuldq (xm9, ptr[eax+ecx+3]); dump();
-pmuldq (xm7, ptr[rip - 0x13456]); dump();
-pmulld (xm7, xm10); dump();
-pmulld (xm8, ptr[eax+ecx+3]); dump();
-pmulld (xm4, ptr[rdx+r15+0x12]); dump();
-phminposuw (xm9, xm10); dump();
-phminposuw (xm11, ptr[eax+ecx+3]); dump();
-phminposuw (xm10, ptr[rip - 0x13456]); dump();
-pcmpgtq (xm8, xm7); dump();
-pcmpgtq (xm9, ptr[eax+ecx+3]); dump();
-pcmpgtq (xm8, ptr[rdx+r15+0x12]); dump();
-blendpd (xm5, xm6, 4); dump();
-blendpd (xm8, ptr[eax+ecx+3], 4); dump();
-blendpd (xm9, ptr[rip - 0x13456], 4); dump();
-blendps (xm6, xm7, 4); dump();
-blendps (xm9, ptr[eax+ecx+3], 4); dump();
-blendps (xm11, ptr[rdx+r15+0x12], 4); dump();
-dppd (xm5, xm6, 4); dump();
-dppd (xm4, ptr[eax+ecx+3], 4); dump();
-dppd (xm4, ptr[rip - 0x13456], 4); dump();
-dpps (xm8, xm5, 4); dump();
-dpps (xm7, ptr[eax+ecx+3], 4); dump();
-dpps (xm4, ptr[rdx+r15+0x12], 4); dump();
-mpsadbw (xm8, xm7, 4); dump();
-mpsadbw (xm6, ptr[eax+ecx+3], 4); dump();
-mpsadbw (xm8, ptr[rip - 0x13456], 4); dump();
-pblendw (xm9, xm10, 4); dump();
-pblendw (xm7, ptr[eax+ecx+3], 4); dump();
-pblendw (xm5, ptr[rdx+r15+0x12], 4); dump();
-roundps (xm7, xm10, 4); dump();
-roundps (xm11, ptr[eax+ecx+3], 4); dump();
-roundps (xm11, ptr[rip - 0x13456], 4); dump();
-roundpd (xm5, xm8, 4); dump();
-roundpd (xm4, ptr[eax+ecx+3], 4); dump();
-roundpd (xm7, ptr[rdx+r15+0x12], 4); dump();
-roundss (xm11, xm10, 4); dump();
-roundss (xm6, ptr[eax+ecx+3], 4); dump();
-roundss (xm4, ptr[rip - 0x13456], 4); dump();
-roundsd (xm9, xm8, 4); dump();
-roundsd (xm5, ptr[eax+ecx+3], 4); dump();
-roundsd (xm7, ptr[rdx+r15+0x12], 4); dump();
-pcmpestrm (xm11, xm8, 4); dump();
-pcmpestrm (xm9, ptr[eax+ecx+3], 4); dump();
-pcmpestrm (xm5, ptr[rip - 0x13456], 4); dump();
-pcmpestri (xm9, xm9, 4); dump();
-pcmpestri (xm10, ptr[eax+ecx+3], 4); dump();
-pcmpestri (xm9, ptr[rdx+r15+0x12], 4); dump();
-pcmpistrm (xm9, xm8, 4); dump();
-pcmpistrm (xm6, ptr[eax+ecx+3], 4); dump();
-pcmpistrm (xm8, ptr[rip - 0x13456], 4); dump();
-pcmpistri (xm6, xm6, 4); dump();
-pcmpistri (xm4, ptr[eax+ecx+3], 4); dump();
-pcmpistri (xm7, ptr[rdx+r15+0x12], 4); dump();
-extractps (ptr[eax+ecx+3], xm7, 4); dump();
-extractps (ebp, xm11, 4); dump();
-extractps (eax, xm8, 4); dump();
-extractps (ptr[rip - 0x13456], xm6, 4); dump();
-extractps (r13d, xm11, 4); dump();
-extractps (rcx, xm11, 4); dump();
-extractps (r14, xm7, 4); dump();
-extractps (rax, xm7, 4); dump();
-pextrw (ptr[eax+ecx+3], xm8, 4); dump();
-pextrw (ecx, xm4, 4); dump();
-pextrw (eax, xm11, 4); dump();
-pextrw (ptr[rdx+r15+0x12], xm8, 4); dump();
-pextrw (r14d, xm6, 4); dump();
-pextrw (rbp, xm11, 4); dump();
-pextrw (r10, xm6, 4); dump();
-pextrw (rax, xm7, 4); dump();
-pextrb (ptr[eax+ecx+3], xm11, 4); dump();
-pextrb (edi, xm10, 4); dump();
-pextrb (eax, xm8, 4); dump();
-pextrb (ptr[rip - 0x13456], xm6, 4); dump();
-pextrb (r14d, xm9, 4); dump();
-pextrb (rcx, xm10, 4); dump();
-pextrb (r11, xm8, 4); dump();
-pextrb (rax, xm11, 4); dump();
-pextrd (ptr[eax+ecx+3], xm5, 4); dump();
-pextrd (ecx, xm4, 4); dump();
-pextrd (eax, xm5, 4); dump();
-pextrd (ptr[rdx+r15+0x12], xm4, 4); dump();
-pextrd (r9d, xm9, 4); dump();
-insertps (xm8, xm6, 4); dump();
-insertps (xm10, ptr[eax+ecx+3], 4); dump();
-insertps (xm11, ptr[rip - 0x13456], 4); dump();
-pinsrb (xm6, ptr[eax+ecx+3], 4); dump();
-pinsrb (xm10, edx, 4); dump();
-pinsrb (xm5, eax, 4); dump();
-pinsrb (xm8, ptr[rdx+r15+0x12], 4); dump();
-pinsrb (xm7, r8d, 4); dump();
-pinsrd (xm11, ptr[eax+ecx+3], 4); dump();
-pinsrd (xm6, edi, 4); dump();
-pinsrd (xm11, eax, 4); dump();
-pinsrd (xm10, ptr[rip - 0x13456], 4); dump();
-pinsrd (xm7, r14d, 4); dump();
-movntdqa (xm10, ptr[eax+ecx+3]); dump();
-movntdqa (xm6, ptr[rdx+r15+0x12]); dump();
-popcnt (cx, ptr[eax+ecx+3]); dump();
-popcnt (cx, dx); dump();
-popcnt (sp, ax); dump();
-popcnt (si, ptr[rip - 0x13456]); dump();
-popcnt (di, r14w); dump();
-popcnt (ax, ptr[eax+ecx+3]); dump();
-popcnt (ax, cx); dump();
-popcnt (ax, ax); dump();
-popcnt (ax, ptr[rdx+r15+0x12]); dump();
-popcnt (ax, r14w); dump();
-popcnt (r10w, ptr[eax+ecx+3]); dump();
-popcnt (r13w, sp); dump();
-popcnt (r13w, ax); dump();
-popcnt (r10w, ptr[rip - 0x13456]); dump();
-popcnt (r13w, r10w); dump();
-popcnt (ebp, ptr[eax+ecx+3]); dump();
-popcnt (esp, edx); dump();
-popcnt (ebp, eax); dump();
-popcnt (ebx, ptr[rdx+r15+0x12]); dump();
-popcnt (edi, r14d); dump();
-popcnt (eax, ptr[eax+ecx+3]); dump();
-popcnt (eax, esp); dump();
-popcnt (eax, eax); dump();
-popcnt (eax, ptr[rip - 0x13456]); dump();
-popcnt (eax, r13d); dump();
-popcnt (r9d, ptr[eax+ecx+3]); dump();
-popcnt (r15d, edi); dump();
-popcnt (r13d, eax); dump();
-popcnt (r9d, ptr[rdx+r15+0x12]); dump();
-popcnt (r14d, r14d); dump();
-popcnt (rcx, ptr[eax+ecx+3]); dump();
-popcnt (rbx, ptr[rip - 0x13456]); dump();
-popcnt (rcx, rsi); dump();
-popcnt (rdi, r11); dump();
-popcnt (rsi, rax); dump();
-popcnt (r10, ptr[eax+ecx+3]); dump();
-popcnt (r11, ptr[rdx+r15+0x12]); dump();
-popcnt (r11, rdi); dump();
-popcnt (r14, r11); dump();
-popcnt (r15, rax); dump();
-popcnt (rax, ptr[eax+ecx+3]); dump();
-popcnt (rax, ptr[rip - 0x13456]); dump();
-popcnt (rax, rbx); dump();
-popcnt (rax, r14); dump();
-popcnt (rax, rax); dump();
-crc32 (esp, ecx); dump();
-crc32 (ecx, eax); dump();
-crc32 (edx, cl); dump();
-crc32 (ebx, cx); dump();
-crc32 (ebx, ax); dump();
-crc32 (esi, al); dump();
-crc32 (edi, byte [eax+edx]); dump();
-crc32 (ebp, word [esi]); dump();
-crc32 (ebx, dword [ebp*2]); dump();
-crc32 (esi, r10d); dump();
-crc32 (esp, r11w); dump();
-crc32 (ebx, r15b); dump();
-crc32 (eax, esi); dump();
-crc32 (eax, eax); dump();
-crc32 (eax, bl); dump();
-crc32 (eax, cx); dump();
-crc32 (eax, ax); dump();
-crc32 (eax, al); dump();
-crc32 (eax, byte [eax+edx]); dump();
-crc32 (eax, word [esi]); dump();
-crc32 (eax, dword [ebp*2]); dump();
-crc32 (eax, r13d); dump();
-crc32 (eax, r8w); dump();
-crc32 (eax, r15b); dump();
-crc32 (r8d, ecx); dump();
-crc32 (r9d, eax); dump();
-crc32 (r11d, bl); dump();
-crc32 (r9d, si); dump();
-crc32 (r15d, ax); dump();
-crc32 (r9d, al); dump();
-crc32 (r13d, byte [eax+edx]); dump();
-crc32 (r14d, word [esi]); dump();
-crc32 (r12d, dword [ebp*2]); dump();
-crc32 (r10d, r13d); dump();
-crc32 (r12d, r15w); dump();
-crc32 (r14d, r11b); dump();
-crc32 (rdi, cl); dump();
-crc32 (rdi, al); dump();
-crc32 (rcx, byte [eax+edx]); dump();
-crc32 (rbx, r15b); dump();
-crc32 (rdx, rbp); dump();
-crc32 (rcx, r11); dump();
-crc32 (rdi, rax); dump();
-crc32 (r8, al); dump();
-crc32 (r13, al); dump();
-crc32 (r13, byte [eax+edx]); dump();
-crc32 (r11, r12b); dump();
-crc32 (r9, rcx); dump();
-crc32 (r13, r12); dump();
-crc32 (r11, rax); dump();
-crc32 (rax, cl); dump();
-crc32 (rax, al); dump();
-crc32 (rax, byte [eax+edx]); dump();
-crc32 (rax, r14b); dump();
-crc32 (rax, rbp); dump();
-crc32 (rax, r9); dump();
-crc32 (rax, rax); dump();
+void gen0(){
+mov (ecx, ptr[rax+rax+0]); dump();
+mov (ecx, ptr[rax+rax+1]); dump();
+mov (ecx, ptr[rax+rax+1000]); dump();
+mov (ecx, ptr[rax+rax-1]); dump();
+mov (ecx, ptr[rax+rax-1000]); dump();
+mov (ecx, ptr[rax+rax*1+0]); dump();
+mov (ecx, ptr[rax+rax*1+1]); dump();
+mov (ecx, ptr[rax+rax*1+1000]); dump();
+mov (ecx, ptr[rax+rax*1-1]); dump();
+mov (ecx, ptr[rax+rax*1-1000]); dump();
+mov (ecx, ptr[rax+rax*2+0]); dump();
+mov (ecx, ptr[rax+rax*2+1]); dump();
+mov (ecx, ptr[rax+rax*2+1000]); dump();
+mov (ecx, ptr[rax+rax*2-1]); dump();
+mov (ecx, ptr[rax+rax*2-1000]); dump();
+mov (ecx, ptr[rax+rax*4+0]); dump();
+mov (ecx, ptr[rax+rax*4+1]); dump();
+mov (ecx, ptr[rax+rax*4+1000]); dump();
+mov (ecx, ptr[rax+rax*4-1]); dump();
+mov (ecx, ptr[rax+rax*4-1000]); dump();
+mov (ecx, ptr[rax+rax*8+0]); dump();
+mov (ecx, ptr[rax+rax*8+1]); dump();
+mov (ecx, ptr[rax+rax*8+1000]); dump();
+mov (ecx, ptr[rax+rax*8-1]); dump();
+mov (ecx, ptr[rax+rax*8-1000]); dump();
+mov (ecx, ptr[rax+rcx+0]); dump();
+mov (ecx, ptr[rax+rcx+1]); dump();
+mov (ecx, ptr[rax+rcx+1000]); dump();
+mov (ecx, ptr[rax+rcx-1]); dump();
+mov (ecx, ptr[rax+rcx-1000]); dump();
+mov (ecx, ptr[rax+rcx*1+0]); dump();
+mov (ecx, ptr[rax+rcx*1+1]); dump();
+mov (ecx, ptr[rax+rcx*1+1000]); dump();
+mov (ecx, ptr[rax+rcx*1-1]); dump();
+mov (ecx, ptr[rax+rcx*1-1000]); dump();
+mov (ecx, ptr[rax+rcx*2+0]); dump();
+mov (ecx, ptr[rax+rcx*2+1]); dump();
+mov (ecx, ptr[rax+rcx*2+1000]); dump();
+mov (ecx, ptr[rax+rcx*2-1]); dump();
+mov (ecx, ptr[rax+rcx*2-1000]); dump();
+mov (ecx, ptr[rax+rcx*4+0]); dump();
+mov (ecx, ptr[rax+rcx*4+1]); dump();
+mov (ecx, ptr[rax+rcx*4+1000]); dump();
+mov (ecx, ptr[rax+rcx*4-1]); dump();
+mov (ecx, ptr[rax+rcx*4-1000]); dump();
+mov (ecx, ptr[rax+rcx*8+0]); dump();
+mov (ecx, ptr[rax+rcx*8+1]); dump();
+mov (ecx, ptr[rax+rcx*8+1000]); dump();
+mov (ecx, ptr[rax+rcx*8-1]); dump();
+mov (ecx, ptr[rax+rcx*8-1000]); dump();
+mov (ecx, ptr[rax+rdx+0]); dump();
+mov (ecx, ptr[rax+rdx+1]); dump();
+mov (ecx, ptr[rax+rdx+1000]); dump();
+mov (ecx, ptr[rax+rdx-1]); dump();
+mov (ecx, ptr[rax+rdx-1000]); dump();
+mov (ecx, ptr[rax+rdx*1+0]); dump();
+mov (ecx, ptr[rax+rdx*1+1]); dump();
+mov (ecx, ptr[rax+rdx*1+1000]); dump();
+mov (ecx, ptr[rax+rdx*1-1]); dump();
+mov (ecx, ptr[rax+rdx*1-1000]); dump();
+mov (ecx, ptr[rax+rdx*2+0]); dump();
+mov (ecx, ptr[rax+rdx*2+1]); dump();
+mov (ecx, ptr[rax+rdx*2+1000]); dump();
+mov (ecx, ptr[rax+rdx*2-1]); dump();
+mov (ecx, ptr[rax+rdx*2-1000]); dump();
+mov (ecx, ptr[rax+rdx*4+0]); dump();
+mov (ecx, ptr[rax+rdx*4+1]); dump();
+mov (ecx, ptr[rax+rdx*4+1000]); dump();
+mov (ecx, ptr[rax+rdx*4-1]); dump();
+mov (ecx, ptr[rax+rdx*4-1000]); dump();
+mov (ecx, ptr[rax+rdx*8+0]); dump();
+mov (ecx, ptr[rax+rdx*8+1]); dump();
+mov (ecx, ptr[rax+rdx*8+1000]); dump();
+mov (ecx, ptr[rax+rdx*8-1]); dump();
+mov (ecx, ptr[rax+rdx*8-1000]); dump();
+mov (ecx, ptr[rax+rbx+0]); dump();
+mov (ecx, ptr[rax+rbx+1]); dump();
+mov (ecx, ptr[rax+rbx+1000]); dump();
+mov (ecx, ptr[rax+rbx-1]); dump();
+mov (ecx, ptr[rax+rbx-1000]); dump();
+mov (ecx, ptr[rax+rbx*1+0]); dump();
+mov (ecx, ptr[rax+rbx*1+1]); dump();
+mov (ecx, ptr[rax+rbx*1+1000]); dump();
+mov (ecx, ptr[rax+rbx*1-1]); dump();
+mov (ecx, ptr[rax+rbx*1-1000]); dump();
+mov (ecx, ptr[rax+rbx*2+0]); dump();
+mov (ecx, ptr[rax+rbx*2+1]); dump();
+mov (ecx, ptr[rax+rbx*2+1000]); dump();
+mov (ecx, ptr[rax+rbx*2-1]); dump();
+mov (ecx, ptr[rax+rbx*2-1000]); dump();
+mov (ecx, ptr[rax+rbx*4+0]); dump();
+mov (ecx, ptr[rax+rbx*4+1]); dump();
+mov (ecx, ptr[rax+rbx*4+1000]); dump();
+mov (ecx, ptr[rax+rbx*4-1]); dump();
+mov (ecx, ptr[rax+rbx*4-1000]); dump();
+mov (ecx, ptr[rax+rbx*8+0]); dump();
+mov (ecx, ptr[rax+rbx*8+1]); dump();
+mov (ecx, ptr[rax+rbx*8+1000]); dump();
+mov (ecx, ptr[rax+rbx*8-1]); dump();
+mov (ecx, ptr[rax+rbx*8-1000]); dump();
+}
+    void gen1(){
+mov (ecx, ptr[rax+rbp+0]); dump();
+mov (ecx, ptr[rax+rbp+1]); dump();
+mov (ecx, ptr[rax+rbp+1000]); dump();
+mov (ecx, ptr[rax+rbp-1]); dump();
+mov (ecx, ptr[rax+rbp-1000]); dump();
+mov (ecx, ptr[rax+rbp*1+0]); dump();
+mov (ecx, ptr[rax+rbp*1+1]); dump();
+mov (ecx, ptr[rax+rbp*1+1000]); dump();
+mov (ecx, ptr[rax+rbp*1-1]); dump();
+mov (ecx, ptr[rax+rbp*1-1000]); dump();
+mov (ecx, ptr[rax+rbp*2+0]); dump();
+mov (ecx, ptr[rax+rbp*2+1]); dump();
+mov (ecx, ptr[rax+rbp*2+1000]); dump();
+mov (ecx, ptr[rax+rbp*2-1]); dump();
+mov (ecx, ptr[rax+rbp*2-1000]); dump();
+mov (ecx, ptr[rax+rbp*4+0]); dump();
+mov (ecx, ptr[rax+rbp*4+1]); dump();
+mov (ecx, ptr[rax+rbp*4+1000]); dump();
+mov (ecx, ptr[rax+rbp*4-1]); dump();
+mov (ecx, ptr[rax+rbp*4-1000]); dump();
+mov (ecx, ptr[rax+rbp*8+0]); dump();
+mov (ecx, ptr[rax+rbp*8+1]); dump();
+mov (ecx, ptr[rax+rbp*8+1000]); dump();
+mov (ecx, ptr[rax+rbp*8-1]); dump();
+mov (ecx, ptr[rax+rbp*8-1000]); dump();
+mov (ecx, ptr[rax+rsi+0]); dump();
+mov (ecx, ptr[rax+rsi+1]); dump();
+mov (ecx, ptr[rax+rsi+1000]); dump();
+mov (ecx, ptr[rax+rsi-1]); dump();
+mov (ecx, ptr[rax+rsi-1000]); dump();
+mov (ecx, ptr[rax+rsi*1+0]); dump();
+mov (ecx, ptr[rax+rsi*1+1]); dump();
+mov (ecx, ptr[rax+rsi*1+1000]); dump();
+mov (ecx, ptr[rax+rsi*1-1]); dump();
+mov (ecx, ptr[rax+rsi*1-1000]); dump();
+mov (ecx, ptr[rax+rsi*2+0]); dump();
+mov (ecx, ptr[rax+rsi*2+1]); dump();
+mov (ecx, ptr[rax+rsi*2+1000]); dump();
+mov (ecx, ptr[rax+rsi*2-1]); dump();
+mov (ecx, ptr[rax+rsi*2-1000]); dump();
+mov (ecx, ptr[rax+rsi*4+0]); dump();
+mov (ecx, ptr[rax+rsi*4+1]); dump();
+mov (ecx, ptr[rax+rsi*4+1000]); dump();
+mov (ecx, ptr[rax+rsi*4-1]); dump();
+mov (ecx, ptr[rax+rsi*4-1000]); dump();
+mov (ecx, ptr[rax+rsi*8+0]); dump();
+mov (ecx, ptr[rax+rsi*8+1]); dump();
+mov (ecx, ptr[rax+rsi*8+1000]); dump();
+mov (ecx, ptr[rax+rsi*8-1]); dump();
+mov (ecx, ptr[rax+rsi*8-1000]); dump();
+mov (ecx, ptr[rax+rdi+0]); dump();
+mov (ecx, ptr[rax+rdi+1]); dump();
+mov (ecx, ptr[rax+rdi+1000]); dump();
+mov (ecx, ptr[rax+rdi-1]); dump();
+mov (ecx, ptr[rax+rdi-1000]); dump();
+mov (ecx, ptr[rax+rdi*1+0]); dump();
+mov (ecx, ptr[rax+rdi*1+1]); dump();
+mov (ecx, ptr[rax+rdi*1+1000]); dump();
+mov (ecx, ptr[rax+rdi*1-1]); dump();
+mov (ecx, ptr[rax+rdi*1-1000]); dump();
+mov (ecx, ptr[rax+rdi*2+0]); dump();
+mov (ecx, ptr[rax+rdi*2+1]); dump();
+mov (ecx, ptr[rax+rdi*2+1000]); dump();
+mov (ecx, ptr[rax+rdi*2-1]); dump();
+mov (ecx, ptr[rax+rdi*2-1000]); dump();
+mov (ecx, ptr[rax+rdi*4+0]); dump();
+mov (ecx, ptr[rax+rdi*4+1]); dump();
+mov (ecx, ptr[rax+rdi*4+1000]); dump();
+mov (ecx, ptr[rax+rdi*4-1]); dump();
+mov (ecx, ptr[rax+rdi*4-1000]); dump();
+mov (ecx, ptr[rax+rdi*8+0]); dump();
+mov (ecx, ptr[rax+rdi*8+1]); dump();
+mov (ecx, ptr[rax+rdi*8+1000]); dump();
+mov (ecx, ptr[rax+rdi*8-1]); dump();
+mov (ecx, ptr[rax+rdi*8-1000]); dump();
+mov (ecx, ptr[rax+r9+0]); dump();
+mov (ecx, ptr[rax+r9+1]); dump();
+mov (ecx, ptr[rax+r9+1000]); dump();
+mov (ecx, ptr[rax+r9-1]); dump();
+mov (ecx, ptr[rax+r9-1000]); dump();
+mov (ecx, ptr[rax+r9*1+0]); dump();
+mov (ecx, ptr[rax+r9*1+1]); dump();
+mov (ecx, ptr[rax+r9*1+1000]); dump();
+mov (ecx, ptr[rax+r9*1-1]); dump();
+mov (ecx, ptr[rax+r9*1-1000]); dump();
+mov (ecx, ptr[rax+r9*2+0]); dump();
+mov (ecx, ptr[rax+r9*2+1]); dump();
+mov (ecx, ptr[rax+r9*2+1000]); dump();
+mov (ecx, ptr[rax+r9*2-1]); dump();
+mov (ecx, ptr[rax+r9*2-1000]); dump();
+mov (ecx, ptr[rax+r9*4+0]); dump();
+mov (ecx, ptr[rax+r9*4+1]); dump();
+mov (ecx, ptr[rax+r9*4+1000]); dump();
+mov (ecx, ptr[rax+r9*4-1]); dump();
+mov (ecx, ptr[rax+r9*4-1000]); dump();
+mov (ecx, ptr[rax+r9*8+0]); dump();
+mov (ecx, ptr[rax+r9*8+1]); dump();
+mov (ecx, ptr[rax+r9*8+1000]); dump();
+mov (ecx, ptr[rax+r9*8-1]); dump();
+mov (ecx, ptr[rax+r9*8-1000]); dump();
+}
+    void gen2(){
+mov (ecx, ptr[rax+r10+0]); dump();
+mov (ecx, ptr[rax+r10+1]); dump();
+mov (ecx, ptr[rax+r10+1000]); dump();
+mov (ecx, ptr[rax+r10-1]); dump();
+mov (ecx, ptr[rax+r10-1000]); dump();
+mov (ecx, ptr[rax+r10*1+0]); dump();
+mov (ecx, ptr[rax+r10*1+1]); dump();
+mov (ecx, ptr[rax+r10*1+1000]); dump();
+mov (ecx, ptr[rax+r10*1-1]); dump();
+mov (ecx, ptr[rax+r10*1-1000]); dump();
+mov (ecx, ptr[rax+r10*2+0]); dump();
+mov (ecx, ptr[rax+r10*2+1]); dump();
+mov (ecx, ptr[rax+r10*2+1000]); dump();
+mov (ecx, ptr[rax+r10*2-1]); dump();
+mov (ecx, ptr[rax+r10*2-1000]); dump();
+mov (ecx, ptr[rax+r10*4+0]); dump();
+mov (ecx, ptr[rax+r10*4+1]); dump();
+mov (ecx, ptr[rax+r10*4+1000]); dump();
+mov (ecx, ptr[rax+r10*4-1]); dump();
+mov (ecx, ptr[rax+r10*4-1000]); dump();
+mov (ecx, ptr[rax+r10*8+0]); dump();
+mov (ecx, ptr[rax+r10*8+1]); dump();
+mov (ecx, ptr[rax+r10*8+1000]); dump();
+mov (ecx, ptr[rax+r10*8-1]); dump();
+mov (ecx, ptr[rax+r10*8-1000]); dump();
+mov (ecx, ptr[rax+r11+0]); dump();
+mov (ecx, ptr[rax+r11+1]); dump();
+mov (ecx, ptr[rax+r11+1000]); dump();
+mov (ecx, ptr[rax+r11-1]); dump();
+mov (ecx, ptr[rax+r11-1000]); dump();
+mov (ecx, ptr[rax+r11*1+0]); dump();
+mov (ecx, ptr[rax+r11*1+1]); dump();
+mov (ecx, ptr[rax+r11*1+1000]); dump();
+mov (ecx, ptr[rax+r11*1-1]); dump();
+mov (ecx, ptr[rax+r11*1-1000]); dump();
+mov (ecx, ptr[rax+r11*2+0]); dump();
+mov (ecx, ptr[rax+r11*2+1]); dump();
+mov (ecx, ptr[rax+r11*2+1000]); dump();
+mov (ecx, ptr[rax+r11*2-1]); dump();
+mov (ecx, ptr[rax+r11*2-1000]); dump();
+mov (ecx, ptr[rax+r11*4+0]); dump();
+mov (ecx, ptr[rax+r11*4+1]); dump();
+mov (ecx, ptr[rax+r11*4+1000]); dump();
+mov (ecx, ptr[rax+r11*4-1]); dump();
+mov (ecx, ptr[rax+r11*4-1000]); dump();
+mov (ecx, ptr[rax+r11*8+0]); dump();
+mov (ecx, ptr[rax+r11*8+1]); dump();
+mov (ecx, ptr[rax+r11*8+1000]); dump();
+mov (ecx, ptr[rax+r11*8-1]); dump();
+mov (ecx, ptr[rax+r11*8-1000]); dump();
+mov (ecx, ptr[rax+r12+0]); dump();
+mov (ecx, ptr[rax+r12+1]); dump();
+mov (ecx, ptr[rax+r12+1000]); dump();
+mov (ecx, ptr[rax+r12-1]); dump();
+mov (ecx, ptr[rax+r12-1000]); dump();
+mov (ecx, ptr[rax+r12*1+0]); dump();
+mov (ecx, ptr[rax+r12*1+1]); dump();
+mov (ecx, ptr[rax+r12*1+1000]); dump();
+mov (ecx, ptr[rax+r12*1-1]); dump();
+mov (ecx, ptr[rax+r12*1-1000]); dump();
+mov (ecx, ptr[rax+r12*2+0]); dump();
+mov (ecx, ptr[rax+r12*2+1]); dump();
+mov (ecx, ptr[rax+r12*2+1000]); dump();
+mov (ecx, ptr[rax+r12*2-1]); dump();
+mov (ecx, ptr[rax+r12*2-1000]); dump();
+mov (ecx, ptr[rax+r12*4+0]); dump();
+mov (ecx, ptr[rax+r12*4+1]); dump();
+mov (ecx, ptr[rax+r12*4+1000]); dump();
+mov (ecx, ptr[rax+r12*4-1]); dump();
+mov (ecx, ptr[rax+r12*4-1000]); dump();
+mov (ecx, ptr[rax+r12*8+0]); dump();
+mov (ecx, ptr[rax+r12*8+1]); dump();
+mov (ecx, ptr[rax+r12*8+1000]); dump();
+mov (ecx, ptr[rax+r12*8-1]); dump();
+mov (ecx, ptr[rax+r12*8-1000]); dump();
+mov (ecx, ptr[rax+r13+0]); dump();
+mov (ecx, ptr[rax+r13+1]); dump();
+mov (ecx, ptr[rax+r13+1000]); dump();
+mov (ecx, ptr[rax+r13-1]); dump();
+mov (ecx, ptr[rax+r13-1000]); dump();
+mov (ecx, ptr[rax+r13*1+0]); dump();
+mov (ecx, ptr[rax+r13*1+1]); dump();
+mov (ecx, ptr[rax+r13*1+1000]); dump();
+mov (ecx, ptr[rax+r13*1-1]); dump();
+mov (ecx, ptr[rax+r13*1-1000]); dump();
+mov (ecx, ptr[rax+r13*2+0]); dump();
+mov (ecx, ptr[rax+r13*2+1]); dump();
+mov (ecx, ptr[rax+r13*2+1000]); dump();
+mov (ecx, ptr[rax+r13*2-1]); dump();
+mov (ecx, ptr[rax+r13*2-1000]); dump();
+mov (ecx, ptr[rax+r13*4+0]); dump();
+mov (ecx, ptr[rax+r13*4+1]); dump();
+mov (ecx, ptr[rax+r13*4+1000]); dump();
+mov (ecx, ptr[rax+r13*4-1]); dump();
+mov (ecx, ptr[rax+r13*4-1000]); dump();
+mov (ecx, ptr[rax+r13*8+0]); dump();
+mov (ecx, ptr[rax+r13*8+1]); dump();
+mov (ecx, ptr[rax+r13*8+1000]); dump();
+mov (ecx, ptr[rax+r13*8-1]); dump();
+mov (ecx, ptr[rax+r13*8-1000]); dump();
+}
+    void gen3(){
+mov (ecx, ptr[rax+r14+0]); dump();
+mov (ecx, ptr[rax+r14+1]); dump();
+mov (ecx, ptr[rax+r14+1000]); dump();
+mov (ecx, ptr[rax+r14-1]); dump();
+mov (ecx, ptr[rax+r14-1000]); dump();
+mov (ecx, ptr[rax+r14*1+0]); dump();
+mov (ecx, ptr[rax+r14*1+1]); dump();
+mov (ecx, ptr[rax+r14*1+1000]); dump();
+mov (ecx, ptr[rax+r14*1-1]); dump();
+mov (ecx, ptr[rax+r14*1-1000]); dump();
+mov (ecx, ptr[rax+r14*2+0]); dump();
+mov (ecx, ptr[rax+r14*2+1]); dump();
+mov (ecx, ptr[rax+r14*2+1000]); dump();
+mov (ecx, ptr[rax+r14*2-1]); dump();
+mov (ecx, ptr[rax+r14*2-1000]); dump();
+mov (ecx, ptr[rax+r14*4+0]); dump();
+mov (ecx, ptr[rax+r14*4+1]); dump();
+mov (ecx, ptr[rax+r14*4+1000]); dump();
+mov (ecx, ptr[rax+r14*4-1]); dump();
+mov (ecx, ptr[rax+r14*4-1000]); dump();
+mov (ecx, ptr[rax+r14*8+0]); dump();
+mov (ecx, ptr[rax+r14*8+1]); dump();
+mov (ecx, ptr[rax+r14*8+1000]); dump();
+mov (ecx, ptr[rax+r14*8-1]); dump();
+mov (ecx, ptr[rax+r14*8-1000]); dump();
+mov (ecx, ptr[rax+r15+0]); dump();
+mov (ecx, ptr[rax+r15+1]); dump();
+mov (ecx, ptr[rax+r15+1000]); dump();
+mov (ecx, ptr[rax+r15-1]); dump();
+mov (ecx, ptr[rax+r15-1000]); dump();
+mov (ecx, ptr[rax+r15*1+0]); dump();
+mov (ecx, ptr[rax+r15*1+1]); dump();
+mov (ecx, ptr[rax+r15*1+1000]); dump();
+mov (ecx, ptr[rax+r15*1-1]); dump();
+mov (ecx, ptr[rax+r15*1-1000]); dump();
+mov (ecx, ptr[rax+r15*2+0]); dump();
+mov (ecx, ptr[rax+r15*2+1]); dump();
+mov (ecx, ptr[rax+r15*2+1000]); dump();
+mov (ecx, ptr[rax+r15*2-1]); dump();
+mov (ecx, ptr[rax+r15*2-1000]); dump();
+mov (ecx, ptr[rax+r15*4+0]); dump();
+mov (ecx, ptr[rax+r15*4+1]); dump();
+mov (ecx, ptr[rax+r15*4+1000]); dump();
+mov (ecx, ptr[rax+r15*4-1]); dump();
+mov (ecx, ptr[rax+r15*4-1000]); dump();
+mov (ecx, ptr[rax+r15*8+0]); dump();
+mov (ecx, ptr[rax+r15*8+1]); dump();
+mov (ecx, ptr[rax+r15*8+1000]); dump();
+mov (ecx, ptr[rax+r15*8-1]); dump();
+mov (ecx, ptr[rax+r15*8-1000]); dump();
+mov (ecx, ptr[rax+0]); dump();
+mov (ecx, ptr[rax+1]); dump();
+mov (ecx, ptr[rax+1000]); dump();
+mov (ecx, ptr[rax-1]); dump();
+mov (ecx, ptr[rax-1000]); dump();
+mov (ecx, ptr[rax+0]); dump();
+mov (ecx, ptr[rax+1]); dump();
+mov (ecx, ptr[rax+1000]); dump();
+mov (ecx, ptr[rax-1]); dump();
+mov (ecx, ptr[rax-1000]); dump();
+mov (ecx, ptr[rax+0]); dump();
+mov (ecx, ptr[rax+1]); dump();
+mov (ecx, ptr[rax+1000]); dump();
+mov (ecx, ptr[rax-1]); dump();
+mov (ecx, ptr[rax-1000]); dump();
+mov (ecx, ptr[rax+0]); dump();
+mov (ecx, ptr[rax+1]); dump();
+mov (ecx, ptr[rax+1000]); dump();
+mov (ecx, ptr[rax-1]); dump();
+mov (ecx, ptr[rax-1000]); dump();
+mov (ecx, ptr[rax+0]); dump();
+mov (ecx, ptr[rax+1]); dump();
+mov (ecx, ptr[rax+1000]); dump();
+mov (ecx, ptr[rax-1]); dump();
+mov (ecx, ptr[rax-1000]); dump();
+mov (ecx, ptr[rcx+rax+0]); dump();
+mov (ecx, ptr[rcx+rax+1]); dump();
+mov (ecx, ptr[rcx+rax+1000]); dump();
+mov (ecx, ptr[rcx+rax-1]); dump();
+mov (ecx, ptr[rcx+rax-1000]); dump();
+mov (ecx, ptr[rcx+rax*1+0]); dump();
+mov (ecx, ptr[rcx+rax*1+1]); dump();
+mov (ecx, ptr[rcx+rax*1+1000]); dump();
+mov (ecx, ptr[rcx+rax*1-1]); dump();
+mov (ecx, ptr[rcx+rax*1-1000]); dump();
+mov (ecx, ptr[rcx+rax*2+0]); dump();
+mov (ecx, ptr[rcx+rax*2+1]); dump();
+mov (ecx, ptr[rcx+rax*2+1000]); dump();
+mov (ecx, ptr[rcx+rax*2-1]); dump();
+mov (ecx, ptr[rcx+rax*2-1000]); dump();
+mov (ecx, ptr[rcx+rax*4+0]); dump();
+mov (ecx, ptr[rcx+rax*4+1]); dump();
+mov (ecx, ptr[rcx+rax*4+1000]); dump();
+mov (ecx, ptr[rcx+rax*4-1]); dump();
+mov (ecx, ptr[rcx+rax*4-1000]); dump();
+mov (ecx, ptr[rcx+rax*8+0]); dump();
+mov (ecx, ptr[rcx+rax*8+1]); dump();
+mov (ecx, ptr[rcx+rax*8+1000]); dump();
+mov (ecx, ptr[rcx+rax*8-1]); dump();
+mov (ecx, ptr[rcx+rax*8-1000]); dump();
+}
+    void gen4(){
+mov (ecx, ptr[rcx+rcx+0]); dump();
+mov (ecx, ptr[rcx+rcx+1]); dump();
+mov (ecx, ptr[rcx+rcx+1000]); dump();
+mov (ecx, ptr[rcx+rcx-1]); dump();
+mov (ecx, ptr[rcx+rcx-1000]); dump();
+mov (ecx, ptr[rcx+rcx*1+0]); dump();
+mov (ecx, ptr[rcx+rcx*1+1]); dump();
+mov (ecx, ptr[rcx+rcx*1+1000]); dump();
+mov (ecx, ptr[rcx+rcx*1-1]); dump();
+mov (ecx, ptr[rcx+rcx*1-1000]); dump();
+mov (ecx, ptr[rcx+rcx*2+0]); dump();
+mov (ecx, ptr[rcx+rcx*2+1]); dump();
+mov (ecx, ptr[rcx+rcx*2+1000]); dump();
+mov (ecx, ptr[rcx+rcx*2-1]); dump();
+mov (ecx, ptr[rcx+rcx*2-1000]); dump();
+mov (ecx, ptr[rcx+rcx*4+0]); dump();
+mov (ecx, ptr[rcx+rcx*4+1]); dump();
+mov (ecx, ptr[rcx+rcx*4+1000]); dump();
+mov (ecx, ptr[rcx+rcx*4-1]); dump();
+mov (ecx, ptr[rcx+rcx*4-1000]); dump();
+mov (ecx, ptr[rcx+rcx*8+0]); dump();
+mov (ecx, ptr[rcx+rcx*8+1]); dump();
+mov (ecx, ptr[rcx+rcx*8+1000]); dump();
+mov (ecx, ptr[rcx+rcx*8-1]); dump();
+mov (ecx, ptr[rcx+rcx*8-1000]); dump();
+mov (ecx, ptr[rcx+rdx+0]); dump();
+mov (ecx, ptr[rcx+rdx+1]); dump();
+mov (ecx, ptr[rcx+rdx+1000]); dump();
+mov (ecx, ptr[rcx+rdx-1]); dump();
+mov (ecx, ptr[rcx+rdx-1000]); dump();
+mov (ecx, ptr[rcx+rdx*1+0]); dump();
+mov (ecx, ptr[rcx+rdx*1+1]); dump();
+mov (ecx, ptr[rcx+rdx*1+1000]); dump();
+mov (ecx, ptr[rcx+rdx*1-1]); dump();
+mov (ecx, ptr[rcx+rdx*1-1000]); dump();
+mov (ecx, ptr[rcx+rdx*2+0]); dump();
+mov (ecx, ptr[rcx+rdx*2+1]); dump();
+mov (ecx, ptr[rcx+rdx*2+1000]); dump();
+mov (ecx, ptr[rcx+rdx*2-1]); dump();
+mov (ecx, ptr[rcx+rdx*2-1000]); dump();
+mov (ecx, ptr[rcx+rdx*4+0]); dump();
+mov (ecx, ptr[rcx+rdx*4+1]); dump();
+mov (ecx, ptr[rcx+rdx*4+1000]); dump();
+mov (ecx, ptr[rcx+rdx*4-1]); dump();
+mov (ecx, ptr[rcx+rdx*4-1000]); dump();
+mov (ecx, ptr[rcx+rdx*8+0]); dump();
+mov (ecx, ptr[rcx+rdx*8+1]); dump();
+mov (ecx, ptr[rcx+rdx*8+1000]); dump();
+mov (ecx, ptr[rcx+rdx*8-1]); dump();
+mov (ecx, ptr[rcx+rdx*8-1000]); dump();
+mov (ecx, ptr[rcx+rbx+0]); dump();
+mov (ecx, ptr[rcx+rbx+1]); dump();
+mov (ecx, ptr[rcx+rbx+1000]); dump();
+mov (ecx, ptr[rcx+rbx-1]); dump();
+mov (ecx, ptr[rcx+rbx-1000]); dump();
+mov (ecx, ptr[rcx+rbx*1+0]); dump();
+mov (ecx, ptr[rcx+rbx*1+1]); dump();
+mov (ecx, ptr[rcx+rbx*1+1000]); dump();
+mov (ecx, ptr[rcx+rbx*1-1]); dump();
+mov (ecx, ptr[rcx+rbx*1-1000]); dump();
+mov (ecx, ptr[rcx+rbx*2+0]); dump();
+mov (ecx, ptr[rcx+rbx*2+1]); dump();
+mov (ecx, ptr[rcx+rbx*2+1000]); dump();
+mov (ecx, ptr[rcx+rbx*2-1]); dump();
+mov (ecx, ptr[rcx+rbx*2-1000]); dump();
+mov (ecx, ptr[rcx+rbx*4+0]); dump();
+mov (ecx, ptr[rcx+rbx*4+1]); dump();
+mov (ecx, ptr[rcx+rbx*4+1000]); dump();
+mov (ecx, ptr[rcx+rbx*4-1]); dump();
+mov (ecx, ptr[rcx+rbx*4-1000]); dump();
+mov (ecx, ptr[rcx+rbx*8+0]); dump();
+mov (ecx, ptr[rcx+rbx*8+1]); dump();
+mov (ecx, ptr[rcx+rbx*8+1000]); dump();
+mov (ecx, ptr[rcx+rbx*8-1]); dump();
+mov (ecx, ptr[rcx+rbx*8-1000]); dump();
+mov (ecx, ptr[rcx+rbp+0]); dump();
+mov (ecx, ptr[rcx+rbp+1]); dump();
+mov (ecx, ptr[rcx+rbp+1000]); dump();
+mov (ecx, ptr[rcx+rbp-1]); dump();
+mov (ecx, ptr[rcx+rbp-1000]); dump();
+mov (ecx, ptr[rcx+rbp*1+0]); dump();
+mov (ecx, ptr[rcx+rbp*1+1]); dump();
+mov (ecx, ptr[rcx+rbp*1+1000]); dump();
+mov (ecx, ptr[rcx+rbp*1-1]); dump();
+mov (ecx, ptr[rcx+rbp*1-1000]); dump();
+mov (ecx, ptr[rcx+rbp*2+0]); dump();
+mov (ecx, ptr[rcx+rbp*2+1]); dump();
+mov (ecx, ptr[rcx+rbp*2+1000]); dump();
+mov (ecx, ptr[rcx+rbp*2-1]); dump();
+mov (ecx, ptr[rcx+rbp*2-1000]); dump();
+mov (ecx, ptr[rcx+rbp*4+0]); dump();
+mov (ecx, ptr[rcx+rbp*4+1]); dump();
+mov (ecx, ptr[rcx+rbp*4+1000]); dump();
+mov (ecx, ptr[rcx+rbp*4-1]); dump();
+mov (ecx, ptr[rcx+rbp*4-1000]); dump();
+mov (ecx, ptr[rcx+rbp*8+0]); dump();
+mov (ecx, ptr[rcx+rbp*8+1]); dump();
+mov (ecx, ptr[rcx+rbp*8+1000]); dump();
+mov (ecx, ptr[rcx+rbp*8-1]); dump();
+mov (ecx, ptr[rcx+rbp*8-1000]); dump();
+}
+    void gen5(){
+mov (ecx, ptr[rcx+rsi+0]); dump();
+mov (ecx, ptr[rcx+rsi+1]); dump();
+mov (ecx, ptr[rcx+rsi+1000]); dump();
+mov (ecx, ptr[rcx+rsi-1]); dump();
+mov (ecx, ptr[rcx+rsi-1000]); dump();
+mov (ecx, ptr[rcx+rsi*1+0]); dump();
+mov (ecx, ptr[rcx+rsi*1+1]); dump();
+mov (ecx, ptr[rcx+rsi*1+1000]); dump();
+mov (ecx, ptr[rcx+rsi*1-1]); dump();
+mov (ecx, ptr[rcx+rsi*1-1000]); dump();
+mov (ecx, ptr[rcx+rsi*2+0]); dump();
+mov (ecx, ptr[rcx+rsi*2+1]); dump();
+mov (ecx, ptr[rcx+rsi*2+1000]); dump();
+mov (ecx, ptr[rcx+rsi*2-1]); dump();
+mov (ecx, ptr[rcx+rsi*2-1000]); dump();
+mov (ecx, ptr[rcx+rsi*4+0]); dump();
+mov (ecx, ptr[rcx+rsi*4+1]); dump();
+mov (ecx, ptr[rcx+rsi*4+1000]); dump();
+mov (ecx, ptr[rcx+rsi*4-1]); dump();
+mov (ecx, ptr[rcx+rsi*4-1000]); dump();
+mov (ecx, ptr[rcx+rsi*8+0]); dump();
+mov (ecx, ptr[rcx+rsi*8+1]); dump();
+mov (ecx, ptr[rcx+rsi*8+1000]); dump();
+mov (ecx, ptr[rcx+rsi*8-1]); dump();
+mov (ecx, ptr[rcx+rsi*8-1000]); dump();
+mov (ecx, ptr[rcx+rdi+0]); dump();
+mov (ecx, ptr[rcx+rdi+1]); dump();
+mov (ecx, ptr[rcx+rdi+1000]); dump();
+mov (ecx, ptr[rcx+rdi-1]); dump();
+mov (ecx, ptr[rcx+rdi-1000]); dump();
+mov (ecx, ptr[rcx+rdi*1+0]); dump();
+mov (ecx, ptr[rcx+rdi*1+1]); dump();
+mov (ecx, ptr[rcx+rdi*1+1000]); dump();
+mov (ecx, ptr[rcx+rdi*1-1]); dump();
+mov (ecx, ptr[rcx+rdi*1-1000]); dump();
+mov (ecx, ptr[rcx+rdi*2+0]); dump();
+mov (ecx, ptr[rcx+rdi*2+1]); dump();
+mov (ecx, ptr[rcx+rdi*2+1000]); dump();
+mov (ecx, ptr[rcx+rdi*2-1]); dump();
+mov (ecx, ptr[rcx+rdi*2-1000]); dump();
+mov (ecx, ptr[rcx+rdi*4+0]); dump();
+mov (ecx, ptr[rcx+rdi*4+1]); dump();
+mov (ecx, ptr[rcx+rdi*4+1000]); dump();
+mov (ecx, ptr[rcx+rdi*4-1]); dump();
+mov (ecx, ptr[rcx+rdi*4-1000]); dump();
+mov (ecx, ptr[rcx+rdi*8+0]); dump();
+mov (ecx, ptr[rcx+rdi*8+1]); dump();
+mov (ecx, ptr[rcx+rdi*8+1000]); dump();
+mov (ecx, ptr[rcx+rdi*8-1]); dump();
+mov (ecx, ptr[rcx+rdi*8-1000]); dump();
+mov (ecx, ptr[rcx+r9+0]); dump();
+mov (ecx, ptr[rcx+r9+1]); dump();
+mov (ecx, ptr[rcx+r9+1000]); dump();
+mov (ecx, ptr[rcx+r9-1]); dump();
+mov (ecx, ptr[rcx+r9-1000]); dump();
+mov (ecx, ptr[rcx+r9*1+0]); dump();
+mov (ecx, ptr[rcx+r9*1+1]); dump();
+mov (ecx, ptr[rcx+r9*1+1000]); dump();
+mov (ecx, ptr[rcx+r9*1-1]); dump();
+mov (ecx, ptr[rcx+r9*1-1000]); dump();
+mov (ecx, ptr[rcx+r9*2+0]); dump();
+mov (ecx, ptr[rcx+r9*2+1]); dump();
+mov (ecx, ptr[rcx+r9*2+1000]); dump();
+mov (ecx, ptr[rcx+r9*2-1]); dump();
+mov (ecx, ptr[rcx+r9*2-1000]); dump();
+mov (ecx, ptr[rcx+r9*4+0]); dump();
+mov (ecx, ptr[rcx+r9*4+1]); dump();
+mov (ecx, ptr[rcx+r9*4+1000]); dump();
+mov (ecx, ptr[rcx+r9*4-1]); dump();
+mov (ecx, ptr[rcx+r9*4-1000]); dump();
+mov (ecx, ptr[rcx+r9*8+0]); dump();
+mov (ecx, ptr[rcx+r9*8+1]); dump();
+mov (ecx, ptr[rcx+r9*8+1000]); dump();
+mov (ecx, ptr[rcx+r9*8-1]); dump();
+mov (ecx, ptr[rcx+r9*8-1000]); dump();
+mov (ecx, ptr[rcx+r10+0]); dump();
+mov (ecx, ptr[rcx+r10+1]); dump();
+mov (ecx, ptr[rcx+r10+1000]); dump();
+mov (ecx, ptr[rcx+r10-1]); dump();
+mov (ecx, ptr[rcx+r10-1000]); dump();
+mov (ecx, ptr[rcx+r10*1+0]); dump();
+mov (ecx, ptr[rcx+r10*1+1]); dump();
+mov (ecx, ptr[rcx+r10*1+1000]); dump();
+mov (ecx, ptr[rcx+r10*1-1]); dump();
+mov (ecx, ptr[rcx+r10*1-1000]); dump();
+mov (ecx, ptr[rcx+r10*2+0]); dump();
+mov (ecx, ptr[rcx+r10*2+1]); dump();
+mov (ecx, ptr[rcx+r10*2+1000]); dump();
+mov (ecx, ptr[rcx+r10*2-1]); dump();
+mov (ecx, ptr[rcx+r10*2-1000]); dump();
+mov (ecx, ptr[rcx+r10*4+0]); dump();
+mov (ecx, ptr[rcx+r10*4+1]); dump();
+mov (ecx, ptr[rcx+r10*4+1000]); dump();
+mov (ecx, ptr[rcx+r10*4-1]); dump();
+mov (ecx, ptr[rcx+r10*4-1000]); dump();
+mov (ecx, ptr[rcx+r10*8+0]); dump();
+mov (ecx, ptr[rcx+r10*8+1]); dump();
+mov (ecx, ptr[rcx+r10*8+1000]); dump();
+mov (ecx, ptr[rcx+r10*8-1]); dump();
+mov (ecx, ptr[rcx+r10*8-1000]); dump();
+}
+    void gen6(){
+mov (ecx, ptr[rcx+r11+0]); dump();
+mov (ecx, ptr[rcx+r11+1]); dump();
+mov (ecx, ptr[rcx+r11+1000]); dump();
+mov (ecx, ptr[rcx+r11-1]); dump();
+mov (ecx, ptr[rcx+r11-1000]); dump();
+mov (ecx, ptr[rcx+r11*1+0]); dump();
+mov (ecx, ptr[rcx+r11*1+1]); dump();
+mov (ecx, ptr[rcx+r11*1+1000]); dump();
+mov (ecx, ptr[rcx+r11*1-1]); dump();
+mov (ecx, ptr[rcx+r11*1-1000]); dump();
+mov (ecx, ptr[rcx+r11*2+0]); dump();
+mov (ecx, ptr[rcx+r11*2+1]); dump();
+mov (ecx, ptr[rcx+r11*2+1000]); dump();
+mov (ecx, ptr[rcx+r11*2-1]); dump();
+mov (ecx, ptr[rcx+r11*2-1000]); dump();
+mov (ecx, ptr[rcx+r11*4+0]); dump();
+mov (ecx, ptr[rcx+r11*4+1]); dump();
+mov (ecx, ptr[rcx+r11*4+1000]); dump();
+mov (ecx, ptr[rcx+r11*4-1]); dump();
+mov (ecx, ptr[rcx+r11*4-1000]); dump();
+mov (ecx, ptr[rcx+r11*8+0]); dump();
+mov (ecx, ptr[rcx+r11*8+1]); dump();
+mov (ecx, ptr[rcx+r11*8+1000]); dump();
+mov (ecx, ptr[rcx+r11*8-1]); dump();
+mov (ecx, ptr[rcx+r11*8-1000]); dump();
+mov (ecx, ptr[rcx+r12+0]); dump();
+mov (ecx, ptr[rcx+r12+1]); dump();
+mov (ecx, ptr[rcx+r12+1000]); dump();
+mov (ecx, ptr[rcx+r12-1]); dump();
+mov (ecx, ptr[rcx+r12-1000]); dump();
+mov (ecx, ptr[rcx+r12*1+0]); dump();
+mov (ecx, ptr[rcx+r12*1+1]); dump();
+mov (ecx, ptr[rcx+r12*1+1000]); dump();
+mov (ecx, ptr[rcx+r12*1-1]); dump();
+mov (ecx, ptr[rcx+r12*1-1000]); dump();
+mov (ecx, ptr[rcx+r12*2+0]); dump();
+mov (ecx, ptr[rcx+r12*2+1]); dump();
+mov (ecx, ptr[rcx+r12*2+1000]); dump();
+mov (ecx, ptr[rcx+r12*2-1]); dump();
+mov (ecx, ptr[rcx+r12*2-1000]); dump();
+mov (ecx, ptr[rcx+r12*4+0]); dump();
+mov (ecx, ptr[rcx+r12*4+1]); dump();
+mov (ecx, ptr[rcx+r12*4+1000]); dump();
+mov (ecx, ptr[rcx+r12*4-1]); dump();
+mov (ecx, ptr[rcx+r12*4-1000]); dump();
+mov (ecx, ptr[rcx+r12*8+0]); dump();
+mov (ecx, ptr[rcx+r12*8+1]); dump();
+mov (ecx, ptr[rcx+r12*8+1000]); dump();
+mov (ecx, ptr[rcx+r12*8-1]); dump();
+mov (ecx, ptr[rcx+r12*8-1000]); dump();
+mov (ecx, ptr[rcx+r13+0]); dump();
+mov (ecx, ptr[rcx+r13+1]); dump();
+mov (ecx, ptr[rcx+r13+1000]); dump();
+mov (ecx, ptr[rcx+r13-1]); dump();
+mov (ecx, ptr[rcx+r13-1000]); dump();
+mov (ecx, ptr[rcx+r13*1+0]); dump();
+mov (ecx, ptr[rcx+r13*1+1]); dump();
+mov (ecx, ptr[rcx+r13*1+1000]); dump();
+mov (ecx, ptr[rcx+r13*1-1]); dump();
+mov (ecx, ptr[rcx+r13*1-1000]); dump();
+mov (ecx, ptr[rcx+r13*2+0]); dump();
+mov (ecx, ptr[rcx+r13*2+1]); dump();
+mov (ecx, ptr[rcx+r13*2+1000]); dump();
+mov (ecx, ptr[rcx+r13*2-1]); dump();
+mov (ecx, ptr[rcx+r13*2-1000]); dump();
+mov (ecx, ptr[rcx+r13*4+0]); dump();
+mov (ecx, ptr[rcx+r13*4+1]); dump();
+mov (ecx, ptr[rcx+r13*4+1000]); dump();
+mov (ecx, ptr[rcx+r13*4-1]); dump();
+mov (ecx, ptr[rcx+r13*4-1000]); dump();
+mov (ecx, ptr[rcx+r13*8+0]); dump();
+mov (ecx, ptr[rcx+r13*8+1]); dump();
+mov (ecx, ptr[rcx+r13*8+1000]); dump();
+mov (ecx, ptr[rcx+r13*8-1]); dump();
+mov (ecx, ptr[rcx+r13*8-1000]); dump();
+mov (ecx, ptr[rcx+r14+0]); dump();
+mov (ecx, ptr[rcx+r14+1]); dump();
+mov (ecx, ptr[rcx+r14+1000]); dump();
+mov (ecx, ptr[rcx+r14-1]); dump();
+mov (ecx, ptr[rcx+r14-1000]); dump();
+mov (ecx, ptr[rcx+r14*1+0]); dump();
+mov (ecx, ptr[rcx+r14*1+1]); dump();
+mov (ecx, ptr[rcx+r14*1+1000]); dump();
+mov (ecx, ptr[rcx+r14*1-1]); dump();
+mov (ecx, ptr[rcx+r14*1-1000]); dump();
+mov (ecx, ptr[rcx+r14*2+0]); dump();
+mov (ecx, ptr[rcx+r14*2+1]); dump();
+mov (ecx, ptr[rcx+r14*2+1000]); dump();
+mov (ecx, ptr[rcx+r14*2-1]); dump();
+mov (ecx, ptr[rcx+r14*2-1000]); dump();
+mov (ecx, ptr[rcx+r14*4+0]); dump();
+mov (ecx, ptr[rcx+r14*4+1]); dump();
+mov (ecx, ptr[rcx+r14*4+1000]); dump();
+mov (ecx, ptr[rcx+r14*4-1]); dump();
+mov (ecx, ptr[rcx+r14*4-1000]); dump();
+mov (ecx, ptr[rcx+r14*8+0]); dump();
+mov (ecx, ptr[rcx+r14*8+1]); dump();
+mov (ecx, ptr[rcx+r14*8+1000]); dump();
+mov (ecx, ptr[rcx+r14*8-1]); dump();
+mov (ecx, ptr[rcx+r14*8-1000]); dump();
+}
+    void gen7(){
+mov (ecx, ptr[rcx+r15+0]); dump();
+mov (ecx, ptr[rcx+r15+1]); dump();
+mov (ecx, ptr[rcx+r15+1000]); dump();
+mov (ecx, ptr[rcx+r15-1]); dump();
+mov (ecx, ptr[rcx+r15-1000]); dump();
+mov (ecx, ptr[rcx+r15*1+0]); dump();
+mov (ecx, ptr[rcx+r15*1+1]); dump();
+mov (ecx, ptr[rcx+r15*1+1000]); dump();
+mov (ecx, ptr[rcx+r15*1-1]); dump();
+mov (ecx, ptr[rcx+r15*1-1000]); dump();
+mov (ecx, ptr[rcx+r15*2+0]); dump();
+mov (ecx, ptr[rcx+r15*2+1]); dump();
+mov (ecx, ptr[rcx+r15*2+1000]); dump();
+mov (ecx, ptr[rcx+r15*2-1]); dump();
+mov (ecx, ptr[rcx+r15*2-1000]); dump();
+mov (ecx, ptr[rcx+r15*4+0]); dump();
+mov (ecx, ptr[rcx+r15*4+1]); dump();
+mov (ecx, ptr[rcx+r15*4+1000]); dump();
+mov (ecx, ptr[rcx+r15*4-1]); dump();
+mov (ecx, ptr[rcx+r15*4-1000]); dump();
+mov (ecx, ptr[rcx+r15*8+0]); dump();
+mov (ecx, ptr[rcx+r15*8+1]); dump();
+mov (ecx, ptr[rcx+r15*8+1000]); dump();
+mov (ecx, ptr[rcx+r15*8-1]); dump();
+mov (ecx, ptr[rcx+r15*8-1000]); dump();
+mov (ecx, ptr[rcx+0]); dump();
+mov (ecx, ptr[rcx+1]); dump();
+mov (ecx, ptr[rcx+1000]); dump();
+mov (ecx, ptr[rcx-1]); dump();
+mov (ecx, ptr[rcx-1000]); dump();
+mov (ecx, ptr[rcx+0]); dump();
+mov (ecx, ptr[rcx+1]); dump();
+mov (ecx, ptr[rcx+1000]); dump();
+mov (ecx, ptr[rcx-1]); dump();
+mov (ecx, ptr[rcx-1000]); dump();
+mov (ecx, ptr[rcx+0]); dump();
+mov (ecx, ptr[rcx+1]); dump();
+mov (ecx, ptr[rcx+1000]); dump();
+mov (ecx, ptr[rcx-1]); dump();
+mov (ecx, ptr[rcx-1000]); dump();
+mov (ecx, ptr[rcx+0]); dump();
+mov (ecx, ptr[rcx+1]); dump();
+mov (ecx, ptr[rcx+1000]); dump();
+mov (ecx, ptr[rcx-1]); dump();
+mov (ecx, ptr[rcx-1000]); dump();
+mov (ecx, ptr[rcx+0]); dump();
+mov (ecx, ptr[rcx+1]); dump();
+mov (ecx, ptr[rcx+1000]); dump();
+mov (ecx, ptr[rcx-1]); dump();
+mov (ecx, ptr[rcx-1000]); dump();
+mov (ecx, ptr[rdx+rax+0]); dump();
+mov (ecx, ptr[rdx+rax+1]); dump();
+mov (ecx, ptr[rdx+rax+1000]); dump();
+mov (ecx, ptr[rdx+rax-1]); dump();
+mov (ecx, ptr[rdx+rax-1000]); dump();
+mov (ecx, ptr[rdx+rax*1+0]); dump();
+mov (ecx, ptr[rdx+rax*1+1]); dump();
+mov (ecx, ptr[rdx+rax*1+1000]); dump();
+mov (ecx, ptr[rdx+rax*1-1]); dump();
+mov (ecx, ptr[rdx+rax*1-1000]); dump();
+mov (ecx, ptr[rdx+rax*2+0]); dump();
+mov (ecx, ptr[rdx+rax*2+1]); dump();
+mov (ecx, ptr[rdx+rax*2+1000]); dump();
+mov (ecx, ptr[rdx+rax*2-1]); dump();
+mov (ecx, ptr[rdx+rax*2-1000]); dump();
+mov (ecx, ptr[rdx+rax*4+0]); dump();
+mov (ecx, ptr[rdx+rax*4+1]); dump();
+mov (ecx, ptr[rdx+rax*4+1000]); dump();
+mov (ecx, ptr[rdx+rax*4-1]); dump();
+mov (ecx, ptr[rdx+rax*4-1000]); dump();
+mov (ecx, ptr[rdx+rax*8+0]); dump();
+mov (ecx, ptr[rdx+rax*8+1]); dump();
+mov (ecx, ptr[rdx+rax*8+1000]); dump();
+mov (ecx, ptr[rdx+rax*8-1]); dump();
+mov (ecx, ptr[rdx+rax*8-1000]); dump();
+mov (ecx, ptr[rdx+rcx+0]); dump();
+mov (ecx, ptr[rdx+rcx+1]); dump();
+mov (ecx, ptr[rdx+rcx+1000]); dump();
+mov (ecx, ptr[rdx+rcx-1]); dump();
+mov (ecx, ptr[rdx+rcx-1000]); dump();
+mov (ecx, ptr[rdx+rcx*1+0]); dump();
+mov (ecx, ptr[rdx+rcx*1+1]); dump();
+mov (ecx, ptr[rdx+rcx*1+1000]); dump();
+mov (ecx, ptr[rdx+rcx*1-1]); dump();
+mov (ecx, ptr[rdx+rcx*1-1000]); dump();
+mov (ecx, ptr[rdx+rcx*2+0]); dump();
+mov (ecx, ptr[rdx+rcx*2+1]); dump();
+mov (ecx, ptr[rdx+rcx*2+1000]); dump();
+mov (ecx, ptr[rdx+rcx*2-1]); dump();
+mov (ecx, ptr[rdx+rcx*2-1000]); dump();
+mov (ecx, ptr[rdx+rcx*4+0]); dump();
+mov (ecx, ptr[rdx+rcx*4+1]); dump();
+mov (ecx, ptr[rdx+rcx*4+1000]); dump();
+mov (ecx, ptr[rdx+rcx*4-1]); dump();
+mov (ecx, ptr[rdx+rcx*4-1000]); dump();
+mov (ecx, ptr[rdx+rcx*8+0]); dump();
+mov (ecx, ptr[rdx+rcx*8+1]); dump();
+mov (ecx, ptr[rdx+rcx*8+1000]); dump();
+mov (ecx, ptr[rdx+rcx*8-1]); dump();
+mov (ecx, ptr[rdx+rcx*8-1000]); dump();
+}
+    void gen8(){
+mov (ecx, ptr[rdx+rdx+0]); dump();
+mov (ecx, ptr[rdx+rdx+1]); dump();
+mov (ecx, ptr[rdx+rdx+1000]); dump();
+mov (ecx, ptr[rdx+rdx-1]); dump();
+mov (ecx, ptr[rdx+rdx-1000]); dump();
+mov (ecx, ptr[rdx+rdx*1+0]); dump();
+mov (ecx, ptr[rdx+rdx*1+1]); dump();
+mov (ecx, ptr[rdx+rdx*1+1000]); dump();
+mov (ecx, ptr[rdx+rdx*1-1]); dump();
+mov (ecx, ptr[rdx+rdx*1-1000]); dump();
+mov (ecx, ptr[rdx+rdx*2+0]); dump();
+mov (ecx, ptr[rdx+rdx*2+1]); dump();
+mov (ecx, ptr[rdx+rdx*2+1000]); dump();
+mov (ecx, ptr[rdx+rdx*2-1]); dump();
+mov (ecx, ptr[rdx+rdx*2-1000]); dump();
+mov (ecx, ptr[rdx+rdx*4+0]); dump();
+mov (ecx, ptr[rdx+rdx*4+1]); dump();
+mov (ecx, ptr[rdx+rdx*4+1000]); dump();
+mov (ecx, ptr[rdx+rdx*4-1]); dump();
+mov (ecx, ptr[rdx+rdx*4-1000]); dump();
+mov (ecx, ptr[rdx+rdx*8+0]); dump();
+mov (ecx, ptr[rdx+rdx*8+1]); dump();
+mov (ecx, ptr[rdx+rdx*8+1000]); dump();
+mov (ecx, ptr[rdx+rdx*8-1]); dump();
+mov (ecx, ptr[rdx+rdx*8-1000]); dump();
+mov (ecx, ptr[rdx+rbx+0]); dump();
+mov (ecx, ptr[rdx+rbx+1]); dump();
+mov (ecx, ptr[rdx+rbx+1000]); dump();
+mov (ecx, ptr[rdx+rbx-1]); dump();
+mov (ecx, ptr[rdx+rbx-1000]); dump();
+mov (ecx, ptr[rdx+rbx*1+0]); dump();
+mov (ecx, ptr[rdx+rbx*1+1]); dump();
+mov (ecx, ptr[rdx+rbx*1+1000]); dump();
+mov (ecx, ptr[rdx+rbx*1-1]); dump();
+mov (ecx, ptr[rdx+rbx*1-1000]); dump();
+mov (ecx, ptr[rdx+rbx*2+0]); dump();
+mov (ecx, ptr[rdx+rbx*2+1]); dump();
+mov (ecx, ptr[rdx+rbx*2+1000]); dump();
+mov (ecx, ptr[rdx+rbx*2-1]); dump();
+mov (ecx, ptr[rdx+rbx*2-1000]); dump();
+mov (ecx, ptr[rdx+rbx*4+0]); dump();
+mov (ecx, ptr[rdx+rbx*4+1]); dump();
+mov (ecx, ptr[rdx+rbx*4+1000]); dump();
+mov (ecx, ptr[rdx+rbx*4-1]); dump();
+mov (ecx, ptr[rdx+rbx*4-1000]); dump();
+mov (ecx, ptr[rdx+rbx*8+0]); dump();
+mov (ecx, ptr[rdx+rbx*8+1]); dump();
+mov (ecx, ptr[rdx+rbx*8+1000]); dump();
+mov (ecx, ptr[rdx+rbx*8-1]); dump();
+mov (ecx, ptr[rdx+rbx*8-1000]); dump();
+mov (ecx, ptr[rdx+rbp+0]); dump();
+mov (ecx, ptr[rdx+rbp+1]); dump();
+mov (ecx, ptr[rdx+rbp+1000]); dump();
+mov (ecx, ptr[rdx+rbp-1]); dump();
+mov (ecx, ptr[rdx+rbp-1000]); dump();
+mov (ecx, ptr[rdx+rbp*1+0]); dump();
+mov (ecx, ptr[rdx+rbp*1+1]); dump();
+mov (ecx, ptr[rdx+rbp*1+1000]); dump();
+mov (ecx, ptr[rdx+rbp*1-1]); dump();
+mov (ecx, ptr[rdx+rbp*1-1000]); dump();
+mov (ecx, ptr[rdx+rbp*2+0]); dump();
+mov (ecx, ptr[rdx+rbp*2+1]); dump();
+mov (ecx, ptr[rdx+rbp*2+1000]); dump();
+mov (ecx, ptr[rdx+rbp*2-1]); dump();
+mov (ecx, ptr[rdx+rbp*2-1000]); dump();
+mov (ecx, ptr[rdx+rbp*4+0]); dump();
+mov (ecx, ptr[rdx+rbp*4+1]); dump();
+mov (ecx, ptr[rdx+rbp*4+1000]); dump();
+mov (ecx, ptr[rdx+rbp*4-1]); dump();
+mov (ecx, ptr[rdx+rbp*4-1000]); dump();
+mov (ecx, ptr[rdx+rbp*8+0]); dump();
+mov (ecx, ptr[rdx+rbp*8+1]); dump();
+mov (ecx, ptr[rdx+rbp*8+1000]); dump();
+mov (ecx, ptr[rdx+rbp*8-1]); dump();
+mov (ecx, ptr[rdx+rbp*8-1000]); dump();
+mov (ecx, ptr[rdx+rsi+0]); dump();
+mov (ecx, ptr[rdx+rsi+1]); dump();
+mov (ecx, ptr[rdx+rsi+1000]); dump();
+mov (ecx, ptr[rdx+rsi-1]); dump();
+mov (ecx, ptr[rdx+rsi-1000]); dump();
+mov (ecx, ptr[rdx+rsi*1+0]); dump();
+mov (ecx, ptr[rdx+rsi*1+1]); dump();
+mov (ecx, ptr[rdx+rsi*1+1000]); dump();
+mov (ecx, ptr[rdx+rsi*1-1]); dump();
+mov (ecx, ptr[rdx+rsi*1-1000]); dump();
+mov (ecx, ptr[rdx+rsi*2+0]); dump();
+mov (ecx, ptr[rdx+rsi*2+1]); dump();
+mov (ecx, ptr[rdx+rsi*2+1000]); dump();
+mov (ecx, ptr[rdx+rsi*2-1]); dump();
+mov (ecx, ptr[rdx+rsi*2-1000]); dump();
+mov (ecx, ptr[rdx+rsi*4+0]); dump();
+mov (ecx, ptr[rdx+rsi*4+1]); dump();
+mov (ecx, ptr[rdx+rsi*4+1000]); dump();
+mov (ecx, ptr[rdx+rsi*4-1]); dump();
+mov (ecx, ptr[rdx+rsi*4-1000]); dump();
+mov (ecx, ptr[rdx+rsi*8+0]); dump();
+mov (ecx, ptr[rdx+rsi*8+1]); dump();
+mov (ecx, ptr[rdx+rsi*8+1000]); dump();
+mov (ecx, ptr[rdx+rsi*8-1]); dump();
+mov (ecx, ptr[rdx+rsi*8-1000]); dump();
+}
+    void gen9(){
+mov (ecx, ptr[rdx+rdi+0]); dump();
+mov (ecx, ptr[rdx+rdi+1]); dump();
+mov (ecx, ptr[rdx+rdi+1000]); dump();
+mov (ecx, ptr[rdx+rdi-1]); dump();
+mov (ecx, ptr[rdx+rdi-1000]); dump();
+mov (ecx, ptr[rdx+rdi*1+0]); dump();
+mov (ecx, ptr[rdx+rdi*1+1]); dump();
+mov (ecx, ptr[rdx+rdi*1+1000]); dump();
+mov (ecx, ptr[rdx+rdi*1-1]); dump();
+mov (ecx, ptr[rdx+rdi*1-1000]); dump();
+mov (ecx, ptr[rdx+rdi*2+0]); dump();
+mov (ecx, ptr[rdx+rdi*2+1]); dump();
+mov (ecx, ptr[rdx+rdi*2+1000]); dump();
+mov (ecx, ptr[rdx+rdi*2-1]); dump();
+mov (ecx, ptr[rdx+rdi*2-1000]); dump();
+mov (ecx, ptr[rdx+rdi*4+0]); dump();
+mov (ecx, ptr[rdx+rdi*4+1]); dump();
+mov (ecx, ptr[rdx+rdi*4+1000]); dump();
+mov (ecx, ptr[rdx+rdi*4-1]); dump();
+mov (ecx, ptr[rdx+rdi*4-1000]); dump();
+mov (ecx, ptr[rdx+rdi*8+0]); dump();
+mov (ecx, ptr[rdx+rdi*8+1]); dump();
+mov (ecx, ptr[rdx+rdi*8+1000]); dump();
+mov (ecx, ptr[rdx+rdi*8-1]); dump();
+mov (ecx, ptr[rdx+rdi*8-1000]); dump();
+mov (ecx, ptr[rdx+r9+0]); dump();
+mov (ecx, ptr[rdx+r9+1]); dump();
+mov (ecx, ptr[rdx+r9+1000]); dump();
+mov (ecx, ptr[rdx+r9-1]); dump();
+mov (ecx, ptr[rdx+r9-1000]); dump();
+mov (ecx, ptr[rdx+r9*1+0]); dump();
+mov (ecx, ptr[rdx+r9*1+1]); dump();
+mov (ecx, ptr[rdx+r9*1+1000]); dump();
+mov (ecx, ptr[rdx+r9*1-1]); dump();
+mov (ecx, ptr[rdx+r9*1-1000]); dump();
+mov (ecx, ptr[rdx+r9*2+0]); dump();
+mov (ecx, ptr[rdx+r9*2+1]); dump();
+mov (ecx, ptr[rdx+r9*2+1000]); dump();
+mov (ecx, ptr[rdx+r9*2-1]); dump();
+mov (ecx, ptr[rdx+r9*2-1000]); dump();
+mov (ecx, ptr[rdx+r9*4+0]); dump();
+mov (ecx, ptr[rdx+r9*4+1]); dump();
+mov (ecx, ptr[rdx+r9*4+1000]); dump();
+mov (ecx, ptr[rdx+r9*4-1]); dump();
+mov (ecx, ptr[rdx+r9*4-1000]); dump();
+mov (ecx, ptr[rdx+r9*8+0]); dump();
+mov (ecx, ptr[rdx+r9*8+1]); dump();
+mov (ecx, ptr[rdx+r9*8+1000]); dump();
+mov (ecx, ptr[rdx+r9*8-1]); dump();
+mov (ecx, ptr[rdx+r9*8-1000]); dump();
+mov (ecx, ptr[rdx+r10+0]); dump();
+mov (ecx, ptr[rdx+r10+1]); dump();
+mov (ecx, ptr[rdx+r10+1000]); dump();
+mov (ecx, ptr[rdx+r10-1]); dump();
+mov (ecx, ptr[rdx+r10-1000]); dump();
+mov (ecx, ptr[rdx+r10*1+0]); dump();
+mov (ecx, ptr[rdx+r10*1+1]); dump();
+mov (ecx, ptr[rdx+r10*1+1000]); dump();
+mov (ecx, ptr[rdx+r10*1-1]); dump();
+mov (ecx, ptr[rdx+r10*1-1000]); dump();
+mov (ecx, ptr[rdx+r10*2+0]); dump();
+mov (ecx, ptr[rdx+r10*2+1]); dump();
+mov (ecx, ptr[rdx+r10*2+1000]); dump();
+mov (ecx, ptr[rdx+r10*2-1]); dump();
+mov (ecx, ptr[rdx+r10*2-1000]); dump();
+mov (ecx, ptr[rdx+r10*4+0]); dump();
+mov (ecx, ptr[rdx+r10*4+1]); dump();
+mov (ecx, ptr[rdx+r10*4+1000]); dump();
+mov (ecx, ptr[rdx+r10*4-1]); dump();
+mov (ecx, ptr[rdx+r10*4-1000]); dump();
+mov (ecx, ptr[rdx+r10*8+0]); dump();
+mov (ecx, ptr[rdx+r10*8+1]); dump();
+mov (ecx, ptr[rdx+r10*8+1000]); dump();
+mov (ecx, ptr[rdx+r10*8-1]); dump();
+mov (ecx, ptr[rdx+r10*8-1000]); dump();
+mov (ecx, ptr[rdx+r11+0]); dump();
+mov (ecx, ptr[rdx+r11+1]); dump();
+mov (ecx, ptr[rdx+r11+1000]); dump();
+mov (ecx, ptr[rdx+r11-1]); dump();
+mov (ecx, ptr[rdx+r11-1000]); dump();
+mov (ecx, ptr[rdx+r11*1+0]); dump();
+mov (ecx, ptr[rdx+r11*1+1]); dump();
+mov (ecx, ptr[rdx+r11*1+1000]); dump();
+mov (ecx, ptr[rdx+r11*1-1]); dump();
+mov (ecx, ptr[rdx+r11*1-1000]); dump();
+mov (ecx, ptr[rdx+r11*2+0]); dump();
+mov (ecx, ptr[rdx+r11*2+1]); dump();
+mov (ecx, ptr[rdx+r11*2+1000]); dump();
+mov (ecx, ptr[rdx+r11*2-1]); dump();
+mov (ecx, ptr[rdx+r11*2-1000]); dump();
+mov (ecx, ptr[rdx+r11*4+0]); dump();
+mov (ecx, ptr[rdx+r11*4+1]); dump();
+mov (ecx, ptr[rdx+r11*4+1000]); dump();
+mov (ecx, ptr[rdx+r11*4-1]); dump();
+mov (ecx, ptr[rdx+r11*4-1000]); dump();
+mov (ecx, ptr[rdx+r11*8+0]); dump();
+mov (ecx, ptr[rdx+r11*8+1]); dump();
+mov (ecx, ptr[rdx+r11*8+1000]); dump();
+mov (ecx, ptr[rdx+r11*8-1]); dump();
+mov (ecx, ptr[rdx+r11*8-1000]); dump();
+}
+    void gen10(){
+mov (ecx, ptr[rdx+r12+0]); dump();
+mov (ecx, ptr[rdx+r12+1]); dump();
+mov (ecx, ptr[rdx+r12+1000]); dump();
+mov (ecx, ptr[rdx+r12-1]); dump();
+mov (ecx, ptr[rdx+r12-1000]); dump();
+mov (ecx, ptr[rdx+r12*1+0]); dump();
+mov (ecx, ptr[rdx+r12*1+1]); dump();
+mov (ecx, ptr[rdx+r12*1+1000]); dump();
+mov (ecx, ptr[rdx+r12*1-1]); dump();
+mov (ecx, ptr[rdx+r12*1-1000]); dump();
+mov (ecx, ptr[rdx+r12*2+0]); dump();
+mov (ecx, ptr[rdx+r12*2+1]); dump();
+mov (ecx, ptr[rdx+r12*2+1000]); dump();
+mov (ecx, ptr[rdx+r12*2-1]); dump();
+mov (ecx, ptr[rdx+r12*2-1000]); dump();
+mov (ecx, ptr[rdx+r12*4+0]); dump();
+mov (ecx, ptr[rdx+r12*4+1]); dump();
+mov (ecx, ptr[rdx+r12*4+1000]); dump();
+mov (ecx, ptr[rdx+r12*4-1]); dump();
+mov (ecx, ptr[rdx+r12*4-1000]); dump();
+mov (ecx, ptr[rdx+r12*8+0]); dump();
+mov (ecx, ptr[rdx+r12*8+1]); dump();
+mov (ecx, ptr[rdx+r12*8+1000]); dump();
+mov (ecx, ptr[rdx+r12*8-1]); dump();
+mov (ecx, ptr[rdx+r12*8-1000]); dump();
+mov (ecx, ptr[rdx+r13+0]); dump();
+mov (ecx, ptr[rdx+r13+1]); dump();
+mov (ecx, ptr[rdx+r13+1000]); dump();
+mov (ecx, ptr[rdx+r13-1]); dump();
+mov (ecx, ptr[rdx+r13-1000]); dump();
+mov (ecx, ptr[rdx+r13*1+0]); dump();
+mov (ecx, ptr[rdx+r13*1+1]); dump();
+mov (ecx, ptr[rdx+r13*1+1000]); dump();
+mov (ecx, ptr[rdx+r13*1-1]); dump();
+mov (ecx, ptr[rdx+r13*1-1000]); dump();
+mov (ecx, ptr[rdx+r13*2+0]); dump();
+mov (ecx, ptr[rdx+r13*2+1]); dump();
+mov (ecx, ptr[rdx+r13*2+1000]); dump();
+mov (ecx, ptr[rdx+r13*2-1]); dump();
+mov (ecx, ptr[rdx+r13*2-1000]); dump();
+mov (ecx, ptr[rdx+r13*4+0]); dump();
+mov (ecx, ptr[rdx+r13*4+1]); dump();
+mov (ecx, ptr[rdx+r13*4+1000]); dump();
+mov (ecx, ptr[rdx+r13*4-1]); dump();
+mov (ecx, ptr[rdx+r13*4-1000]); dump();
+mov (ecx, ptr[rdx+r13*8+0]); dump();
+mov (ecx, ptr[rdx+r13*8+1]); dump();
+mov (ecx, ptr[rdx+r13*8+1000]); dump();
+mov (ecx, ptr[rdx+r13*8-1]); dump();
+mov (ecx, ptr[rdx+r13*8-1000]); dump();
+mov (ecx, ptr[rdx+r14+0]); dump();
+mov (ecx, ptr[rdx+r14+1]); dump();
+mov (ecx, ptr[rdx+r14+1000]); dump();
+mov (ecx, ptr[rdx+r14-1]); dump();
+mov (ecx, ptr[rdx+r14-1000]); dump();
+mov (ecx, ptr[rdx+r14*1+0]); dump();
+mov (ecx, ptr[rdx+r14*1+1]); dump();
+mov (ecx, ptr[rdx+r14*1+1000]); dump();
+mov (ecx, ptr[rdx+r14*1-1]); dump();
+mov (ecx, ptr[rdx+r14*1-1000]); dump();
+mov (ecx, ptr[rdx+r14*2+0]); dump();
+mov (ecx, ptr[rdx+r14*2+1]); dump();
+mov (ecx, ptr[rdx+r14*2+1000]); dump();
+mov (ecx, ptr[rdx+r14*2-1]); dump();
+mov (ecx, ptr[rdx+r14*2-1000]); dump();
+mov (ecx, ptr[rdx+r14*4+0]); dump();
+mov (ecx, ptr[rdx+r14*4+1]); dump();
+mov (ecx, ptr[rdx+r14*4+1000]); dump();
+mov (ecx, ptr[rdx+r14*4-1]); dump();
+mov (ecx, ptr[rdx+r14*4-1000]); dump();
+mov (ecx, ptr[rdx+r14*8+0]); dump();
+mov (ecx, ptr[rdx+r14*8+1]); dump();
+mov (ecx, ptr[rdx+r14*8+1000]); dump();
+mov (ecx, ptr[rdx+r14*8-1]); dump();
+mov (ecx, ptr[rdx+r14*8-1000]); dump();
+mov (ecx, ptr[rdx+r15+0]); dump();
+mov (ecx, ptr[rdx+r15+1]); dump();
+mov (ecx, ptr[rdx+r15+1000]); dump();
+mov (ecx, ptr[rdx+r15-1]); dump();
+mov (ecx, ptr[rdx+r15-1000]); dump();
+mov (ecx, ptr[rdx+r15*1+0]); dump();
+mov (ecx, ptr[rdx+r15*1+1]); dump();
+mov (ecx, ptr[rdx+r15*1+1000]); dump();
+mov (ecx, ptr[rdx+r15*1-1]); dump();
+mov (ecx, ptr[rdx+r15*1-1000]); dump();
+mov (ecx, ptr[rdx+r15*2+0]); dump();
+mov (ecx, ptr[rdx+r15*2+1]); dump();
+mov (ecx, ptr[rdx+r15*2+1000]); dump();
+mov (ecx, ptr[rdx+r15*2-1]); dump();
+mov (ecx, ptr[rdx+r15*2-1000]); dump();
+mov (ecx, ptr[rdx+r15*4+0]); dump();
+mov (ecx, ptr[rdx+r15*4+1]); dump();
+mov (ecx, ptr[rdx+r15*4+1000]); dump();
+mov (ecx, ptr[rdx+r15*4-1]); dump();
+mov (ecx, ptr[rdx+r15*4-1000]); dump();
+mov (ecx, ptr[rdx+r15*8+0]); dump();
+mov (ecx, ptr[rdx+r15*8+1]); dump();
+mov (ecx, ptr[rdx+r15*8+1000]); dump();
+mov (ecx, ptr[rdx+r15*8-1]); dump();
+mov (ecx, ptr[rdx+r15*8-1000]); dump();
+}
+    void gen11(){
+mov (ecx, ptr[rdx+0]); dump();
+mov (ecx, ptr[rdx+1]); dump();
+mov (ecx, ptr[rdx+1000]); dump();
+mov (ecx, ptr[rdx-1]); dump();
+mov (ecx, ptr[rdx-1000]); dump();
+mov (ecx, ptr[rdx+0]); dump();
+mov (ecx, ptr[rdx+1]); dump();
+mov (ecx, ptr[rdx+1000]); dump();
+mov (ecx, ptr[rdx-1]); dump();
+mov (ecx, ptr[rdx-1000]); dump();
+mov (ecx, ptr[rdx+0]); dump();
+mov (ecx, ptr[rdx+1]); dump();
+mov (ecx, ptr[rdx+1000]); dump();
+mov (ecx, ptr[rdx-1]); dump();
+mov (ecx, ptr[rdx-1000]); dump();
+mov (ecx, ptr[rdx+0]); dump();
+mov (ecx, ptr[rdx+1]); dump();
+mov (ecx, ptr[rdx+1000]); dump();
+mov (ecx, ptr[rdx-1]); dump();
+mov (ecx, ptr[rdx-1000]); dump();
+mov (ecx, ptr[rdx+0]); dump();
+mov (ecx, ptr[rdx+1]); dump();
+mov (ecx, ptr[rdx+1000]); dump();
+mov (ecx, ptr[rdx-1]); dump();
+mov (ecx, ptr[rdx-1000]); dump();
+mov (ecx, ptr[rbx+rax+0]); dump();
+mov (ecx, ptr[rbx+rax+1]); dump();
+mov (ecx, ptr[rbx+rax+1000]); dump();
+mov (ecx, ptr[rbx+rax-1]); dump();
+mov (ecx, ptr[rbx+rax-1000]); dump();
+mov (ecx, ptr[rbx+rax*1+0]); dump();
+mov (ecx, ptr[rbx+rax*1+1]); dump();
+mov (ecx, ptr[rbx+rax*1+1000]); dump();
+mov (ecx, ptr[rbx+rax*1-1]); dump();
+mov (ecx, ptr[rbx+rax*1-1000]); dump();
+mov (ecx, ptr[rbx+rax*2+0]); dump();
+mov (ecx, ptr[rbx+rax*2+1]); dump();
+mov (ecx, ptr[rbx+rax*2+1000]); dump();
+mov (ecx, ptr[rbx+rax*2-1]); dump();
+mov (ecx, ptr[rbx+rax*2-1000]); dump();
+mov (ecx, ptr[rbx+rax*4+0]); dump();
+mov (ecx, ptr[rbx+rax*4+1]); dump();
+mov (ecx, ptr[rbx+rax*4+1000]); dump();
+mov (ecx, ptr[rbx+rax*4-1]); dump();
+mov (ecx, ptr[rbx+rax*4-1000]); dump();
+mov (ecx, ptr[rbx+rax*8+0]); dump();
+mov (ecx, ptr[rbx+rax*8+1]); dump();
+mov (ecx, ptr[rbx+rax*8+1000]); dump();
+mov (ecx, ptr[rbx+rax*8-1]); dump();
+mov (ecx, ptr[rbx+rax*8-1000]); dump();
+mov (ecx, ptr[rbx+rcx+0]); dump();
+mov (ecx, ptr[rbx+rcx+1]); dump();
+mov (ecx, ptr[rbx+rcx+1000]); dump();
+mov (ecx, ptr[rbx+rcx-1]); dump();
+mov (ecx, ptr[rbx+rcx-1000]); dump();
+mov (ecx, ptr[rbx+rcx*1+0]); dump();
+mov (ecx, ptr[rbx+rcx*1+1]); dump();
+mov (ecx, ptr[rbx+rcx*1+1000]); dump();
+mov (ecx, ptr[rbx+rcx*1-1]); dump();
+mov (ecx, ptr[rbx+rcx*1-1000]); dump();
+mov (ecx, ptr[rbx+rcx*2+0]); dump();
+mov (ecx, ptr[rbx+rcx*2+1]); dump();
+mov (ecx, ptr[rbx+rcx*2+1000]); dump();
+mov (ecx, ptr[rbx+rcx*2-1]); dump();
+mov (ecx, ptr[rbx+rcx*2-1000]); dump();
+mov (ecx, ptr[rbx+rcx*4+0]); dump();
+mov (ecx, ptr[rbx+rcx*4+1]); dump();
+mov (ecx, ptr[rbx+rcx*4+1000]); dump();
+mov (ecx, ptr[rbx+rcx*4-1]); dump();
+mov (ecx, ptr[rbx+rcx*4-1000]); dump();
+mov (ecx, ptr[rbx+rcx*8+0]); dump();
+mov (ecx, ptr[rbx+rcx*8+1]); dump();
+mov (ecx, ptr[rbx+rcx*8+1000]); dump();
+mov (ecx, ptr[rbx+rcx*8-1]); dump();
+mov (ecx, ptr[rbx+rcx*8-1000]); dump();
+mov (ecx, ptr[rbx+rdx+0]); dump();
+mov (ecx, ptr[rbx+rdx+1]); dump();
+mov (ecx, ptr[rbx+rdx+1000]); dump();
+mov (ecx, ptr[rbx+rdx-1]); dump();
+mov (ecx, ptr[rbx+rdx-1000]); dump();
+mov (ecx, ptr[rbx+rdx*1+0]); dump();
+mov (ecx, ptr[rbx+rdx*1+1]); dump();
+mov (ecx, ptr[rbx+rdx*1+1000]); dump();
+mov (ecx, ptr[rbx+rdx*1-1]); dump();
+mov (ecx, ptr[rbx+rdx*1-1000]); dump();
+mov (ecx, ptr[rbx+rdx*2+0]); dump();
+mov (ecx, ptr[rbx+rdx*2+1]); dump();
+mov (ecx, ptr[rbx+rdx*2+1000]); dump();
+mov (ecx, ptr[rbx+rdx*2-1]); dump();
+mov (ecx, ptr[rbx+rdx*2-1000]); dump();
+mov (ecx, ptr[rbx+rdx*4+0]); dump();
+mov (ecx, ptr[rbx+rdx*4+1]); dump();
+mov (ecx, ptr[rbx+rdx*4+1000]); dump();
+mov (ecx, ptr[rbx+rdx*4-1]); dump();
+mov (ecx, ptr[rbx+rdx*4-1000]); dump();
+mov (ecx, ptr[rbx+rdx*8+0]); dump();
+mov (ecx, ptr[rbx+rdx*8+1]); dump();
+mov (ecx, ptr[rbx+rdx*8+1000]); dump();
+mov (ecx, ptr[rbx+rdx*8-1]); dump();
+mov (ecx, ptr[rbx+rdx*8-1000]); dump();
+}
+    void gen12(){
+mov (ecx, ptr[rbx+rbx+0]); dump();
+mov (ecx, ptr[rbx+rbx+1]); dump();
+mov (ecx, ptr[rbx+rbx+1000]); dump();
+mov (ecx, ptr[rbx+rbx-1]); dump();
+mov (ecx, ptr[rbx+rbx-1000]); dump();
+mov (ecx, ptr[rbx+rbx*1+0]); dump();
+mov (ecx, ptr[rbx+rbx*1+1]); dump();
+mov (ecx, ptr[rbx+rbx*1+1000]); dump();
+mov (ecx, ptr[rbx+rbx*1-1]); dump();
+mov (ecx, ptr[rbx+rbx*1-1000]); dump();
+mov (ecx, ptr[rbx+rbx*2+0]); dump();
+mov (ecx, ptr[rbx+rbx*2+1]); dump();
+mov (ecx, ptr[rbx+rbx*2+1000]); dump();
+mov (ecx, ptr[rbx+rbx*2-1]); dump();
+mov (ecx, ptr[rbx+rbx*2-1000]); dump();
+mov (ecx, ptr[rbx+rbx*4+0]); dump();
+mov (ecx, ptr[rbx+rbx*4+1]); dump();
+mov (ecx, ptr[rbx+rbx*4+1000]); dump();
+mov (ecx, ptr[rbx+rbx*4-1]); dump();
+mov (ecx, ptr[rbx+rbx*4-1000]); dump();
+mov (ecx, ptr[rbx+rbx*8+0]); dump();
+mov (ecx, ptr[rbx+rbx*8+1]); dump();
+mov (ecx, ptr[rbx+rbx*8+1000]); dump();
+mov (ecx, ptr[rbx+rbx*8-1]); dump();
+mov (ecx, ptr[rbx+rbx*8-1000]); dump();
+mov (ecx, ptr[rbx+rbp+0]); dump();
+mov (ecx, ptr[rbx+rbp+1]); dump();
+mov (ecx, ptr[rbx+rbp+1000]); dump();
+mov (ecx, ptr[rbx+rbp-1]); dump();
+mov (ecx, ptr[rbx+rbp-1000]); dump();
+mov (ecx, ptr[rbx+rbp*1+0]); dump();
+mov (ecx, ptr[rbx+rbp*1+1]); dump();
+mov (ecx, ptr[rbx+rbp*1+1000]); dump();
+mov (ecx, ptr[rbx+rbp*1-1]); dump();
+mov (ecx, ptr[rbx+rbp*1-1000]); dump();
+mov (ecx, ptr[rbx+rbp*2+0]); dump();
+mov (ecx, ptr[rbx+rbp*2+1]); dump();
+mov (ecx, ptr[rbx+rbp*2+1000]); dump();
+mov (ecx, ptr[rbx+rbp*2-1]); dump();
+mov (ecx, ptr[rbx+rbp*2-1000]); dump();
+mov (ecx, ptr[rbx+rbp*4+0]); dump();
+mov (ecx, ptr[rbx+rbp*4+1]); dump();
+mov (ecx, ptr[rbx+rbp*4+1000]); dump();
+mov (ecx, ptr[rbx+rbp*4-1]); dump();
+mov (ecx, ptr[rbx+rbp*4-1000]); dump();
+mov (ecx, ptr[rbx+rbp*8+0]); dump();
+mov (ecx, ptr[rbx+rbp*8+1]); dump();
+mov (ecx, ptr[rbx+rbp*8+1000]); dump();
+mov (ecx, ptr[rbx+rbp*8-1]); dump();
+mov (ecx, ptr[rbx+rbp*8-1000]); dump();
+mov (ecx, ptr[rbx+rsi+0]); dump();
+mov (ecx, ptr[rbx+rsi+1]); dump();
+mov (ecx, ptr[rbx+rsi+1000]); dump();
+mov (ecx, ptr[rbx+rsi-1]); dump();
+mov (ecx, ptr[rbx+rsi-1000]); dump();
+mov (ecx, ptr[rbx+rsi*1+0]); dump();
+mov (ecx, ptr[rbx+rsi*1+1]); dump();
+mov (ecx, ptr[rbx+rsi*1+1000]); dump();
+mov (ecx, ptr[rbx+rsi*1-1]); dump();
+mov (ecx, ptr[rbx+rsi*1-1000]); dump();
+mov (ecx, ptr[rbx+rsi*2+0]); dump();
+mov (ecx, ptr[rbx+rsi*2+1]); dump();
+mov (ecx, ptr[rbx+rsi*2+1000]); dump();
+mov (ecx, ptr[rbx+rsi*2-1]); dump();
+mov (ecx, ptr[rbx+rsi*2-1000]); dump();
+mov (ecx, ptr[rbx+rsi*4+0]); dump();
+mov (ecx, ptr[rbx+rsi*4+1]); dump();
+mov (ecx, ptr[rbx+rsi*4+1000]); dump();
+mov (ecx, ptr[rbx+rsi*4-1]); dump();
+mov (ecx, ptr[rbx+rsi*4-1000]); dump();
+mov (ecx, ptr[rbx+rsi*8+0]); dump();
+mov (ecx, ptr[rbx+rsi*8+1]); dump();
+mov (ecx, ptr[rbx+rsi*8+1000]); dump();
+mov (ecx, ptr[rbx+rsi*8-1]); dump();
+mov (ecx, ptr[rbx+rsi*8-1000]); dump();
+mov (ecx, ptr[rbx+rdi+0]); dump();
+mov (ecx, ptr[rbx+rdi+1]); dump();
+mov (ecx, ptr[rbx+rdi+1000]); dump();
+mov (ecx, ptr[rbx+rdi-1]); dump();
+mov (ecx, ptr[rbx+rdi-1000]); dump();
+mov (ecx, ptr[rbx+rdi*1+0]); dump();
+mov (ecx, ptr[rbx+rdi*1+1]); dump();
+mov (ecx, ptr[rbx+rdi*1+1000]); dump();
+mov (ecx, ptr[rbx+rdi*1-1]); dump();
+mov (ecx, ptr[rbx+rdi*1-1000]); dump();
+mov (ecx, ptr[rbx+rdi*2+0]); dump();
+mov (ecx, ptr[rbx+rdi*2+1]); dump();
+mov (ecx, ptr[rbx+rdi*2+1000]); dump();
+mov (ecx, ptr[rbx+rdi*2-1]); dump();
+mov (ecx, ptr[rbx+rdi*2-1000]); dump();
+mov (ecx, ptr[rbx+rdi*4+0]); dump();
+mov (ecx, ptr[rbx+rdi*4+1]); dump();
+mov (ecx, ptr[rbx+rdi*4+1000]); dump();
+mov (ecx, ptr[rbx+rdi*4-1]); dump();
+mov (ecx, ptr[rbx+rdi*4-1000]); dump();
+mov (ecx, ptr[rbx+rdi*8+0]); dump();
+mov (ecx, ptr[rbx+rdi*8+1]); dump();
+mov (ecx, ptr[rbx+rdi*8+1000]); dump();
+mov (ecx, ptr[rbx+rdi*8-1]); dump();
+mov (ecx, ptr[rbx+rdi*8-1000]); dump();
+}
+    void gen13(){
+mov (ecx, ptr[rbx+r9+0]); dump();
+mov (ecx, ptr[rbx+r9+1]); dump();
+mov (ecx, ptr[rbx+r9+1000]); dump();
+mov (ecx, ptr[rbx+r9-1]); dump();
+mov (ecx, ptr[rbx+r9-1000]); dump();
+mov (ecx, ptr[rbx+r9*1+0]); dump();
+mov (ecx, ptr[rbx+r9*1+1]); dump();
+mov (ecx, ptr[rbx+r9*1+1000]); dump();
+mov (ecx, ptr[rbx+r9*1-1]); dump();
+mov (ecx, ptr[rbx+r9*1-1000]); dump();
+mov (ecx, ptr[rbx+r9*2+0]); dump();
+mov (ecx, ptr[rbx+r9*2+1]); dump();
+mov (ecx, ptr[rbx+r9*2+1000]); dump();
+mov (ecx, ptr[rbx+r9*2-1]); dump();
+mov (ecx, ptr[rbx+r9*2-1000]); dump();
+mov (ecx, ptr[rbx+r9*4+0]); dump();
+mov (ecx, ptr[rbx+r9*4+1]); dump();
+mov (ecx, ptr[rbx+r9*4+1000]); dump();
+mov (ecx, ptr[rbx+r9*4-1]); dump();
+mov (ecx, ptr[rbx+r9*4-1000]); dump();
+mov (ecx, ptr[rbx+r9*8+0]); dump();
+mov (ecx, ptr[rbx+r9*8+1]); dump();
+mov (ecx, ptr[rbx+r9*8+1000]); dump();
+mov (ecx, ptr[rbx+r9*8-1]); dump();
+mov (ecx, ptr[rbx+r9*8-1000]); dump();
+mov (ecx, ptr[rbx+r10+0]); dump();
+mov (ecx, ptr[rbx+r10+1]); dump();
+mov (ecx, ptr[rbx+r10+1000]); dump();
+mov (ecx, ptr[rbx+r10-1]); dump();
+mov (ecx, ptr[rbx+r10-1000]); dump();
+mov (ecx, ptr[rbx+r10*1+0]); dump();
+mov (ecx, ptr[rbx+r10*1+1]); dump();
+mov (ecx, ptr[rbx+r10*1+1000]); dump();
+mov (ecx, ptr[rbx+r10*1-1]); dump();
+mov (ecx, ptr[rbx+r10*1-1000]); dump();
+mov (ecx, ptr[rbx+r10*2+0]); dump();
+mov (ecx, ptr[rbx+r10*2+1]); dump();
+mov (ecx, ptr[rbx+r10*2+1000]); dump();
+mov (ecx, ptr[rbx+r10*2-1]); dump();
+mov (ecx, ptr[rbx+r10*2-1000]); dump();
+mov (ecx, ptr[rbx+r10*4+0]); dump();
+mov (ecx, ptr[rbx+r10*4+1]); dump();
+mov (ecx, ptr[rbx+r10*4+1000]); dump();
+mov (ecx, ptr[rbx+r10*4-1]); dump();
+mov (ecx, ptr[rbx+r10*4-1000]); dump();
+mov (ecx, ptr[rbx+r10*8+0]); dump();
+mov (ecx, ptr[rbx+r10*8+1]); dump();
+mov (ecx, ptr[rbx+r10*8+1000]); dump();
+mov (ecx, ptr[rbx+r10*8-1]); dump();
+mov (ecx, ptr[rbx+r10*8-1000]); dump();
+mov (ecx, ptr[rbx+r11+0]); dump();
+mov (ecx, ptr[rbx+r11+1]); dump();
+mov (ecx, ptr[rbx+r11+1000]); dump();
+mov (ecx, ptr[rbx+r11-1]); dump();
+mov (ecx, ptr[rbx+r11-1000]); dump();
+mov (ecx, ptr[rbx+r11*1+0]); dump();
+mov (ecx, ptr[rbx+r11*1+1]); dump();
+mov (ecx, ptr[rbx+r11*1+1000]); dump();
+mov (ecx, ptr[rbx+r11*1-1]); dump();
+mov (ecx, ptr[rbx+r11*1-1000]); dump();
+mov (ecx, ptr[rbx+r11*2+0]); dump();
+mov (ecx, ptr[rbx+r11*2+1]); dump();
+mov (ecx, ptr[rbx+r11*2+1000]); dump();
+mov (ecx, ptr[rbx+r11*2-1]); dump();
+mov (ecx, ptr[rbx+r11*2-1000]); dump();
+mov (ecx, ptr[rbx+r11*4+0]); dump();
+mov (ecx, ptr[rbx+r11*4+1]); dump();
+mov (ecx, ptr[rbx+r11*4+1000]); dump();
+mov (ecx, ptr[rbx+r11*4-1]); dump();
+mov (ecx, ptr[rbx+r11*4-1000]); dump();
+mov (ecx, ptr[rbx+r11*8+0]); dump();
+mov (ecx, ptr[rbx+r11*8+1]); dump();
+mov (ecx, ptr[rbx+r11*8+1000]); dump();
+mov (ecx, ptr[rbx+r11*8-1]); dump();
+mov (ecx, ptr[rbx+r11*8-1000]); dump();
+mov (ecx, ptr[rbx+r12+0]); dump();
+mov (ecx, ptr[rbx+r12+1]); dump();
+mov (ecx, ptr[rbx+r12+1000]); dump();
+mov (ecx, ptr[rbx+r12-1]); dump();
+mov (ecx, ptr[rbx+r12-1000]); dump();
+mov (ecx, ptr[rbx+r12*1+0]); dump();
+mov (ecx, ptr[rbx+r12*1+1]); dump();
+mov (ecx, ptr[rbx+r12*1+1000]); dump();
+mov (ecx, ptr[rbx+r12*1-1]); dump();
+mov (ecx, ptr[rbx+r12*1-1000]); dump();
+mov (ecx, ptr[rbx+r12*2+0]); dump();
+mov (ecx, ptr[rbx+r12*2+1]); dump();
+mov (ecx, ptr[rbx+r12*2+1000]); dump();
+mov (ecx, ptr[rbx+r12*2-1]); dump();
+mov (ecx, ptr[rbx+r12*2-1000]); dump();
+mov (ecx, ptr[rbx+r12*4+0]); dump();
+mov (ecx, ptr[rbx+r12*4+1]); dump();
+mov (ecx, ptr[rbx+r12*4+1000]); dump();
+mov (ecx, ptr[rbx+r12*4-1]); dump();
+mov (ecx, ptr[rbx+r12*4-1000]); dump();
+mov (ecx, ptr[rbx+r12*8+0]); dump();
+mov (ecx, ptr[rbx+r12*8+1]); dump();
+mov (ecx, ptr[rbx+r12*8+1000]); dump();
+mov (ecx, ptr[rbx+r12*8-1]); dump();
+mov (ecx, ptr[rbx+r12*8-1000]); dump();
+}
+    void gen14(){
+mov (ecx, ptr[rbx+r13+0]); dump();
+mov (ecx, ptr[rbx+r13+1]); dump();
+mov (ecx, ptr[rbx+r13+1000]); dump();
+mov (ecx, ptr[rbx+r13-1]); dump();
+mov (ecx, ptr[rbx+r13-1000]); dump();
+mov (ecx, ptr[rbx+r13*1+0]); dump();
+mov (ecx, ptr[rbx+r13*1+1]); dump();
+mov (ecx, ptr[rbx+r13*1+1000]); dump();
+mov (ecx, ptr[rbx+r13*1-1]); dump();
+mov (ecx, ptr[rbx+r13*1-1000]); dump();
+mov (ecx, ptr[rbx+r13*2+0]); dump();
+mov (ecx, ptr[rbx+r13*2+1]); dump();
+mov (ecx, ptr[rbx+r13*2+1000]); dump();
+mov (ecx, ptr[rbx+r13*2-1]); dump();
+mov (ecx, ptr[rbx+r13*2-1000]); dump();
+mov (ecx, ptr[rbx+r13*4+0]); dump();
+mov (ecx, ptr[rbx+r13*4+1]); dump();
+mov (ecx, ptr[rbx+r13*4+1000]); dump();
+mov (ecx, ptr[rbx+r13*4-1]); dump();
+mov (ecx, ptr[rbx+r13*4-1000]); dump();
+mov (ecx, ptr[rbx+r13*8+0]); dump();
+mov (ecx, ptr[rbx+r13*8+1]); dump();
+mov (ecx, ptr[rbx+r13*8+1000]); dump();
+mov (ecx, ptr[rbx+r13*8-1]); dump();
+mov (ecx, ptr[rbx+r13*8-1000]); dump();
+mov (ecx, ptr[rbx+r14+0]); dump();
+mov (ecx, ptr[rbx+r14+1]); dump();
+mov (ecx, ptr[rbx+r14+1000]); dump();
+mov (ecx, ptr[rbx+r14-1]); dump();
+mov (ecx, ptr[rbx+r14-1000]); dump();
+mov (ecx, ptr[rbx+r14*1+0]); dump();
+mov (ecx, ptr[rbx+r14*1+1]); dump();
+mov (ecx, ptr[rbx+r14*1+1000]); dump();
+mov (ecx, ptr[rbx+r14*1-1]); dump();
+mov (ecx, ptr[rbx+r14*1-1000]); dump();
+mov (ecx, ptr[rbx+r14*2+0]); dump();
+mov (ecx, ptr[rbx+r14*2+1]); dump();
+mov (ecx, ptr[rbx+r14*2+1000]); dump();
+mov (ecx, ptr[rbx+r14*2-1]); dump();
+mov (ecx, ptr[rbx+r14*2-1000]); dump();
+mov (ecx, ptr[rbx+r14*4+0]); dump();
+mov (ecx, ptr[rbx+r14*4+1]); dump();
+mov (ecx, ptr[rbx+r14*4+1000]); dump();
+mov (ecx, ptr[rbx+r14*4-1]); dump();
+mov (ecx, ptr[rbx+r14*4-1000]); dump();
+mov (ecx, ptr[rbx+r14*8+0]); dump();
+mov (ecx, ptr[rbx+r14*8+1]); dump();
+mov (ecx, ptr[rbx+r14*8+1000]); dump();
+mov (ecx, ptr[rbx+r14*8-1]); dump();
+mov (ecx, ptr[rbx+r14*8-1000]); dump();
+mov (ecx, ptr[rbx+r15+0]); dump();
+mov (ecx, ptr[rbx+r15+1]); dump();
+mov (ecx, ptr[rbx+r15+1000]); dump();
+mov (ecx, ptr[rbx+r15-1]); dump();
+mov (ecx, ptr[rbx+r15-1000]); dump();
+mov (ecx, ptr[rbx+r15*1+0]); dump();
+mov (ecx, ptr[rbx+r15*1+1]); dump();
+mov (ecx, ptr[rbx+r15*1+1000]); dump();
+mov (ecx, ptr[rbx+r15*1-1]); dump();
+mov (ecx, ptr[rbx+r15*1-1000]); dump();
+mov (ecx, ptr[rbx+r15*2+0]); dump();
+mov (ecx, ptr[rbx+r15*2+1]); dump();
+mov (ecx, ptr[rbx+r15*2+1000]); dump();
+mov (ecx, ptr[rbx+r15*2-1]); dump();
+mov (ecx, ptr[rbx+r15*2-1000]); dump();
+mov (ecx, ptr[rbx+r15*4+0]); dump();
+mov (ecx, ptr[rbx+r15*4+1]); dump();
+mov (ecx, ptr[rbx+r15*4+1000]); dump();
+mov (ecx, ptr[rbx+r15*4-1]); dump();
+mov (ecx, ptr[rbx+r15*4-1000]); dump();
+mov (ecx, ptr[rbx+r15*8+0]); dump();
+mov (ecx, ptr[rbx+r15*8+1]); dump();
+mov (ecx, ptr[rbx+r15*8+1000]); dump();
+mov (ecx, ptr[rbx+r15*8-1]); dump();
+mov (ecx, ptr[rbx+r15*8-1000]); dump();
+mov (ecx, ptr[rbx+0]); dump();
+mov (ecx, ptr[rbx+1]); dump();
+mov (ecx, ptr[rbx+1000]); dump();
+mov (ecx, ptr[rbx-1]); dump();
+mov (ecx, ptr[rbx-1000]); dump();
+mov (ecx, ptr[rbx+0]); dump();
+mov (ecx, ptr[rbx+1]); dump();
+mov (ecx, ptr[rbx+1000]); dump();
+mov (ecx, ptr[rbx-1]); dump();
+mov (ecx, ptr[rbx-1000]); dump();
+mov (ecx, ptr[rbx+0]); dump();
+mov (ecx, ptr[rbx+1]); dump();
+mov (ecx, ptr[rbx+1000]); dump();
+mov (ecx, ptr[rbx-1]); dump();
+mov (ecx, ptr[rbx-1000]); dump();
+mov (ecx, ptr[rbx+0]); dump();
+mov (ecx, ptr[rbx+1]); dump();
+mov (ecx, ptr[rbx+1000]); dump();
+mov (ecx, ptr[rbx-1]); dump();
+mov (ecx, ptr[rbx-1000]); dump();
+mov (ecx, ptr[rbx+0]); dump();
+mov (ecx, ptr[rbx+1]); dump();
+mov (ecx, ptr[rbx+1000]); dump();
+mov (ecx, ptr[rbx-1]); dump();
+mov (ecx, ptr[rbx-1000]); dump();
+}
+    void gen15(){
+mov (ecx, ptr[rsp+rax+0]); dump();
+mov (ecx, ptr[rsp+rax+1]); dump();
+mov (ecx, ptr[rsp+rax+1000]); dump();
+mov (ecx, ptr[rsp+rax-1]); dump();
+mov (ecx, ptr[rsp+rax-1000]); dump();
+mov (ecx, ptr[rsp+rax*1+0]); dump();
+mov (ecx, ptr[rsp+rax*1+1]); dump();
+mov (ecx, ptr[rsp+rax*1+1000]); dump();
+mov (ecx, ptr[rsp+rax*1-1]); dump();
+mov (ecx, ptr[rsp+rax*1-1000]); dump();
+mov (ecx, ptr[rsp+rax*2+0]); dump();
+mov (ecx, ptr[rsp+rax*2+1]); dump();
+mov (ecx, ptr[rsp+rax*2+1000]); dump();
+mov (ecx, ptr[rsp+rax*2-1]); dump();
+mov (ecx, ptr[rsp+rax*2-1000]); dump();
+mov (ecx, ptr[rsp+rax*4+0]); dump();
+mov (ecx, ptr[rsp+rax*4+1]); dump();
+mov (ecx, ptr[rsp+rax*4+1000]); dump();
+mov (ecx, ptr[rsp+rax*4-1]); dump();
+mov (ecx, ptr[rsp+rax*4-1000]); dump();
+mov (ecx, ptr[rsp+rax*8+0]); dump();
+mov (ecx, ptr[rsp+rax*8+1]); dump();
+mov (ecx, ptr[rsp+rax*8+1000]); dump();
+mov (ecx, ptr[rsp+rax*8-1]); dump();
+mov (ecx, ptr[rsp+rax*8-1000]); dump();
+mov (ecx, ptr[rsp+rcx+0]); dump();
+mov (ecx, ptr[rsp+rcx+1]); dump();
+mov (ecx, ptr[rsp+rcx+1000]); dump();
+mov (ecx, ptr[rsp+rcx-1]); dump();
+mov (ecx, ptr[rsp+rcx-1000]); dump();
+mov (ecx, ptr[rsp+rcx*1+0]); dump();
+mov (ecx, ptr[rsp+rcx*1+1]); dump();
+mov (ecx, ptr[rsp+rcx*1+1000]); dump();
+mov (ecx, ptr[rsp+rcx*1-1]); dump();
+mov (ecx, ptr[rsp+rcx*1-1000]); dump();
+mov (ecx, ptr[rsp+rcx*2+0]); dump();
+mov (ecx, ptr[rsp+rcx*2+1]); dump();
+mov (ecx, ptr[rsp+rcx*2+1000]); dump();
+mov (ecx, ptr[rsp+rcx*2-1]); dump();
+mov (ecx, ptr[rsp+rcx*2-1000]); dump();
+mov (ecx, ptr[rsp+rcx*4+0]); dump();
+mov (ecx, ptr[rsp+rcx*4+1]); dump();
+mov (ecx, ptr[rsp+rcx*4+1000]); dump();
+mov (ecx, ptr[rsp+rcx*4-1]); dump();
+mov (ecx, ptr[rsp+rcx*4-1000]); dump();
+mov (ecx, ptr[rsp+rcx*8+0]); dump();
+mov (ecx, ptr[rsp+rcx*8+1]); dump();
+mov (ecx, ptr[rsp+rcx*8+1000]); dump();
+mov (ecx, ptr[rsp+rcx*8-1]); dump();
+mov (ecx, ptr[rsp+rcx*8-1000]); dump();
+mov (ecx, ptr[rsp+rdx+0]); dump();
+mov (ecx, ptr[rsp+rdx+1]); dump();
+mov (ecx, ptr[rsp+rdx+1000]); dump();
+mov (ecx, ptr[rsp+rdx-1]); dump();
+mov (ecx, ptr[rsp+rdx-1000]); dump();
+mov (ecx, ptr[rsp+rdx*1+0]); dump();
+mov (ecx, ptr[rsp+rdx*1+1]); dump();
+mov (ecx, ptr[rsp+rdx*1+1000]); dump();
+mov (ecx, ptr[rsp+rdx*1-1]); dump();
+mov (ecx, ptr[rsp+rdx*1-1000]); dump();
+mov (ecx, ptr[rsp+rdx*2+0]); dump();
+mov (ecx, ptr[rsp+rdx*2+1]); dump();
+mov (ecx, ptr[rsp+rdx*2+1000]); dump();
+mov (ecx, ptr[rsp+rdx*2-1]); dump();
+mov (ecx, ptr[rsp+rdx*2-1000]); dump();
+mov (ecx, ptr[rsp+rdx*4+0]); dump();
+mov (ecx, ptr[rsp+rdx*4+1]); dump();
+mov (ecx, ptr[rsp+rdx*4+1000]); dump();
+mov (ecx, ptr[rsp+rdx*4-1]); dump();
+mov (ecx, ptr[rsp+rdx*4-1000]); dump();
+mov (ecx, ptr[rsp+rdx*8+0]); dump();
+mov (ecx, ptr[rsp+rdx*8+1]); dump();
+mov (ecx, ptr[rsp+rdx*8+1000]); dump();
+mov (ecx, ptr[rsp+rdx*8-1]); dump();
+mov (ecx, ptr[rsp+rdx*8-1000]); dump();
+mov (ecx, ptr[rsp+rbx+0]); dump();
+mov (ecx, ptr[rsp+rbx+1]); dump();
+mov (ecx, ptr[rsp+rbx+1000]); dump();
+mov (ecx, ptr[rsp+rbx-1]); dump();
+mov (ecx, ptr[rsp+rbx-1000]); dump();
+mov (ecx, ptr[rsp+rbx*1+0]); dump();
+mov (ecx, ptr[rsp+rbx*1+1]); dump();
+mov (ecx, ptr[rsp+rbx*1+1000]); dump();
+mov (ecx, ptr[rsp+rbx*1-1]); dump();
+mov (ecx, ptr[rsp+rbx*1-1000]); dump();
+mov (ecx, ptr[rsp+rbx*2+0]); dump();
+mov (ecx, ptr[rsp+rbx*2+1]); dump();
+mov (ecx, ptr[rsp+rbx*2+1000]); dump();
+mov (ecx, ptr[rsp+rbx*2-1]); dump();
+mov (ecx, ptr[rsp+rbx*2-1000]); dump();
+mov (ecx, ptr[rsp+rbx*4+0]); dump();
+mov (ecx, ptr[rsp+rbx*4+1]); dump();
+mov (ecx, ptr[rsp+rbx*4+1000]); dump();
+mov (ecx, ptr[rsp+rbx*4-1]); dump();
+mov (ecx, ptr[rsp+rbx*4-1000]); dump();
+mov (ecx, ptr[rsp+rbx*8+0]); dump();
+mov (ecx, ptr[rsp+rbx*8+1]); dump();
+mov (ecx, ptr[rsp+rbx*8+1000]); dump();
+mov (ecx, ptr[rsp+rbx*8-1]); dump();
+mov (ecx, ptr[rsp+rbx*8-1000]); dump();
+}
+    void gen16(){
+mov (ecx, ptr[rsp+rbp+0]); dump();
+mov (ecx, ptr[rsp+rbp+1]); dump();
+mov (ecx, ptr[rsp+rbp+1000]); dump();
+mov (ecx, ptr[rsp+rbp-1]); dump();
+mov (ecx, ptr[rsp+rbp-1000]); dump();
+mov (ecx, ptr[rsp+rbp*1+0]); dump();
+mov (ecx, ptr[rsp+rbp*1+1]); dump();
+mov (ecx, ptr[rsp+rbp*1+1000]); dump();
+mov (ecx, ptr[rsp+rbp*1-1]); dump();
+mov (ecx, ptr[rsp+rbp*1-1000]); dump();
+mov (ecx, ptr[rsp+rbp*2+0]); dump();
+mov (ecx, ptr[rsp+rbp*2+1]); dump();
+mov (ecx, ptr[rsp+rbp*2+1000]); dump();
+mov (ecx, ptr[rsp+rbp*2-1]); dump();
+mov (ecx, ptr[rsp+rbp*2-1000]); dump();
+mov (ecx, ptr[rsp+rbp*4+0]); dump();
+mov (ecx, ptr[rsp+rbp*4+1]); dump();
+mov (ecx, ptr[rsp+rbp*4+1000]); dump();
+mov (ecx, ptr[rsp+rbp*4-1]); dump();
+mov (ecx, ptr[rsp+rbp*4-1000]); dump();
+mov (ecx, ptr[rsp+rbp*8+0]); dump();
+mov (ecx, ptr[rsp+rbp*8+1]); dump();
+mov (ecx, ptr[rsp+rbp*8+1000]); dump();
+mov (ecx, ptr[rsp+rbp*8-1]); dump();
+mov (ecx, ptr[rsp+rbp*8-1000]); dump();
+mov (ecx, ptr[rsp+rsi+0]); dump();
+mov (ecx, ptr[rsp+rsi+1]); dump();
+mov (ecx, ptr[rsp+rsi+1000]); dump();
+mov (ecx, ptr[rsp+rsi-1]); dump();
+mov (ecx, ptr[rsp+rsi-1000]); dump();
+mov (ecx, ptr[rsp+rsi*1+0]); dump();
+mov (ecx, ptr[rsp+rsi*1+1]); dump();
+mov (ecx, ptr[rsp+rsi*1+1000]); dump();
+mov (ecx, ptr[rsp+rsi*1-1]); dump();
+mov (ecx, ptr[rsp+rsi*1-1000]); dump();
+mov (ecx, ptr[rsp+rsi*2+0]); dump();
+mov (ecx, ptr[rsp+rsi*2+1]); dump();
+mov (ecx, ptr[rsp+rsi*2+1000]); dump();
+mov (ecx, ptr[rsp+rsi*2-1]); dump();
+mov (ecx, ptr[rsp+rsi*2-1000]); dump();
+mov (ecx, ptr[rsp+rsi*4+0]); dump();
+mov (ecx, ptr[rsp+rsi*4+1]); dump();
+mov (ecx, ptr[rsp+rsi*4+1000]); dump();
+mov (ecx, ptr[rsp+rsi*4-1]); dump();
+mov (ecx, ptr[rsp+rsi*4-1000]); dump();
+mov (ecx, ptr[rsp+rsi*8+0]); dump();
+mov (ecx, ptr[rsp+rsi*8+1]); dump();
+mov (ecx, ptr[rsp+rsi*8+1000]); dump();
+mov (ecx, ptr[rsp+rsi*8-1]); dump();
+mov (ecx, ptr[rsp+rsi*8-1000]); dump();
+mov (ecx, ptr[rsp+rdi+0]); dump();
+mov (ecx, ptr[rsp+rdi+1]); dump();
+mov (ecx, ptr[rsp+rdi+1000]); dump();
+mov (ecx, ptr[rsp+rdi-1]); dump();
+mov (ecx, ptr[rsp+rdi-1000]); dump();
+mov (ecx, ptr[rsp+rdi*1+0]); dump();
+mov (ecx, ptr[rsp+rdi*1+1]); dump();
+mov (ecx, ptr[rsp+rdi*1+1000]); dump();
+mov (ecx, ptr[rsp+rdi*1-1]); dump();
+mov (ecx, ptr[rsp+rdi*1-1000]); dump();
+mov (ecx, ptr[rsp+rdi*2+0]); dump();
+mov (ecx, ptr[rsp+rdi*2+1]); dump();
+mov (ecx, ptr[rsp+rdi*2+1000]); dump();
+mov (ecx, ptr[rsp+rdi*2-1]); dump();
+mov (ecx, ptr[rsp+rdi*2-1000]); dump();
+mov (ecx, ptr[rsp+rdi*4+0]); dump();
+mov (ecx, ptr[rsp+rdi*4+1]); dump();
+mov (ecx, ptr[rsp+rdi*4+1000]); dump();
+mov (ecx, ptr[rsp+rdi*4-1]); dump();
+mov (ecx, ptr[rsp+rdi*4-1000]); dump();
+mov (ecx, ptr[rsp+rdi*8+0]); dump();
+mov (ecx, ptr[rsp+rdi*8+1]); dump();
+mov (ecx, ptr[rsp+rdi*8+1000]); dump();
+mov (ecx, ptr[rsp+rdi*8-1]); dump();
+mov (ecx, ptr[rsp+rdi*8-1000]); dump();
+mov (ecx, ptr[rsp+r9+0]); dump();
+mov (ecx, ptr[rsp+r9+1]); dump();
+mov (ecx, ptr[rsp+r9+1000]); dump();
+mov (ecx, ptr[rsp+r9-1]); dump();
+mov (ecx, ptr[rsp+r9-1000]); dump();
+mov (ecx, ptr[rsp+r9*1+0]); dump();
+mov (ecx, ptr[rsp+r9*1+1]); dump();
+mov (ecx, ptr[rsp+r9*1+1000]); dump();
+mov (ecx, ptr[rsp+r9*1-1]); dump();
+mov (ecx, ptr[rsp+r9*1-1000]); dump();
+mov (ecx, ptr[rsp+r9*2+0]); dump();
+mov (ecx, ptr[rsp+r9*2+1]); dump();
+mov (ecx, ptr[rsp+r9*2+1000]); dump();
+mov (ecx, ptr[rsp+r9*2-1]); dump();
+mov (ecx, ptr[rsp+r9*2-1000]); dump();
+mov (ecx, ptr[rsp+r9*4+0]); dump();
+mov (ecx, ptr[rsp+r9*4+1]); dump();
+mov (ecx, ptr[rsp+r9*4+1000]); dump();
+mov (ecx, ptr[rsp+r9*4-1]); dump();
+mov (ecx, ptr[rsp+r9*4-1000]); dump();
+mov (ecx, ptr[rsp+r9*8+0]); dump();
+mov (ecx, ptr[rsp+r9*8+1]); dump();
+mov (ecx, ptr[rsp+r9*8+1000]); dump();
+mov (ecx, ptr[rsp+r9*8-1]); dump();
+mov (ecx, ptr[rsp+r9*8-1000]); dump();
+}
+    void gen17(){
+mov (ecx, ptr[rsp+r10+0]); dump();
+mov (ecx, ptr[rsp+r10+1]); dump();
+mov (ecx, ptr[rsp+r10+1000]); dump();
+mov (ecx, ptr[rsp+r10-1]); dump();
+mov (ecx, ptr[rsp+r10-1000]); dump();
+mov (ecx, ptr[rsp+r10*1+0]); dump();
+mov (ecx, ptr[rsp+r10*1+1]); dump();
+mov (ecx, ptr[rsp+r10*1+1000]); dump();
+mov (ecx, ptr[rsp+r10*1-1]); dump();
+mov (ecx, ptr[rsp+r10*1-1000]); dump();
+mov (ecx, ptr[rsp+r10*2+0]); dump();
+mov (ecx, ptr[rsp+r10*2+1]); dump();
+mov (ecx, ptr[rsp+r10*2+1000]); dump();
+mov (ecx, ptr[rsp+r10*2-1]); dump();
+mov (ecx, ptr[rsp+r10*2-1000]); dump();
+mov (ecx, ptr[rsp+r10*4+0]); dump();
+mov (ecx, ptr[rsp+r10*4+1]); dump();
+mov (ecx, ptr[rsp+r10*4+1000]); dump();
+mov (ecx, ptr[rsp+r10*4-1]); dump();
+mov (ecx, ptr[rsp+r10*4-1000]); dump();
+mov (ecx, ptr[rsp+r10*8+0]); dump();
+mov (ecx, ptr[rsp+r10*8+1]); dump();
+mov (ecx, ptr[rsp+r10*8+1000]); dump();
+mov (ecx, ptr[rsp+r10*8-1]); dump();
+mov (ecx, ptr[rsp+r10*8-1000]); dump();
+mov (ecx, ptr[rsp+r11+0]); dump();
+mov (ecx, ptr[rsp+r11+1]); dump();
+mov (ecx, ptr[rsp+r11+1000]); dump();
+mov (ecx, ptr[rsp+r11-1]); dump();
+mov (ecx, ptr[rsp+r11-1000]); dump();
+mov (ecx, ptr[rsp+r11*1+0]); dump();
+mov (ecx, ptr[rsp+r11*1+1]); dump();
+mov (ecx, ptr[rsp+r11*1+1000]); dump();
+mov (ecx, ptr[rsp+r11*1-1]); dump();
+mov (ecx, ptr[rsp+r11*1-1000]); dump();
+mov (ecx, ptr[rsp+r11*2+0]); dump();
+mov (ecx, ptr[rsp+r11*2+1]); dump();
+mov (ecx, ptr[rsp+r11*2+1000]); dump();
+mov (ecx, ptr[rsp+r11*2-1]); dump();
+mov (ecx, ptr[rsp+r11*2-1000]); dump();
+mov (ecx, ptr[rsp+r11*4+0]); dump();
+mov (ecx, ptr[rsp+r11*4+1]); dump();
+mov (ecx, ptr[rsp+r11*4+1000]); dump();
+mov (ecx, ptr[rsp+r11*4-1]); dump();
+mov (ecx, ptr[rsp+r11*4-1000]); dump();
+mov (ecx, ptr[rsp+r11*8+0]); dump();
+mov (ecx, ptr[rsp+r11*8+1]); dump();
+mov (ecx, ptr[rsp+r11*8+1000]); dump();
+mov (ecx, ptr[rsp+r11*8-1]); dump();
+mov (ecx, ptr[rsp+r11*8-1000]); dump();
+mov (ecx, ptr[rsp+r12+0]); dump();
+mov (ecx, ptr[rsp+r12+1]); dump();
+mov (ecx, ptr[rsp+r12+1000]); dump();
+mov (ecx, ptr[rsp+r12-1]); dump();
+mov (ecx, ptr[rsp+r12-1000]); dump();
+mov (ecx, ptr[rsp+r12*1+0]); dump();
+mov (ecx, ptr[rsp+r12*1+1]); dump();
+mov (ecx, ptr[rsp+r12*1+1000]); dump();
+mov (ecx, ptr[rsp+r12*1-1]); dump();
+mov (ecx, ptr[rsp+r12*1-1000]); dump();
+mov (ecx, ptr[rsp+r12*2+0]); dump();
+mov (ecx, ptr[rsp+r12*2+1]); dump();
+mov (ecx, ptr[rsp+r12*2+1000]); dump();
+mov (ecx, ptr[rsp+r12*2-1]); dump();
+mov (ecx, ptr[rsp+r12*2-1000]); dump();
+mov (ecx, ptr[rsp+r12*4+0]); dump();
+mov (ecx, ptr[rsp+r12*4+1]); dump();
+mov (ecx, ptr[rsp+r12*4+1000]); dump();
+mov (ecx, ptr[rsp+r12*4-1]); dump();
+mov (ecx, ptr[rsp+r12*4-1000]); dump();
+mov (ecx, ptr[rsp+r12*8+0]); dump();
+mov (ecx, ptr[rsp+r12*8+1]); dump();
+mov (ecx, ptr[rsp+r12*8+1000]); dump();
+mov (ecx, ptr[rsp+r12*8-1]); dump();
+mov (ecx, ptr[rsp+r12*8-1000]); dump();
+mov (ecx, ptr[rsp+r13+0]); dump();
+mov (ecx, ptr[rsp+r13+1]); dump();
+mov (ecx, ptr[rsp+r13+1000]); dump();
+mov (ecx, ptr[rsp+r13-1]); dump();
+mov (ecx, ptr[rsp+r13-1000]); dump();
+mov (ecx, ptr[rsp+r13*1+0]); dump();
+mov (ecx, ptr[rsp+r13*1+1]); dump();
+mov (ecx, ptr[rsp+r13*1+1000]); dump();
+mov (ecx, ptr[rsp+r13*1-1]); dump();
+mov (ecx, ptr[rsp+r13*1-1000]); dump();
+mov (ecx, ptr[rsp+r13*2+0]); dump();
+mov (ecx, ptr[rsp+r13*2+1]); dump();
+mov (ecx, ptr[rsp+r13*2+1000]); dump();
+mov (ecx, ptr[rsp+r13*2-1]); dump();
+mov (ecx, ptr[rsp+r13*2-1000]); dump();
+mov (ecx, ptr[rsp+r13*4+0]); dump();
+mov (ecx, ptr[rsp+r13*4+1]); dump();
+mov (ecx, ptr[rsp+r13*4+1000]); dump();
+mov (ecx, ptr[rsp+r13*4-1]); dump();
+mov (ecx, ptr[rsp+r13*4-1000]); dump();
+mov (ecx, ptr[rsp+r13*8+0]); dump();
+mov (ecx, ptr[rsp+r13*8+1]); dump();
+mov (ecx, ptr[rsp+r13*8+1000]); dump();
+mov (ecx, ptr[rsp+r13*8-1]); dump();
+mov (ecx, ptr[rsp+r13*8-1000]); dump();
+}
+    void gen18(){
+mov (ecx, ptr[rsp+r14+0]); dump();
+mov (ecx, ptr[rsp+r14+1]); dump();
+mov (ecx, ptr[rsp+r14+1000]); dump();
+mov (ecx, ptr[rsp+r14-1]); dump();
+mov (ecx, ptr[rsp+r14-1000]); dump();
+mov (ecx, ptr[rsp+r14*1+0]); dump();
+mov (ecx, ptr[rsp+r14*1+1]); dump();
+mov (ecx, ptr[rsp+r14*1+1000]); dump();
+mov (ecx, ptr[rsp+r14*1-1]); dump();
+mov (ecx, ptr[rsp+r14*1-1000]); dump();
+mov (ecx, ptr[rsp+r14*2+0]); dump();
+mov (ecx, ptr[rsp+r14*2+1]); dump();
+mov (ecx, ptr[rsp+r14*2+1000]); dump();
+mov (ecx, ptr[rsp+r14*2-1]); dump();
+mov (ecx, ptr[rsp+r14*2-1000]); dump();
+mov (ecx, ptr[rsp+r14*4+0]); dump();
+mov (ecx, ptr[rsp+r14*4+1]); dump();
+mov (ecx, ptr[rsp+r14*4+1000]); dump();
+mov (ecx, ptr[rsp+r14*4-1]); dump();
+mov (ecx, ptr[rsp+r14*4-1000]); dump();
+mov (ecx, ptr[rsp+r14*8+0]); dump();
+mov (ecx, ptr[rsp+r14*8+1]); dump();
+mov (ecx, ptr[rsp+r14*8+1000]); dump();
+mov (ecx, ptr[rsp+r14*8-1]); dump();
+mov (ecx, ptr[rsp+r14*8-1000]); dump();
+mov (ecx, ptr[rsp+r15+0]); dump();
+mov (ecx, ptr[rsp+r15+1]); dump();
+mov (ecx, ptr[rsp+r15+1000]); dump();
+mov (ecx, ptr[rsp+r15-1]); dump();
+mov (ecx, ptr[rsp+r15-1000]); dump();
+mov (ecx, ptr[rsp+r15*1+0]); dump();
+mov (ecx, ptr[rsp+r15*1+1]); dump();
+mov (ecx, ptr[rsp+r15*1+1000]); dump();
+mov (ecx, ptr[rsp+r15*1-1]); dump();
+mov (ecx, ptr[rsp+r15*1-1000]); dump();
+mov (ecx, ptr[rsp+r15*2+0]); dump();
+mov (ecx, ptr[rsp+r15*2+1]); dump();
+mov (ecx, ptr[rsp+r15*2+1000]); dump();
+mov (ecx, ptr[rsp+r15*2-1]); dump();
+mov (ecx, ptr[rsp+r15*2-1000]); dump();
+mov (ecx, ptr[rsp+r15*4+0]); dump();
+mov (ecx, ptr[rsp+r15*4+1]); dump();
+mov (ecx, ptr[rsp+r15*4+1000]); dump();
+mov (ecx, ptr[rsp+r15*4-1]); dump();
+mov (ecx, ptr[rsp+r15*4-1000]); dump();
+mov (ecx, ptr[rsp+r15*8+0]); dump();
+mov (ecx, ptr[rsp+r15*8+1]); dump();
+mov (ecx, ptr[rsp+r15*8+1000]); dump();
+mov (ecx, ptr[rsp+r15*8-1]); dump();
+mov (ecx, ptr[rsp+r15*8-1000]); dump();
+mov (ecx, ptr[rsp+0]); dump();
+mov (ecx, ptr[rsp+1]); dump();
+mov (ecx, ptr[rsp+1000]); dump();
+mov (ecx, ptr[rsp-1]); dump();
+mov (ecx, ptr[rsp-1000]); dump();
+mov (ecx, ptr[rsp+0]); dump();
+mov (ecx, ptr[rsp+1]); dump();
+mov (ecx, ptr[rsp+1000]); dump();
+mov (ecx, ptr[rsp-1]); dump();
+mov (ecx, ptr[rsp-1000]); dump();
+mov (ecx, ptr[rsp+0]); dump();
+mov (ecx, ptr[rsp+1]); dump();
+mov (ecx, ptr[rsp+1000]); dump();
+mov (ecx, ptr[rsp-1]); dump();
+mov (ecx, ptr[rsp-1000]); dump();
+mov (ecx, ptr[rsp+0]); dump();
+mov (ecx, ptr[rsp+1]); dump();
+mov (ecx, ptr[rsp+1000]); dump();
+mov (ecx, ptr[rsp-1]); dump();
+mov (ecx, ptr[rsp-1000]); dump();
+mov (ecx, ptr[rsp+0]); dump();
+mov (ecx, ptr[rsp+1]); dump();
+mov (ecx, ptr[rsp+1000]); dump();
+mov (ecx, ptr[rsp-1]); dump();
+mov (ecx, ptr[rsp-1000]); dump();
+mov (ecx, ptr[rbp+rax+0]); dump();
+mov (ecx, ptr[rbp+rax+1]); dump();
+mov (ecx, ptr[rbp+rax+1000]); dump();
+mov (ecx, ptr[rbp+rax-1]); dump();
+mov (ecx, ptr[rbp+rax-1000]); dump();
+mov (ecx, ptr[rbp+rax*1+0]); dump();
+mov (ecx, ptr[rbp+rax*1+1]); dump();
+mov (ecx, ptr[rbp+rax*1+1000]); dump();
+mov (ecx, ptr[rbp+rax*1-1]); dump();
+mov (ecx, ptr[rbp+rax*1-1000]); dump();
+mov (ecx, ptr[rbp+rax*2+0]); dump();
+mov (ecx, ptr[rbp+rax*2+1]); dump();
+mov (ecx, ptr[rbp+rax*2+1000]); dump();
+mov (ecx, ptr[rbp+rax*2-1]); dump();
+mov (ecx, ptr[rbp+rax*2-1000]); dump();
+mov (ecx, ptr[rbp+rax*4+0]); dump();
+mov (ecx, ptr[rbp+rax*4+1]); dump();
+mov (ecx, ptr[rbp+rax*4+1000]); dump();
+mov (ecx, ptr[rbp+rax*4-1]); dump();
+mov (ecx, ptr[rbp+rax*4-1000]); dump();
+mov (ecx, ptr[rbp+rax*8+0]); dump();
+mov (ecx, ptr[rbp+rax*8+1]); dump();
+mov (ecx, ptr[rbp+rax*8+1000]); dump();
+mov (ecx, ptr[rbp+rax*8-1]); dump();
+mov (ecx, ptr[rbp+rax*8-1000]); dump();
+}
+    void gen19(){
+mov (ecx, ptr[rbp+rcx+0]); dump();
+mov (ecx, ptr[rbp+rcx+1]); dump();
+mov (ecx, ptr[rbp+rcx+1000]); dump();
+mov (ecx, ptr[rbp+rcx-1]); dump();
+mov (ecx, ptr[rbp+rcx-1000]); dump();
+mov (ecx, ptr[rbp+rcx*1+0]); dump();
+mov (ecx, ptr[rbp+rcx*1+1]); dump();
+mov (ecx, ptr[rbp+rcx*1+1000]); dump();
+mov (ecx, ptr[rbp+rcx*1-1]); dump();
+mov (ecx, ptr[rbp+rcx*1-1000]); dump();
+mov (ecx, ptr[rbp+rcx*2+0]); dump();
+mov (ecx, ptr[rbp+rcx*2+1]); dump();
+mov (ecx, ptr[rbp+rcx*2+1000]); dump();
+mov (ecx, ptr[rbp+rcx*2-1]); dump();
+mov (ecx, ptr[rbp+rcx*2-1000]); dump();
+mov (ecx, ptr[rbp+rcx*4+0]); dump();
+mov (ecx, ptr[rbp+rcx*4+1]); dump();
+mov (ecx, ptr[rbp+rcx*4+1000]); dump();
+mov (ecx, ptr[rbp+rcx*4-1]); dump();
+mov (ecx, ptr[rbp+rcx*4-1000]); dump();
+mov (ecx, ptr[rbp+rcx*8+0]); dump();
+mov (ecx, ptr[rbp+rcx*8+1]); dump();
+mov (ecx, ptr[rbp+rcx*8+1000]); dump();
+mov (ecx, ptr[rbp+rcx*8-1]); dump();
+mov (ecx, ptr[rbp+rcx*8-1000]); dump();
+mov (ecx, ptr[rbp+rdx+0]); dump();
+mov (ecx, ptr[rbp+rdx+1]); dump();
+mov (ecx, ptr[rbp+rdx+1000]); dump();
+mov (ecx, ptr[rbp+rdx-1]); dump();
+mov (ecx, ptr[rbp+rdx-1000]); dump();
+mov (ecx, ptr[rbp+rdx*1+0]); dump();
+mov (ecx, ptr[rbp+rdx*1+1]); dump();
+mov (ecx, ptr[rbp+rdx*1+1000]); dump();
+mov (ecx, ptr[rbp+rdx*1-1]); dump();
+mov (ecx, ptr[rbp+rdx*1-1000]); dump();
+mov (ecx, ptr[rbp+rdx*2+0]); dump();
+mov (ecx, ptr[rbp+rdx*2+1]); dump();
+mov (ecx, ptr[rbp+rdx*2+1000]); dump();
+mov (ecx, ptr[rbp+rdx*2-1]); dump();
+mov (ecx, ptr[rbp+rdx*2-1000]); dump();
+mov (ecx, ptr[rbp+rdx*4+0]); dump();
+mov (ecx, ptr[rbp+rdx*4+1]); dump();
+mov (ecx, ptr[rbp+rdx*4+1000]); dump();
+mov (ecx, ptr[rbp+rdx*4-1]); dump();
+mov (ecx, ptr[rbp+rdx*4-1000]); dump();
+mov (ecx, ptr[rbp+rdx*8+0]); dump();
+mov (ecx, ptr[rbp+rdx*8+1]); dump();
+mov (ecx, ptr[rbp+rdx*8+1000]); dump();
+mov (ecx, ptr[rbp+rdx*8-1]); dump();
+mov (ecx, ptr[rbp+rdx*8-1000]); dump();
+mov (ecx, ptr[rbp+rbx+0]); dump();
+mov (ecx, ptr[rbp+rbx+1]); dump();
+mov (ecx, ptr[rbp+rbx+1000]); dump();
+mov (ecx, ptr[rbp+rbx-1]); dump();
+mov (ecx, ptr[rbp+rbx-1000]); dump();
+mov (ecx, ptr[rbp+rbx*1+0]); dump();
+mov (ecx, ptr[rbp+rbx*1+1]); dump();
+mov (ecx, ptr[rbp+rbx*1+1000]); dump();
+mov (ecx, ptr[rbp+rbx*1-1]); dump();
+mov (ecx, ptr[rbp+rbx*1-1000]); dump();
+mov (ecx, ptr[rbp+rbx*2+0]); dump();
+mov (ecx, ptr[rbp+rbx*2+1]); dump();
+mov (ecx, ptr[rbp+rbx*2+1000]); dump();
+mov (ecx, ptr[rbp+rbx*2-1]); dump();
+mov (ecx, ptr[rbp+rbx*2-1000]); dump();
+mov (ecx, ptr[rbp+rbx*4+0]); dump();
+mov (ecx, ptr[rbp+rbx*4+1]); dump();
+mov (ecx, ptr[rbp+rbx*4+1000]); dump();
+mov (ecx, ptr[rbp+rbx*4-1]); dump();
+mov (ecx, ptr[rbp+rbx*4-1000]); dump();
+mov (ecx, ptr[rbp+rbx*8+0]); dump();
+mov (ecx, ptr[rbp+rbx*8+1]); dump();
+mov (ecx, ptr[rbp+rbx*8+1000]); dump();
+mov (ecx, ptr[rbp+rbx*8-1]); dump();
+mov (ecx, ptr[rbp+rbx*8-1000]); dump();
+mov (ecx, ptr[rbp+rbp+0]); dump();
+mov (ecx, ptr[rbp+rbp+1]); dump();
+mov (ecx, ptr[rbp+rbp+1000]); dump();
+mov (ecx, ptr[rbp+rbp-1]); dump();
+mov (ecx, ptr[rbp+rbp-1000]); dump();
+mov (ecx, ptr[rbp+rbp*1+0]); dump();
+mov (ecx, ptr[rbp+rbp*1+1]); dump();
+mov (ecx, ptr[rbp+rbp*1+1000]); dump();
+mov (ecx, ptr[rbp+rbp*1-1]); dump();
+mov (ecx, ptr[rbp+rbp*1-1000]); dump();
+mov (ecx, ptr[rbp+rbp*2+0]); dump();
+mov (ecx, ptr[rbp+rbp*2+1]); dump();
+mov (ecx, ptr[rbp+rbp*2+1000]); dump();
+mov (ecx, ptr[rbp+rbp*2-1]); dump();
+mov (ecx, ptr[rbp+rbp*2-1000]); dump();
+mov (ecx, ptr[rbp+rbp*4+0]); dump();
+mov (ecx, ptr[rbp+rbp*4+1]); dump();
+mov (ecx, ptr[rbp+rbp*4+1000]); dump();
+mov (ecx, ptr[rbp+rbp*4-1]); dump();
+mov (ecx, ptr[rbp+rbp*4-1000]); dump();
+mov (ecx, ptr[rbp+rbp*8+0]); dump();
+mov (ecx, ptr[rbp+rbp*8+1]); dump();
+mov (ecx, ptr[rbp+rbp*8+1000]); dump();
+mov (ecx, ptr[rbp+rbp*8-1]); dump();
+mov (ecx, ptr[rbp+rbp*8-1000]); dump();
+}
+    void gen20(){
+mov (ecx, ptr[rbp+rsi+0]); dump();
+mov (ecx, ptr[rbp+rsi+1]); dump();
+mov (ecx, ptr[rbp+rsi+1000]); dump();
+mov (ecx, ptr[rbp+rsi-1]); dump();
+mov (ecx, ptr[rbp+rsi-1000]); dump();
+mov (ecx, ptr[rbp+rsi*1+0]); dump();
+mov (ecx, ptr[rbp+rsi*1+1]); dump();
+mov (ecx, ptr[rbp+rsi*1+1000]); dump();
+mov (ecx, ptr[rbp+rsi*1-1]); dump();
+mov (ecx, ptr[rbp+rsi*1-1000]); dump();
+mov (ecx, ptr[rbp+rsi*2+0]); dump();
+mov (ecx, ptr[rbp+rsi*2+1]); dump();
+mov (ecx, ptr[rbp+rsi*2+1000]); dump();
+mov (ecx, ptr[rbp+rsi*2-1]); dump();
+mov (ecx, ptr[rbp+rsi*2-1000]); dump();
+mov (ecx, ptr[rbp+rsi*4+0]); dump();
+mov (ecx, ptr[rbp+rsi*4+1]); dump();
+mov (ecx, ptr[rbp+rsi*4+1000]); dump();
+mov (ecx, ptr[rbp+rsi*4-1]); dump();
+mov (ecx, ptr[rbp+rsi*4-1000]); dump();
+mov (ecx, ptr[rbp+rsi*8+0]); dump();
+mov (ecx, ptr[rbp+rsi*8+1]); dump();
+mov (ecx, ptr[rbp+rsi*8+1000]); dump();
+mov (ecx, ptr[rbp+rsi*8-1]); dump();
+mov (ecx, ptr[rbp+rsi*8-1000]); dump();
+mov (ecx, ptr[rbp+rdi+0]); dump();
+mov (ecx, ptr[rbp+rdi+1]); dump();
+mov (ecx, ptr[rbp+rdi+1000]); dump();
+mov (ecx, ptr[rbp+rdi-1]); dump();
+mov (ecx, ptr[rbp+rdi-1000]); dump();
+mov (ecx, ptr[rbp+rdi*1+0]); dump();
+mov (ecx, ptr[rbp+rdi*1+1]); dump();
+mov (ecx, ptr[rbp+rdi*1+1000]); dump();
+mov (ecx, ptr[rbp+rdi*1-1]); dump();
+mov (ecx, ptr[rbp+rdi*1-1000]); dump();
+mov (ecx, ptr[rbp+rdi*2+0]); dump();
+mov (ecx, ptr[rbp+rdi*2+1]); dump();
+mov (ecx, ptr[rbp+rdi*2+1000]); dump();
+mov (ecx, ptr[rbp+rdi*2-1]); dump();
+mov (ecx, ptr[rbp+rdi*2-1000]); dump();
+mov (ecx, ptr[rbp+rdi*4+0]); dump();
+mov (ecx, ptr[rbp+rdi*4+1]); dump();
+mov (ecx, ptr[rbp+rdi*4+1000]); dump();
+mov (ecx, ptr[rbp+rdi*4-1]); dump();
+mov (ecx, ptr[rbp+rdi*4-1000]); dump();
+mov (ecx, ptr[rbp+rdi*8+0]); dump();
+mov (ecx, ptr[rbp+rdi*8+1]); dump();
+mov (ecx, ptr[rbp+rdi*8+1000]); dump();
+mov (ecx, ptr[rbp+rdi*8-1]); dump();
+mov (ecx, ptr[rbp+rdi*8-1000]); dump();
+mov (ecx, ptr[rbp+r9+0]); dump();
+mov (ecx, ptr[rbp+r9+1]); dump();
+mov (ecx, ptr[rbp+r9+1000]); dump();
+mov (ecx, ptr[rbp+r9-1]); dump();
+mov (ecx, ptr[rbp+r9-1000]); dump();
+mov (ecx, ptr[rbp+r9*1+0]); dump();
+mov (ecx, ptr[rbp+r9*1+1]); dump();
+mov (ecx, ptr[rbp+r9*1+1000]); dump();
+mov (ecx, ptr[rbp+r9*1-1]); dump();
+mov (ecx, ptr[rbp+r9*1-1000]); dump();
+mov (ecx, ptr[rbp+r9*2+0]); dump();
+mov (ecx, ptr[rbp+r9*2+1]); dump();
+mov (ecx, ptr[rbp+r9*2+1000]); dump();
+mov (ecx, ptr[rbp+r9*2-1]); dump();
+mov (ecx, ptr[rbp+r9*2-1000]); dump();
+mov (ecx, ptr[rbp+r9*4+0]); dump();
+mov (ecx, ptr[rbp+r9*4+1]); dump();
+mov (ecx, ptr[rbp+r9*4+1000]); dump();
+mov (ecx, ptr[rbp+r9*4-1]); dump();
+mov (ecx, ptr[rbp+r9*4-1000]); dump();
+mov (ecx, ptr[rbp+r9*8+0]); dump();
+mov (ecx, ptr[rbp+r9*8+1]); dump();
+mov (ecx, ptr[rbp+r9*8+1000]); dump();
+mov (ecx, ptr[rbp+r9*8-1]); dump();
+mov (ecx, ptr[rbp+r9*8-1000]); dump();
+mov (ecx, ptr[rbp+r10+0]); dump();
+mov (ecx, ptr[rbp+r10+1]); dump();
+mov (ecx, ptr[rbp+r10+1000]); dump();
+mov (ecx, ptr[rbp+r10-1]); dump();
+mov (ecx, ptr[rbp+r10-1000]); dump();
+mov (ecx, ptr[rbp+r10*1+0]); dump();
+mov (ecx, ptr[rbp+r10*1+1]); dump();
+mov (ecx, ptr[rbp+r10*1+1000]); dump();
+mov (ecx, ptr[rbp+r10*1-1]); dump();
+mov (ecx, ptr[rbp+r10*1-1000]); dump();
+mov (ecx, ptr[rbp+r10*2+0]); dump();
+mov (ecx, ptr[rbp+r10*2+1]); dump();
+mov (ecx, ptr[rbp+r10*2+1000]); dump();
+mov (ecx, ptr[rbp+r10*2-1]); dump();
+mov (ecx, ptr[rbp+r10*2-1000]); dump();
+mov (ecx, ptr[rbp+r10*4+0]); dump();
+mov (ecx, ptr[rbp+r10*4+1]); dump();
+mov (ecx, ptr[rbp+r10*4+1000]); dump();
+mov (ecx, ptr[rbp+r10*4-1]); dump();
+mov (ecx, ptr[rbp+r10*4-1000]); dump();
+mov (ecx, ptr[rbp+r10*8+0]); dump();
+mov (ecx, ptr[rbp+r10*8+1]); dump();
+mov (ecx, ptr[rbp+r10*8+1000]); dump();
+mov (ecx, ptr[rbp+r10*8-1]); dump();
+mov (ecx, ptr[rbp+r10*8-1000]); dump();
+}
+    void gen21(){
+mov (ecx, ptr[rbp+r11+0]); dump();
+mov (ecx, ptr[rbp+r11+1]); dump();
+mov (ecx, ptr[rbp+r11+1000]); dump();
+mov (ecx, ptr[rbp+r11-1]); dump();
+mov (ecx, ptr[rbp+r11-1000]); dump();
+mov (ecx, ptr[rbp+r11*1+0]); dump();
+mov (ecx, ptr[rbp+r11*1+1]); dump();
+mov (ecx, ptr[rbp+r11*1+1000]); dump();
+mov (ecx, ptr[rbp+r11*1-1]); dump();
+mov (ecx, ptr[rbp+r11*1-1000]); dump();
+mov (ecx, ptr[rbp+r11*2+0]); dump();
+mov (ecx, ptr[rbp+r11*2+1]); dump();
+mov (ecx, ptr[rbp+r11*2+1000]); dump();
+mov (ecx, ptr[rbp+r11*2-1]); dump();
+mov (ecx, ptr[rbp+r11*2-1000]); dump();
+mov (ecx, ptr[rbp+r11*4+0]); dump();
+mov (ecx, ptr[rbp+r11*4+1]); dump();
+mov (ecx, ptr[rbp+r11*4+1000]); dump();
+mov (ecx, ptr[rbp+r11*4-1]); dump();
+mov (ecx, ptr[rbp+r11*4-1000]); dump();
+mov (ecx, ptr[rbp+r11*8+0]); dump();
+mov (ecx, ptr[rbp+r11*8+1]); dump();
+mov (ecx, ptr[rbp+r11*8+1000]); dump();
+mov (ecx, ptr[rbp+r11*8-1]); dump();
+mov (ecx, ptr[rbp+r11*8-1000]); dump();
+mov (ecx, ptr[rbp+r12+0]); dump();
+mov (ecx, ptr[rbp+r12+1]); dump();
+mov (ecx, ptr[rbp+r12+1000]); dump();
+mov (ecx, ptr[rbp+r12-1]); dump();
+mov (ecx, ptr[rbp+r12-1000]); dump();
+mov (ecx, ptr[rbp+r12*1+0]); dump();
+mov (ecx, ptr[rbp+r12*1+1]); dump();
+mov (ecx, ptr[rbp+r12*1+1000]); dump();
+mov (ecx, ptr[rbp+r12*1-1]); dump();
+mov (ecx, ptr[rbp+r12*1-1000]); dump();
+mov (ecx, ptr[rbp+r12*2+0]); dump();
+mov (ecx, ptr[rbp+r12*2+1]); dump();
+mov (ecx, ptr[rbp+r12*2+1000]); dump();
+mov (ecx, ptr[rbp+r12*2-1]); dump();
+mov (ecx, ptr[rbp+r12*2-1000]); dump();
+mov (ecx, ptr[rbp+r12*4+0]); dump();
+mov (ecx, ptr[rbp+r12*4+1]); dump();
+mov (ecx, ptr[rbp+r12*4+1000]); dump();
+mov (ecx, ptr[rbp+r12*4-1]); dump();
+mov (ecx, ptr[rbp+r12*4-1000]); dump();
+mov (ecx, ptr[rbp+r12*8+0]); dump();
+mov (ecx, ptr[rbp+r12*8+1]); dump();
+mov (ecx, ptr[rbp+r12*8+1000]); dump();
+mov (ecx, ptr[rbp+r12*8-1]); dump();
+mov (ecx, ptr[rbp+r12*8-1000]); dump();
+mov (ecx, ptr[rbp+r13+0]); dump();
+mov (ecx, ptr[rbp+r13+1]); dump();
+mov (ecx, ptr[rbp+r13+1000]); dump();
+mov (ecx, ptr[rbp+r13-1]); dump();
+mov (ecx, ptr[rbp+r13-1000]); dump();
+mov (ecx, ptr[rbp+r13*1+0]); dump();
+mov (ecx, ptr[rbp+r13*1+1]); dump();
+mov (ecx, ptr[rbp+r13*1+1000]); dump();
+mov (ecx, ptr[rbp+r13*1-1]); dump();
+mov (ecx, ptr[rbp+r13*1-1000]); dump();
+mov (ecx, ptr[rbp+r13*2+0]); dump();
+mov (ecx, ptr[rbp+r13*2+1]); dump();
+mov (ecx, ptr[rbp+r13*2+1000]); dump();
+mov (ecx, ptr[rbp+r13*2-1]); dump();
+mov (ecx, ptr[rbp+r13*2-1000]); dump();
+mov (ecx, ptr[rbp+r13*4+0]); dump();
+mov (ecx, ptr[rbp+r13*4+1]); dump();
+mov (ecx, ptr[rbp+r13*4+1000]); dump();
+mov (ecx, ptr[rbp+r13*4-1]); dump();
+mov (ecx, ptr[rbp+r13*4-1000]); dump();
+mov (ecx, ptr[rbp+r13*8+0]); dump();
+mov (ecx, ptr[rbp+r13*8+1]); dump();
+mov (ecx, ptr[rbp+r13*8+1000]); dump();
+mov (ecx, ptr[rbp+r13*8-1]); dump();
+mov (ecx, ptr[rbp+r13*8-1000]); dump();
+mov (ecx, ptr[rbp+r14+0]); dump();
+mov (ecx, ptr[rbp+r14+1]); dump();
+mov (ecx, ptr[rbp+r14+1000]); dump();
+mov (ecx, ptr[rbp+r14-1]); dump();
+mov (ecx, ptr[rbp+r14-1000]); dump();
+mov (ecx, ptr[rbp+r14*1+0]); dump();
+mov (ecx, ptr[rbp+r14*1+1]); dump();
+mov (ecx, ptr[rbp+r14*1+1000]); dump();
+mov (ecx, ptr[rbp+r14*1-1]); dump();
+mov (ecx, ptr[rbp+r14*1-1000]); dump();
+mov (ecx, ptr[rbp+r14*2+0]); dump();
+mov (ecx, ptr[rbp+r14*2+1]); dump();
+mov (ecx, ptr[rbp+r14*2+1000]); dump();
+mov (ecx, ptr[rbp+r14*2-1]); dump();
+mov (ecx, ptr[rbp+r14*2-1000]); dump();
+mov (ecx, ptr[rbp+r14*4+0]); dump();
+mov (ecx, ptr[rbp+r14*4+1]); dump();
+mov (ecx, ptr[rbp+r14*4+1000]); dump();
+mov (ecx, ptr[rbp+r14*4-1]); dump();
+mov (ecx, ptr[rbp+r14*4-1000]); dump();
+mov (ecx, ptr[rbp+r14*8+0]); dump();
+mov (ecx, ptr[rbp+r14*8+1]); dump();
+mov (ecx, ptr[rbp+r14*8+1000]); dump();
+mov (ecx, ptr[rbp+r14*8-1]); dump();
+mov (ecx, ptr[rbp+r14*8-1000]); dump();
+}
+    void gen22(){
+mov (ecx, ptr[rbp+r15+0]); dump();
+mov (ecx, ptr[rbp+r15+1]); dump();
+mov (ecx, ptr[rbp+r15+1000]); dump();
+mov (ecx, ptr[rbp+r15-1]); dump();
+mov (ecx, ptr[rbp+r15-1000]); dump();
+mov (ecx, ptr[rbp+r15*1+0]); dump();
+mov (ecx, ptr[rbp+r15*1+1]); dump();
+mov (ecx, ptr[rbp+r15*1+1000]); dump();
+mov (ecx, ptr[rbp+r15*1-1]); dump();
+mov (ecx, ptr[rbp+r15*1-1000]); dump();
+mov (ecx, ptr[rbp+r15*2+0]); dump();
+mov (ecx, ptr[rbp+r15*2+1]); dump();
+mov (ecx, ptr[rbp+r15*2+1000]); dump();
+mov (ecx, ptr[rbp+r15*2-1]); dump();
+mov (ecx, ptr[rbp+r15*2-1000]); dump();
+mov (ecx, ptr[rbp+r15*4+0]); dump();
+mov (ecx, ptr[rbp+r15*4+1]); dump();
+mov (ecx, ptr[rbp+r15*4+1000]); dump();
+mov (ecx, ptr[rbp+r15*4-1]); dump();
+mov (ecx, ptr[rbp+r15*4-1000]); dump();
+mov (ecx, ptr[rbp+r15*8+0]); dump();
+mov (ecx, ptr[rbp+r15*8+1]); dump();
+mov (ecx, ptr[rbp+r15*8+1000]); dump();
+mov (ecx, ptr[rbp+r15*8-1]); dump();
+mov (ecx, ptr[rbp+r15*8-1000]); dump();
+mov (ecx, ptr[rbp+0]); dump();
+mov (ecx, ptr[rbp+1]); dump();
+mov (ecx, ptr[rbp+1000]); dump();
+mov (ecx, ptr[rbp-1]); dump();
+mov (ecx, ptr[rbp-1000]); dump();
+mov (ecx, ptr[rbp+0]); dump();
+mov (ecx, ptr[rbp+1]); dump();
+mov (ecx, ptr[rbp+1000]); dump();
+mov (ecx, ptr[rbp-1]); dump();
+mov (ecx, ptr[rbp-1000]); dump();
+mov (ecx, ptr[rbp+0]); dump();
+mov (ecx, ptr[rbp+1]); dump();
+mov (ecx, ptr[rbp+1000]); dump();
+mov (ecx, ptr[rbp-1]); dump();
+mov (ecx, ptr[rbp-1000]); dump();
+mov (ecx, ptr[rbp+0]); dump();
+mov (ecx, ptr[rbp+1]); dump();
+mov (ecx, ptr[rbp+1000]); dump();
+mov (ecx, ptr[rbp-1]); dump();
+mov (ecx, ptr[rbp-1000]); dump();
+mov (ecx, ptr[rbp+0]); dump();
+mov (ecx, ptr[rbp+1]); dump();
+mov (ecx, ptr[rbp+1000]); dump();
+mov (ecx, ptr[rbp-1]); dump();
+mov (ecx, ptr[rbp-1000]); dump();
+mov (ecx, ptr[rsi+rax+0]); dump();
+mov (ecx, ptr[rsi+rax+1]); dump();
+mov (ecx, ptr[rsi+rax+1000]); dump();
+mov (ecx, ptr[rsi+rax-1]); dump();
+mov (ecx, ptr[rsi+rax-1000]); dump();
+mov (ecx, ptr[rsi+rax*1+0]); dump();
+mov (ecx, ptr[rsi+rax*1+1]); dump();
+mov (ecx, ptr[rsi+rax*1+1000]); dump();
+mov (ecx, ptr[rsi+rax*1-1]); dump();
+mov (ecx, ptr[rsi+rax*1-1000]); dump();
+mov (ecx, ptr[rsi+rax*2+0]); dump();
+mov (ecx, ptr[rsi+rax*2+1]); dump();
+mov (ecx, ptr[rsi+rax*2+1000]); dump();
+mov (ecx, ptr[rsi+rax*2-1]); dump();
+mov (ecx, ptr[rsi+rax*2-1000]); dump();
+mov (ecx, ptr[rsi+rax*4+0]); dump();
+mov (ecx, ptr[rsi+rax*4+1]); dump();
+mov (ecx, ptr[rsi+rax*4+1000]); dump();
+mov (ecx, ptr[rsi+rax*4-1]); dump();
+mov (ecx, ptr[rsi+rax*4-1000]); dump();
+mov (ecx, ptr[rsi+rax*8+0]); dump();
+mov (ecx, ptr[rsi+rax*8+1]); dump();
+mov (ecx, ptr[rsi+rax*8+1000]); dump();
+mov (ecx, ptr[rsi+rax*8-1]); dump();
+mov (ecx, ptr[rsi+rax*8-1000]); dump();
+mov (ecx, ptr[rsi+rcx+0]); dump();
+mov (ecx, ptr[rsi+rcx+1]); dump();
+mov (ecx, ptr[rsi+rcx+1000]); dump();
+mov (ecx, ptr[rsi+rcx-1]); dump();
+mov (ecx, ptr[rsi+rcx-1000]); dump();
+mov (ecx, ptr[rsi+rcx*1+0]); dump();
+mov (ecx, ptr[rsi+rcx*1+1]); dump();
+mov (ecx, ptr[rsi+rcx*1+1000]); dump();
+mov (ecx, ptr[rsi+rcx*1-1]); dump();
+mov (ecx, ptr[rsi+rcx*1-1000]); dump();
+mov (ecx, ptr[rsi+rcx*2+0]); dump();
+mov (ecx, ptr[rsi+rcx*2+1]); dump();
+mov (ecx, ptr[rsi+rcx*2+1000]); dump();
+mov (ecx, ptr[rsi+rcx*2-1]); dump();
+mov (ecx, ptr[rsi+rcx*2-1000]); dump();
+mov (ecx, ptr[rsi+rcx*4+0]); dump();
+mov (ecx, ptr[rsi+rcx*4+1]); dump();
+mov (ecx, ptr[rsi+rcx*4+1000]); dump();
+mov (ecx, ptr[rsi+rcx*4-1]); dump();
+mov (ecx, ptr[rsi+rcx*4-1000]); dump();
+mov (ecx, ptr[rsi+rcx*8+0]); dump();
+mov (ecx, ptr[rsi+rcx*8+1]); dump();
+mov (ecx, ptr[rsi+rcx*8+1000]); dump();
+mov (ecx, ptr[rsi+rcx*8-1]); dump();
+mov (ecx, ptr[rsi+rcx*8-1000]); dump();
+}
+    void gen23(){
+mov (ecx, ptr[rsi+rdx+0]); dump();
+mov (ecx, ptr[rsi+rdx+1]); dump();
+mov (ecx, ptr[rsi+rdx+1000]); dump();
+mov (ecx, ptr[rsi+rdx-1]); dump();
+mov (ecx, ptr[rsi+rdx-1000]); dump();
+mov (ecx, ptr[rsi+rdx*1+0]); dump();
+mov (ecx, ptr[rsi+rdx*1+1]); dump();
+mov (ecx, ptr[rsi+rdx*1+1000]); dump();
+mov (ecx, ptr[rsi+rdx*1-1]); dump();
+mov (ecx, ptr[rsi+rdx*1-1000]); dump();
+mov (ecx, ptr[rsi+rdx*2+0]); dump();
+mov (ecx, ptr[rsi+rdx*2+1]); dump();
+mov (ecx, ptr[rsi+rdx*2+1000]); dump();
+mov (ecx, ptr[rsi+rdx*2-1]); dump();
+mov (ecx, ptr[rsi+rdx*2-1000]); dump();
+mov (ecx, ptr[rsi+rdx*4+0]); dump();
+mov (ecx, ptr[rsi+rdx*4+1]); dump();
+mov (ecx, ptr[rsi+rdx*4+1000]); dump();
+mov (ecx, ptr[rsi+rdx*4-1]); dump();
+mov (ecx, ptr[rsi+rdx*4-1000]); dump();
+mov (ecx, ptr[rsi+rdx*8+0]); dump();
+mov (ecx, ptr[rsi+rdx*8+1]); dump();
+mov (ecx, ptr[rsi+rdx*8+1000]); dump();
+mov (ecx, ptr[rsi+rdx*8-1]); dump();
+mov (ecx, ptr[rsi+rdx*8-1000]); dump();
+mov (ecx, ptr[rsi+rbx+0]); dump();
+mov (ecx, ptr[rsi+rbx+1]); dump();
+mov (ecx, ptr[rsi+rbx+1000]); dump();
+mov (ecx, ptr[rsi+rbx-1]); dump();
+mov (ecx, ptr[rsi+rbx-1000]); dump();
+mov (ecx, ptr[rsi+rbx*1+0]); dump();
+mov (ecx, ptr[rsi+rbx*1+1]); dump();
+mov (ecx, ptr[rsi+rbx*1+1000]); dump();
+mov (ecx, ptr[rsi+rbx*1-1]); dump();
+mov (ecx, ptr[rsi+rbx*1-1000]); dump();
+mov (ecx, ptr[rsi+rbx*2+0]); dump();
+mov (ecx, ptr[rsi+rbx*2+1]); dump();
+mov (ecx, ptr[rsi+rbx*2+1000]); dump();
+mov (ecx, ptr[rsi+rbx*2-1]); dump();
+mov (ecx, ptr[rsi+rbx*2-1000]); dump();
+mov (ecx, ptr[rsi+rbx*4+0]); dump();
+mov (ecx, ptr[rsi+rbx*4+1]); dump();
+mov (ecx, ptr[rsi+rbx*4+1000]); dump();
+mov (ecx, ptr[rsi+rbx*4-1]); dump();
+mov (ecx, ptr[rsi+rbx*4-1000]); dump();
+mov (ecx, ptr[rsi+rbx*8+0]); dump();
+mov (ecx, ptr[rsi+rbx*8+1]); dump();
+mov (ecx, ptr[rsi+rbx*8+1000]); dump();
+mov (ecx, ptr[rsi+rbx*8-1]); dump();
+mov (ecx, ptr[rsi+rbx*8-1000]); dump();
+mov (ecx, ptr[rsi+rbp+0]); dump();
+mov (ecx, ptr[rsi+rbp+1]); dump();
+mov (ecx, ptr[rsi+rbp+1000]); dump();
+mov (ecx, ptr[rsi+rbp-1]); dump();
+mov (ecx, ptr[rsi+rbp-1000]); dump();
+mov (ecx, ptr[rsi+rbp*1+0]); dump();
+mov (ecx, ptr[rsi+rbp*1+1]); dump();
+mov (ecx, ptr[rsi+rbp*1+1000]); dump();
+mov (ecx, ptr[rsi+rbp*1-1]); dump();
+mov (ecx, ptr[rsi+rbp*1-1000]); dump();
+mov (ecx, ptr[rsi+rbp*2+0]); dump();
+mov (ecx, ptr[rsi+rbp*2+1]); dump();
+mov (ecx, ptr[rsi+rbp*2+1000]); dump();
+mov (ecx, ptr[rsi+rbp*2-1]); dump();
+mov (ecx, ptr[rsi+rbp*2-1000]); dump();
+mov (ecx, ptr[rsi+rbp*4+0]); dump();
+mov (ecx, ptr[rsi+rbp*4+1]); dump();
+mov (ecx, ptr[rsi+rbp*4+1000]); dump();
+mov (ecx, ptr[rsi+rbp*4-1]); dump();
+mov (ecx, ptr[rsi+rbp*4-1000]); dump();
+mov (ecx, ptr[rsi+rbp*8+0]); dump();
+mov (ecx, ptr[rsi+rbp*8+1]); dump();
+mov (ecx, ptr[rsi+rbp*8+1000]); dump();
+mov (ecx, ptr[rsi+rbp*8-1]); dump();
+mov (ecx, ptr[rsi+rbp*8-1000]); dump();
+mov (ecx, ptr[rsi+rsi+0]); dump();
+mov (ecx, ptr[rsi+rsi+1]); dump();
+mov (ecx, ptr[rsi+rsi+1000]); dump();
+mov (ecx, ptr[rsi+rsi-1]); dump();
+mov (ecx, ptr[rsi+rsi-1000]); dump();
+mov (ecx, ptr[rsi+rsi*1+0]); dump();
+mov (ecx, ptr[rsi+rsi*1+1]); dump();
+mov (ecx, ptr[rsi+rsi*1+1000]); dump();
+mov (ecx, ptr[rsi+rsi*1-1]); dump();
+mov (ecx, ptr[rsi+rsi*1-1000]); dump();
+mov (ecx, ptr[rsi+rsi*2+0]); dump();
+mov (ecx, ptr[rsi+rsi*2+1]); dump();
+mov (ecx, ptr[rsi+rsi*2+1000]); dump();
+mov (ecx, ptr[rsi+rsi*2-1]); dump();
+mov (ecx, ptr[rsi+rsi*2-1000]); dump();
+mov (ecx, ptr[rsi+rsi*4+0]); dump();
+mov (ecx, ptr[rsi+rsi*4+1]); dump();
+mov (ecx, ptr[rsi+rsi*4+1000]); dump();
+mov (ecx, ptr[rsi+rsi*4-1]); dump();
+mov (ecx, ptr[rsi+rsi*4-1000]); dump();
+mov (ecx, ptr[rsi+rsi*8+0]); dump();
+mov (ecx, ptr[rsi+rsi*8+1]); dump();
+mov (ecx, ptr[rsi+rsi*8+1000]); dump();
+mov (ecx, ptr[rsi+rsi*8-1]); dump();
+mov (ecx, ptr[rsi+rsi*8-1000]); dump();
+}
+    void gen24(){
+mov (ecx, ptr[rsi+rdi+0]); dump();
+mov (ecx, ptr[rsi+rdi+1]); dump();
+mov (ecx, ptr[rsi+rdi+1000]); dump();
+mov (ecx, ptr[rsi+rdi-1]); dump();
+mov (ecx, ptr[rsi+rdi-1000]); dump();
+mov (ecx, ptr[rsi+rdi*1+0]); dump();
+mov (ecx, ptr[rsi+rdi*1+1]); dump();
+mov (ecx, ptr[rsi+rdi*1+1000]); dump();
+mov (ecx, ptr[rsi+rdi*1-1]); dump();
+mov (ecx, ptr[rsi+rdi*1-1000]); dump();
+mov (ecx, ptr[rsi+rdi*2+0]); dump();
+mov (ecx, ptr[rsi+rdi*2+1]); dump();
+mov (ecx, ptr[rsi+rdi*2+1000]); dump();
+mov (ecx, ptr[rsi+rdi*2-1]); dump();
+mov (ecx, ptr[rsi+rdi*2-1000]); dump();
+mov (ecx, ptr[rsi+rdi*4+0]); dump();
+mov (ecx, ptr[rsi+rdi*4+1]); dump();
+mov (ecx, ptr[rsi+rdi*4+1000]); dump();
+mov (ecx, ptr[rsi+rdi*4-1]); dump();
+mov (ecx, ptr[rsi+rdi*4-1000]); dump();
+mov (ecx, ptr[rsi+rdi*8+0]); dump();
+mov (ecx, ptr[rsi+rdi*8+1]); dump();
+mov (ecx, ptr[rsi+rdi*8+1000]); dump();
+mov (ecx, ptr[rsi+rdi*8-1]); dump();
+mov (ecx, ptr[rsi+rdi*8-1000]); dump();
+mov (ecx, ptr[rsi+r9+0]); dump();
+mov (ecx, ptr[rsi+r9+1]); dump();
+mov (ecx, ptr[rsi+r9+1000]); dump();
+mov (ecx, ptr[rsi+r9-1]); dump();
+mov (ecx, ptr[rsi+r9-1000]); dump();
+mov (ecx, ptr[rsi+r9*1+0]); dump();
+mov (ecx, ptr[rsi+r9*1+1]); dump();
+mov (ecx, ptr[rsi+r9*1+1000]); dump();
+mov (ecx, ptr[rsi+r9*1-1]); dump();
+mov (ecx, ptr[rsi+r9*1-1000]); dump();
+mov (ecx, ptr[rsi+r9*2+0]); dump();
+mov (ecx, ptr[rsi+r9*2+1]); dump();
+mov (ecx, ptr[rsi+r9*2+1000]); dump();
+mov (ecx, ptr[rsi+r9*2-1]); dump();
+mov (ecx, ptr[rsi+r9*2-1000]); dump();
+mov (ecx, ptr[rsi+r9*4+0]); dump();
+mov (ecx, ptr[rsi+r9*4+1]); dump();
+mov (ecx, ptr[rsi+r9*4+1000]); dump();
+mov (ecx, ptr[rsi+r9*4-1]); dump();
+mov (ecx, ptr[rsi+r9*4-1000]); dump();
+mov (ecx, ptr[rsi+r9*8+0]); dump();
+mov (ecx, ptr[rsi+r9*8+1]); dump();
+mov (ecx, ptr[rsi+r9*8+1000]); dump();
+mov (ecx, ptr[rsi+r9*8-1]); dump();
+mov (ecx, ptr[rsi+r9*8-1000]); dump();
+mov (ecx, ptr[rsi+r10+0]); dump();
+mov (ecx, ptr[rsi+r10+1]); dump();
+mov (ecx, ptr[rsi+r10+1000]); dump();
+mov (ecx, ptr[rsi+r10-1]); dump();
+mov (ecx, ptr[rsi+r10-1000]); dump();
+mov (ecx, ptr[rsi+r10*1+0]); dump();
+mov (ecx, ptr[rsi+r10*1+1]); dump();
+mov (ecx, ptr[rsi+r10*1+1000]); dump();
+mov (ecx, ptr[rsi+r10*1-1]); dump();
+mov (ecx, ptr[rsi+r10*1-1000]); dump();
+mov (ecx, ptr[rsi+r10*2+0]); dump();
+mov (ecx, ptr[rsi+r10*2+1]); dump();
+mov (ecx, ptr[rsi+r10*2+1000]); dump();
+mov (ecx, ptr[rsi+r10*2-1]); dump();
+mov (ecx, ptr[rsi+r10*2-1000]); dump();
+mov (ecx, ptr[rsi+r10*4+0]); dump();
+mov (ecx, ptr[rsi+r10*4+1]); dump();
+mov (ecx, ptr[rsi+r10*4+1000]); dump();
+mov (ecx, ptr[rsi+r10*4-1]); dump();
+mov (ecx, ptr[rsi+r10*4-1000]); dump();
+mov (ecx, ptr[rsi+r10*8+0]); dump();
+mov (ecx, ptr[rsi+r10*8+1]); dump();
+mov (ecx, ptr[rsi+r10*8+1000]); dump();
+mov (ecx, ptr[rsi+r10*8-1]); dump();
+mov (ecx, ptr[rsi+r10*8-1000]); dump();
+mov (ecx, ptr[rsi+r11+0]); dump();
+mov (ecx, ptr[rsi+r11+1]); dump();
+mov (ecx, ptr[rsi+r11+1000]); dump();
+mov (ecx, ptr[rsi+r11-1]); dump();
+mov (ecx, ptr[rsi+r11-1000]); dump();
+mov (ecx, ptr[rsi+r11*1+0]); dump();
+mov (ecx, ptr[rsi+r11*1+1]); dump();
+mov (ecx, ptr[rsi+r11*1+1000]); dump();
+mov (ecx, ptr[rsi+r11*1-1]); dump();
+mov (ecx, ptr[rsi+r11*1-1000]); dump();
+mov (ecx, ptr[rsi+r11*2+0]); dump();
+mov (ecx, ptr[rsi+r11*2+1]); dump();
+mov (ecx, ptr[rsi+r11*2+1000]); dump();
+mov (ecx, ptr[rsi+r11*2-1]); dump();
+mov (ecx, ptr[rsi+r11*2-1000]); dump();
+mov (ecx, ptr[rsi+r11*4+0]); dump();
+mov (ecx, ptr[rsi+r11*4+1]); dump();
+mov (ecx, ptr[rsi+r11*4+1000]); dump();
+mov (ecx, ptr[rsi+r11*4-1]); dump();
+mov (ecx, ptr[rsi+r11*4-1000]); dump();
+mov (ecx, ptr[rsi+r11*8+0]); dump();
+mov (ecx, ptr[rsi+r11*8+1]); dump();
+mov (ecx, ptr[rsi+r11*8+1000]); dump();
+mov (ecx, ptr[rsi+r11*8-1]); dump();
+mov (ecx, ptr[rsi+r11*8-1000]); dump();
+}
+    void gen25(){
+mov (ecx, ptr[rsi+r12+0]); dump();
+mov (ecx, ptr[rsi+r12+1]); dump();
+mov (ecx, ptr[rsi+r12+1000]); dump();
+mov (ecx, ptr[rsi+r12-1]); dump();
+mov (ecx, ptr[rsi+r12-1000]); dump();
+mov (ecx, ptr[rsi+r12*1+0]); dump();
+mov (ecx, ptr[rsi+r12*1+1]); dump();
+mov (ecx, ptr[rsi+r12*1+1000]); dump();
+mov (ecx, ptr[rsi+r12*1-1]); dump();
+mov (ecx, ptr[rsi+r12*1-1000]); dump();
+mov (ecx, ptr[rsi+r12*2+0]); dump();
+mov (ecx, ptr[rsi+r12*2+1]); dump();
+mov (ecx, ptr[rsi+r12*2+1000]); dump();
+mov (ecx, ptr[rsi+r12*2-1]); dump();
+mov (ecx, ptr[rsi+r12*2-1000]); dump();
+mov (ecx, ptr[rsi+r12*4+0]); dump();
+mov (ecx, ptr[rsi+r12*4+1]); dump();
+mov (ecx, ptr[rsi+r12*4+1000]); dump();
+mov (ecx, ptr[rsi+r12*4-1]); dump();
+mov (ecx, ptr[rsi+r12*4-1000]); dump();
+mov (ecx, ptr[rsi+r12*8+0]); dump();
+mov (ecx, ptr[rsi+r12*8+1]); dump();
+mov (ecx, ptr[rsi+r12*8+1000]); dump();
+mov (ecx, ptr[rsi+r12*8-1]); dump();
+mov (ecx, ptr[rsi+r12*8-1000]); dump();
+mov (ecx, ptr[rsi+r13+0]); dump();
+mov (ecx, ptr[rsi+r13+1]); dump();
+mov (ecx, ptr[rsi+r13+1000]); dump();
+mov (ecx, ptr[rsi+r13-1]); dump();
+mov (ecx, ptr[rsi+r13-1000]); dump();
+mov (ecx, ptr[rsi+r13*1+0]); dump();
+mov (ecx, ptr[rsi+r13*1+1]); dump();
+mov (ecx, ptr[rsi+r13*1+1000]); dump();
+mov (ecx, ptr[rsi+r13*1-1]); dump();
+mov (ecx, ptr[rsi+r13*1-1000]); dump();
+mov (ecx, ptr[rsi+r13*2+0]); dump();
+mov (ecx, ptr[rsi+r13*2+1]); dump();
+mov (ecx, ptr[rsi+r13*2+1000]); dump();
+mov (ecx, ptr[rsi+r13*2-1]); dump();
+mov (ecx, ptr[rsi+r13*2-1000]); dump();
+mov (ecx, ptr[rsi+r13*4+0]); dump();
+mov (ecx, ptr[rsi+r13*4+1]); dump();
+mov (ecx, ptr[rsi+r13*4+1000]); dump();
+mov (ecx, ptr[rsi+r13*4-1]); dump();
+mov (ecx, ptr[rsi+r13*4-1000]); dump();
+mov (ecx, ptr[rsi+r13*8+0]); dump();
+mov (ecx, ptr[rsi+r13*8+1]); dump();
+mov (ecx, ptr[rsi+r13*8+1000]); dump();
+mov (ecx, ptr[rsi+r13*8-1]); dump();
+mov (ecx, ptr[rsi+r13*8-1000]); dump();
+mov (ecx, ptr[rsi+r14+0]); dump();
+mov (ecx, ptr[rsi+r14+1]); dump();
+mov (ecx, ptr[rsi+r14+1000]); dump();
+mov (ecx, ptr[rsi+r14-1]); dump();
+mov (ecx, ptr[rsi+r14-1000]); dump();
+mov (ecx, ptr[rsi+r14*1+0]); dump();
+mov (ecx, ptr[rsi+r14*1+1]); dump();
+mov (ecx, ptr[rsi+r14*1+1000]); dump();
+mov (ecx, ptr[rsi+r14*1-1]); dump();
+mov (ecx, ptr[rsi+r14*1-1000]); dump();
+mov (ecx, ptr[rsi+r14*2+0]); dump();
+mov (ecx, ptr[rsi+r14*2+1]); dump();
+mov (ecx, ptr[rsi+r14*2+1000]); dump();
+mov (ecx, ptr[rsi+r14*2-1]); dump();
+mov (ecx, ptr[rsi+r14*2-1000]); dump();
+mov (ecx, ptr[rsi+r14*4+0]); dump();
+mov (ecx, ptr[rsi+r14*4+1]); dump();
+mov (ecx, ptr[rsi+r14*4+1000]); dump();
+mov (ecx, ptr[rsi+r14*4-1]); dump();
+mov (ecx, ptr[rsi+r14*4-1000]); dump();
+mov (ecx, ptr[rsi+r14*8+0]); dump();
+mov (ecx, ptr[rsi+r14*8+1]); dump();
+mov (ecx, ptr[rsi+r14*8+1000]); dump();
+mov (ecx, ptr[rsi+r14*8-1]); dump();
+mov (ecx, ptr[rsi+r14*8-1000]); dump();
+mov (ecx, ptr[rsi+r15+0]); dump();
+mov (ecx, ptr[rsi+r15+1]); dump();
+mov (ecx, ptr[rsi+r15+1000]); dump();
+mov (ecx, ptr[rsi+r15-1]); dump();
+mov (ecx, ptr[rsi+r15-1000]); dump();
+mov (ecx, ptr[rsi+r15*1+0]); dump();
+mov (ecx, ptr[rsi+r15*1+1]); dump();
+mov (ecx, ptr[rsi+r15*1+1000]); dump();
+mov (ecx, ptr[rsi+r15*1-1]); dump();
+mov (ecx, ptr[rsi+r15*1-1000]); dump();
+mov (ecx, ptr[rsi+r15*2+0]); dump();
+mov (ecx, ptr[rsi+r15*2+1]); dump();
+mov (ecx, ptr[rsi+r15*2+1000]); dump();
+mov (ecx, ptr[rsi+r15*2-1]); dump();
+mov (ecx, ptr[rsi+r15*2-1000]); dump();
+mov (ecx, ptr[rsi+r15*4+0]); dump();
+mov (ecx, ptr[rsi+r15*4+1]); dump();
+mov (ecx, ptr[rsi+r15*4+1000]); dump();
+mov (ecx, ptr[rsi+r15*4-1]); dump();
+mov (ecx, ptr[rsi+r15*4-1000]); dump();
+mov (ecx, ptr[rsi+r15*8+0]); dump();
+mov (ecx, ptr[rsi+r15*8+1]); dump();
+mov (ecx, ptr[rsi+r15*8+1000]); dump();
+mov (ecx, ptr[rsi+r15*8-1]); dump();
+mov (ecx, ptr[rsi+r15*8-1000]); dump();
+}
+    void gen26(){
+mov (ecx, ptr[rsi+0]); dump();
+mov (ecx, ptr[rsi+1]); dump();
+mov (ecx, ptr[rsi+1000]); dump();
+mov (ecx, ptr[rsi-1]); dump();
+mov (ecx, ptr[rsi-1000]); dump();
+mov (ecx, ptr[rsi+0]); dump();
+mov (ecx, ptr[rsi+1]); dump();
+mov (ecx, ptr[rsi+1000]); dump();
+mov (ecx, ptr[rsi-1]); dump();
+mov (ecx, ptr[rsi-1000]); dump();
+mov (ecx, ptr[rsi+0]); dump();
+mov (ecx, ptr[rsi+1]); dump();
+mov (ecx, ptr[rsi+1000]); dump();
+mov (ecx, ptr[rsi-1]); dump();
+mov (ecx, ptr[rsi-1000]); dump();
+mov (ecx, ptr[rsi+0]); dump();
+mov (ecx, ptr[rsi+1]); dump();
+mov (ecx, ptr[rsi+1000]); dump();
+mov (ecx, ptr[rsi-1]); dump();
+mov (ecx, ptr[rsi-1000]); dump();
+mov (ecx, ptr[rsi+0]); dump();
+mov (ecx, ptr[rsi+1]); dump();
+mov (ecx, ptr[rsi+1000]); dump();
+mov (ecx, ptr[rsi-1]); dump();
+mov (ecx, ptr[rsi-1000]); dump();
+mov (ecx, ptr[rdi+rax+0]); dump();
+mov (ecx, ptr[rdi+rax+1]); dump();
+mov (ecx, ptr[rdi+rax+1000]); dump();
+mov (ecx, ptr[rdi+rax-1]); dump();
+mov (ecx, ptr[rdi+rax-1000]); dump();
+mov (ecx, ptr[rdi+rax*1+0]); dump();
+mov (ecx, ptr[rdi+rax*1+1]); dump();
+mov (ecx, ptr[rdi+rax*1+1000]); dump();
+mov (ecx, ptr[rdi+rax*1-1]); dump();
+mov (ecx, ptr[rdi+rax*1-1000]); dump();
+mov (ecx, ptr[rdi+rax*2+0]); dump();
+mov (ecx, ptr[rdi+rax*2+1]); dump();
+mov (ecx, ptr[rdi+rax*2+1000]); dump();
+mov (ecx, ptr[rdi+rax*2-1]); dump();
+mov (ecx, ptr[rdi+rax*2-1000]); dump();
+mov (ecx, ptr[rdi+rax*4+0]); dump();
+mov (ecx, ptr[rdi+rax*4+1]); dump();
+mov (ecx, ptr[rdi+rax*4+1000]); dump();
+mov (ecx, ptr[rdi+rax*4-1]); dump();
+mov (ecx, ptr[rdi+rax*4-1000]); dump();
+mov (ecx, ptr[rdi+rax*8+0]); dump();
+mov (ecx, ptr[rdi+rax*8+1]); dump();
+mov (ecx, ptr[rdi+rax*8+1000]); dump();
+mov (ecx, ptr[rdi+rax*8-1]); dump();
+mov (ecx, ptr[rdi+rax*8-1000]); dump();
+mov (ecx, ptr[rdi+rcx+0]); dump();
+mov (ecx, ptr[rdi+rcx+1]); dump();
+mov (ecx, ptr[rdi+rcx+1000]); dump();
+mov (ecx, ptr[rdi+rcx-1]); dump();
+mov (ecx, ptr[rdi+rcx-1000]); dump();
+mov (ecx, ptr[rdi+rcx*1+0]); dump();
+mov (ecx, ptr[rdi+rcx*1+1]); dump();
+mov (ecx, ptr[rdi+rcx*1+1000]); dump();
+mov (ecx, ptr[rdi+rcx*1-1]); dump();
+mov (ecx, ptr[rdi+rcx*1-1000]); dump();
+mov (ecx, ptr[rdi+rcx*2+0]); dump();
+mov (ecx, ptr[rdi+rcx*2+1]); dump();
+mov (ecx, ptr[rdi+rcx*2+1000]); dump();
+mov (ecx, ptr[rdi+rcx*2-1]); dump();
+mov (ecx, ptr[rdi+rcx*2-1000]); dump();
+mov (ecx, ptr[rdi+rcx*4+0]); dump();
+mov (ecx, ptr[rdi+rcx*4+1]); dump();
+mov (ecx, ptr[rdi+rcx*4+1000]); dump();
+mov (ecx, ptr[rdi+rcx*4-1]); dump();
+mov (ecx, ptr[rdi+rcx*4-1000]); dump();
+mov (ecx, ptr[rdi+rcx*8+0]); dump();
+mov (ecx, ptr[rdi+rcx*8+1]); dump();
+mov (ecx, ptr[rdi+rcx*8+1000]); dump();
+mov (ecx, ptr[rdi+rcx*8-1]); dump();
+mov (ecx, ptr[rdi+rcx*8-1000]); dump();
+mov (ecx, ptr[rdi+rdx+0]); dump();
+mov (ecx, ptr[rdi+rdx+1]); dump();
+mov (ecx, ptr[rdi+rdx+1000]); dump();
+mov (ecx, ptr[rdi+rdx-1]); dump();
+mov (ecx, ptr[rdi+rdx-1000]); dump();
+mov (ecx, ptr[rdi+rdx*1+0]); dump();
+mov (ecx, ptr[rdi+rdx*1+1]); dump();
+mov (ecx, ptr[rdi+rdx*1+1000]); dump();
+mov (ecx, ptr[rdi+rdx*1-1]); dump();
+mov (ecx, ptr[rdi+rdx*1-1000]); dump();
+mov (ecx, ptr[rdi+rdx*2+0]); dump();
+mov (ecx, ptr[rdi+rdx*2+1]); dump();
+mov (ecx, ptr[rdi+rdx*2+1000]); dump();
+mov (ecx, ptr[rdi+rdx*2-1]); dump();
+mov (ecx, ptr[rdi+rdx*2-1000]); dump();
+mov (ecx, ptr[rdi+rdx*4+0]); dump();
+mov (ecx, ptr[rdi+rdx*4+1]); dump();
+mov (ecx, ptr[rdi+rdx*4+1000]); dump();
+mov (ecx, ptr[rdi+rdx*4-1]); dump();
+mov (ecx, ptr[rdi+rdx*4-1000]); dump();
+mov (ecx, ptr[rdi+rdx*8+0]); dump();
+mov (ecx, ptr[rdi+rdx*8+1]); dump();
+mov (ecx, ptr[rdi+rdx*8+1000]); dump();
+mov (ecx, ptr[rdi+rdx*8-1]); dump();
+mov (ecx, ptr[rdi+rdx*8-1000]); dump();
+}
+    void gen27(){
+mov (ecx, ptr[rdi+rbx+0]); dump();
+mov (ecx, ptr[rdi+rbx+1]); dump();
+mov (ecx, ptr[rdi+rbx+1000]); dump();
+mov (ecx, ptr[rdi+rbx-1]); dump();
+mov (ecx, ptr[rdi+rbx-1000]); dump();
+mov (ecx, ptr[rdi+rbx*1+0]); dump();
+mov (ecx, ptr[rdi+rbx*1+1]); dump();
+mov (ecx, ptr[rdi+rbx*1+1000]); dump();
+mov (ecx, ptr[rdi+rbx*1-1]); dump();
+mov (ecx, ptr[rdi+rbx*1-1000]); dump();
+mov (ecx, ptr[rdi+rbx*2+0]); dump();
+mov (ecx, ptr[rdi+rbx*2+1]); dump();
+mov (ecx, ptr[rdi+rbx*2+1000]); dump();
+mov (ecx, ptr[rdi+rbx*2-1]); dump();
+mov (ecx, ptr[rdi+rbx*2-1000]); dump();
+mov (ecx, ptr[rdi+rbx*4+0]); dump();
+mov (ecx, ptr[rdi+rbx*4+1]); dump();
+mov (ecx, ptr[rdi+rbx*4+1000]); dump();
+mov (ecx, ptr[rdi+rbx*4-1]); dump();
+mov (ecx, ptr[rdi+rbx*4-1000]); dump();
+mov (ecx, ptr[rdi+rbx*8+0]); dump();
+mov (ecx, ptr[rdi+rbx*8+1]); dump();
+mov (ecx, ptr[rdi+rbx*8+1000]); dump();
+mov (ecx, ptr[rdi+rbx*8-1]); dump();
+mov (ecx, ptr[rdi+rbx*8-1000]); dump();
+mov (ecx, ptr[rdi+rbp+0]); dump();
+mov (ecx, ptr[rdi+rbp+1]); dump();
+mov (ecx, ptr[rdi+rbp+1000]); dump();
+mov (ecx, ptr[rdi+rbp-1]); dump();
+mov (ecx, ptr[rdi+rbp-1000]); dump();
+mov (ecx, ptr[rdi+rbp*1+0]); dump();
+mov (ecx, ptr[rdi+rbp*1+1]); dump();
+mov (ecx, ptr[rdi+rbp*1+1000]); dump();
+mov (ecx, ptr[rdi+rbp*1-1]); dump();
+mov (ecx, ptr[rdi+rbp*1-1000]); dump();
+mov (ecx, ptr[rdi+rbp*2+0]); dump();
+mov (ecx, ptr[rdi+rbp*2+1]); dump();
+mov (ecx, ptr[rdi+rbp*2+1000]); dump();
+mov (ecx, ptr[rdi+rbp*2-1]); dump();
+mov (ecx, ptr[rdi+rbp*2-1000]); dump();
+mov (ecx, ptr[rdi+rbp*4+0]); dump();
+mov (ecx, ptr[rdi+rbp*4+1]); dump();
+mov (ecx, ptr[rdi+rbp*4+1000]); dump();
+mov (ecx, ptr[rdi+rbp*4-1]); dump();
+mov (ecx, ptr[rdi+rbp*4-1000]); dump();
+mov (ecx, ptr[rdi+rbp*8+0]); dump();
+mov (ecx, ptr[rdi+rbp*8+1]); dump();
+mov (ecx, ptr[rdi+rbp*8+1000]); dump();
+mov (ecx, ptr[rdi+rbp*8-1]); dump();
+mov (ecx, ptr[rdi+rbp*8-1000]); dump();
+mov (ecx, ptr[rdi+rsi+0]); dump();
+mov (ecx, ptr[rdi+rsi+1]); dump();
+mov (ecx, ptr[rdi+rsi+1000]); dump();
+mov (ecx, ptr[rdi+rsi-1]); dump();
+mov (ecx, ptr[rdi+rsi-1000]); dump();
+mov (ecx, ptr[rdi+rsi*1+0]); dump();
+mov (ecx, ptr[rdi+rsi*1+1]); dump();
+mov (ecx, ptr[rdi+rsi*1+1000]); dump();
+mov (ecx, ptr[rdi+rsi*1-1]); dump();
+mov (ecx, ptr[rdi+rsi*1-1000]); dump();
+mov (ecx, ptr[rdi+rsi*2+0]); dump();
+mov (ecx, ptr[rdi+rsi*2+1]); dump();
+mov (ecx, ptr[rdi+rsi*2+1000]); dump();
+mov (ecx, ptr[rdi+rsi*2-1]); dump();
+mov (ecx, ptr[rdi+rsi*2-1000]); dump();
+mov (ecx, ptr[rdi+rsi*4+0]); dump();
+mov (ecx, ptr[rdi+rsi*4+1]); dump();
+mov (ecx, ptr[rdi+rsi*4+1000]); dump();
+mov (ecx, ptr[rdi+rsi*4-1]); dump();
+mov (ecx, ptr[rdi+rsi*4-1000]); dump();
+mov (ecx, ptr[rdi+rsi*8+0]); dump();
+mov (ecx, ptr[rdi+rsi*8+1]); dump();
+mov (ecx, ptr[rdi+rsi*8+1000]); dump();
+mov (ecx, ptr[rdi+rsi*8-1]); dump();
+mov (ecx, ptr[rdi+rsi*8-1000]); dump();
+mov (ecx, ptr[rdi+rdi+0]); dump();
+mov (ecx, ptr[rdi+rdi+1]); dump();
+mov (ecx, ptr[rdi+rdi+1000]); dump();
+mov (ecx, ptr[rdi+rdi-1]); dump();
+mov (ecx, ptr[rdi+rdi-1000]); dump();
+mov (ecx, ptr[rdi+rdi*1+0]); dump();
+mov (ecx, ptr[rdi+rdi*1+1]); dump();
+mov (ecx, ptr[rdi+rdi*1+1000]); dump();
+mov (ecx, ptr[rdi+rdi*1-1]); dump();
+mov (ecx, ptr[rdi+rdi*1-1000]); dump();
+mov (ecx, ptr[rdi+rdi*2+0]); dump();
+mov (ecx, ptr[rdi+rdi*2+1]); dump();
+mov (ecx, ptr[rdi+rdi*2+1000]); dump();
+mov (ecx, ptr[rdi+rdi*2-1]); dump();
+mov (ecx, ptr[rdi+rdi*2-1000]); dump();
+mov (ecx, ptr[rdi+rdi*4+0]); dump();
+mov (ecx, ptr[rdi+rdi*4+1]); dump();
+mov (ecx, ptr[rdi+rdi*4+1000]); dump();
+mov (ecx, ptr[rdi+rdi*4-1]); dump();
+mov (ecx, ptr[rdi+rdi*4-1000]); dump();
+mov (ecx, ptr[rdi+rdi*8+0]); dump();
+mov (ecx, ptr[rdi+rdi*8+1]); dump();
+mov (ecx, ptr[rdi+rdi*8+1000]); dump();
+mov (ecx, ptr[rdi+rdi*8-1]); dump();
+mov (ecx, ptr[rdi+rdi*8-1000]); dump();
+}
+    void gen28(){
+mov (ecx, ptr[rdi+r9+0]); dump();
+mov (ecx, ptr[rdi+r9+1]); dump();
+mov (ecx, ptr[rdi+r9+1000]); dump();
+mov (ecx, ptr[rdi+r9-1]); dump();
+mov (ecx, ptr[rdi+r9-1000]); dump();
+mov (ecx, ptr[rdi+r9*1+0]); dump();
+mov (ecx, ptr[rdi+r9*1+1]); dump();
+mov (ecx, ptr[rdi+r9*1+1000]); dump();
+mov (ecx, ptr[rdi+r9*1-1]); dump();
+mov (ecx, ptr[rdi+r9*1-1000]); dump();
+mov (ecx, ptr[rdi+r9*2+0]); dump();
+mov (ecx, ptr[rdi+r9*2+1]); dump();
+mov (ecx, ptr[rdi+r9*2+1000]); dump();
+mov (ecx, ptr[rdi+r9*2-1]); dump();
+mov (ecx, ptr[rdi+r9*2-1000]); dump();
+mov (ecx, ptr[rdi+r9*4+0]); dump();
+mov (ecx, ptr[rdi+r9*4+1]); dump();
+mov (ecx, ptr[rdi+r9*4+1000]); dump();
+mov (ecx, ptr[rdi+r9*4-1]); dump();
+mov (ecx, ptr[rdi+r9*4-1000]); dump();
+mov (ecx, ptr[rdi+r9*8+0]); dump();
+mov (ecx, ptr[rdi+r9*8+1]); dump();
+mov (ecx, ptr[rdi+r9*8+1000]); dump();
+mov (ecx, ptr[rdi+r9*8-1]); dump();
+mov (ecx, ptr[rdi+r9*8-1000]); dump();
+mov (ecx, ptr[rdi+r10+0]); dump();
+mov (ecx, ptr[rdi+r10+1]); dump();
+mov (ecx, ptr[rdi+r10+1000]); dump();
+mov (ecx, ptr[rdi+r10-1]); dump();
+mov (ecx, ptr[rdi+r10-1000]); dump();
+mov (ecx, ptr[rdi+r10*1+0]); dump();
+mov (ecx, ptr[rdi+r10*1+1]); dump();
+mov (ecx, ptr[rdi+r10*1+1000]); dump();
+mov (ecx, ptr[rdi+r10*1-1]); dump();
+mov (ecx, ptr[rdi+r10*1-1000]); dump();
+mov (ecx, ptr[rdi+r10*2+0]); dump();
+mov (ecx, ptr[rdi+r10*2+1]); dump();
+mov (ecx, ptr[rdi+r10*2+1000]); dump();
+mov (ecx, ptr[rdi+r10*2-1]); dump();
+mov (ecx, ptr[rdi+r10*2-1000]); dump();
+mov (ecx, ptr[rdi+r10*4+0]); dump();
+mov (ecx, ptr[rdi+r10*4+1]); dump();
+mov (ecx, ptr[rdi+r10*4+1000]); dump();
+mov (ecx, ptr[rdi+r10*4-1]); dump();
+mov (ecx, ptr[rdi+r10*4-1000]); dump();
+mov (ecx, ptr[rdi+r10*8+0]); dump();
+mov (ecx, ptr[rdi+r10*8+1]); dump();
+mov (ecx, ptr[rdi+r10*8+1000]); dump();
+mov (ecx, ptr[rdi+r10*8-1]); dump();
+mov (ecx, ptr[rdi+r10*8-1000]); dump();
+mov (ecx, ptr[rdi+r11+0]); dump();
+mov (ecx, ptr[rdi+r11+1]); dump();
+mov (ecx, ptr[rdi+r11+1000]); dump();
+mov (ecx, ptr[rdi+r11-1]); dump();
+mov (ecx, ptr[rdi+r11-1000]); dump();
+mov (ecx, ptr[rdi+r11*1+0]); dump();
+mov (ecx, ptr[rdi+r11*1+1]); dump();
+mov (ecx, ptr[rdi+r11*1+1000]); dump();
+mov (ecx, ptr[rdi+r11*1-1]); dump();
+mov (ecx, ptr[rdi+r11*1-1000]); dump();
+mov (ecx, ptr[rdi+r11*2+0]); dump();
+mov (ecx, ptr[rdi+r11*2+1]); dump();
+mov (ecx, ptr[rdi+r11*2+1000]); dump();
+mov (ecx, ptr[rdi+r11*2-1]); dump();
+mov (ecx, ptr[rdi+r11*2-1000]); dump();
+mov (ecx, ptr[rdi+r11*4+0]); dump();
+mov (ecx, ptr[rdi+r11*4+1]); dump();
+mov (ecx, ptr[rdi+r11*4+1000]); dump();
+mov (ecx, ptr[rdi+r11*4-1]); dump();
+mov (ecx, ptr[rdi+r11*4-1000]); dump();
+mov (ecx, ptr[rdi+r11*8+0]); dump();
+mov (ecx, ptr[rdi+r11*8+1]); dump();
+mov (ecx, ptr[rdi+r11*8+1000]); dump();
+mov (ecx, ptr[rdi+r11*8-1]); dump();
+mov (ecx, ptr[rdi+r11*8-1000]); dump();
+mov (ecx, ptr[rdi+r12+0]); dump();
+mov (ecx, ptr[rdi+r12+1]); dump();
+mov (ecx, ptr[rdi+r12+1000]); dump();
+mov (ecx, ptr[rdi+r12-1]); dump();
+mov (ecx, ptr[rdi+r12-1000]); dump();
+mov (ecx, ptr[rdi+r12*1+0]); dump();
+mov (ecx, ptr[rdi+r12*1+1]); dump();
+mov (ecx, ptr[rdi+r12*1+1000]); dump();
+mov (ecx, ptr[rdi+r12*1-1]); dump();
+mov (ecx, ptr[rdi+r12*1-1000]); dump();
+mov (ecx, ptr[rdi+r12*2+0]); dump();
+mov (ecx, ptr[rdi+r12*2+1]); dump();
+mov (ecx, ptr[rdi+r12*2+1000]); dump();
+mov (ecx, ptr[rdi+r12*2-1]); dump();
+mov (ecx, ptr[rdi+r12*2-1000]); dump();
+mov (ecx, ptr[rdi+r12*4+0]); dump();
+mov (ecx, ptr[rdi+r12*4+1]); dump();
+mov (ecx, ptr[rdi+r12*4+1000]); dump();
+mov (ecx, ptr[rdi+r12*4-1]); dump();
+mov (ecx, ptr[rdi+r12*4-1000]); dump();
+mov (ecx, ptr[rdi+r12*8+0]); dump();
+mov (ecx, ptr[rdi+r12*8+1]); dump();
+mov (ecx, ptr[rdi+r12*8+1000]); dump();
+mov (ecx, ptr[rdi+r12*8-1]); dump();
+mov (ecx, ptr[rdi+r12*8-1000]); dump();
+}
+    void gen29(){
+mov (ecx, ptr[rdi+r13+0]); dump();
+mov (ecx, ptr[rdi+r13+1]); dump();
+mov (ecx, ptr[rdi+r13+1000]); dump();
+mov (ecx, ptr[rdi+r13-1]); dump();
+mov (ecx, ptr[rdi+r13-1000]); dump();
+mov (ecx, ptr[rdi+r13*1+0]); dump();
+mov (ecx, ptr[rdi+r13*1+1]); dump();
+mov (ecx, ptr[rdi+r13*1+1000]); dump();
+mov (ecx, ptr[rdi+r13*1-1]); dump();
+mov (ecx, ptr[rdi+r13*1-1000]); dump();
+mov (ecx, ptr[rdi+r13*2+0]); dump();
+mov (ecx, ptr[rdi+r13*2+1]); dump();
+mov (ecx, ptr[rdi+r13*2+1000]); dump();
+mov (ecx, ptr[rdi+r13*2-1]); dump();
+mov (ecx, ptr[rdi+r13*2-1000]); dump();
+mov (ecx, ptr[rdi+r13*4+0]); dump();
+mov (ecx, ptr[rdi+r13*4+1]); dump();
+mov (ecx, ptr[rdi+r13*4+1000]); dump();
+mov (ecx, ptr[rdi+r13*4-1]); dump();
+mov (ecx, ptr[rdi+r13*4-1000]); dump();
+mov (ecx, ptr[rdi+r13*8+0]); dump();
+mov (ecx, ptr[rdi+r13*8+1]); dump();
+mov (ecx, ptr[rdi+r13*8+1000]); dump();
+mov (ecx, ptr[rdi+r13*8-1]); dump();
+mov (ecx, ptr[rdi+r13*8-1000]); dump();
+mov (ecx, ptr[rdi+r14+0]); dump();
+mov (ecx, ptr[rdi+r14+1]); dump();
+mov (ecx, ptr[rdi+r14+1000]); dump();
+mov (ecx, ptr[rdi+r14-1]); dump();
+mov (ecx, ptr[rdi+r14-1000]); dump();
+mov (ecx, ptr[rdi+r14*1+0]); dump();
+mov (ecx, ptr[rdi+r14*1+1]); dump();
+mov (ecx, ptr[rdi+r14*1+1000]); dump();
+mov (ecx, ptr[rdi+r14*1-1]); dump();
+mov (ecx, ptr[rdi+r14*1-1000]); dump();
+mov (ecx, ptr[rdi+r14*2+0]); dump();
+mov (ecx, ptr[rdi+r14*2+1]); dump();
+mov (ecx, ptr[rdi+r14*2+1000]); dump();
+mov (ecx, ptr[rdi+r14*2-1]); dump();
+mov (ecx, ptr[rdi+r14*2-1000]); dump();
+mov (ecx, ptr[rdi+r14*4+0]); dump();
+mov (ecx, ptr[rdi+r14*4+1]); dump();
+mov (ecx, ptr[rdi+r14*4+1000]); dump();
+mov (ecx, ptr[rdi+r14*4-1]); dump();
+mov (ecx, ptr[rdi+r14*4-1000]); dump();
+mov (ecx, ptr[rdi+r14*8+0]); dump();
+mov (ecx, ptr[rdi+r14*8+1]); dump();
+mov (ecx, ptr[rdi+r14*8+1000]); dump();
+mov (ecx, ptr[rdi+r14*8-1]); dump();
+mov (ecx, ptr[rdi+r14*8-1000]); dump();
+mov (ecx, ptr[rdi+r15+0]); dump();
+mov (ecx, ptr[rdi+r15+1]); dump();
+mov (ecx, ptr[rdi+r15+1000]); dump();
+mov (ecx, ptr[rdi+r15-1]); dump();
+mov (ecx, ptr[rdi+r15-1000]); dump();
+mov (ecx, ptr[rdi+r15*1+0]); dump();
+mov (ecx, ptr[rdi+r15*1+1]); dump();
+mov (ecx, ptr[rdi+r15*1+1000]); dump();
+mov (ecx, ptr[rdi+r15*1-1]); dump();
+mov (ecx, ptr[rdi+r15*1-1000]); dump();
+mov (ecx, ptr[rdi+r15*2+0]); dump();
+mov (ecx, ptr[rdi+r15*2+1]); dump();
+mov (ecx, ptr[rdi+r15*2+1000]); dump();
+mov (ecx, ptr[rdi+r15*2-1]); dump();
+mov (ecx, ptr[rdi+r15*2-1000]); dump();
+mov (ecx, ptr[rdi+r15*4+0]); dump();
+mov (ecx, ptr[rdi+r15*4+1]); dump();
+mov (ecx, ptr[rdi+r15*4+1000]); dump();
+mov (ecx, ptr[rdi+r15*4-1]); dump();
+mov (ecx, ptr[rdi+r15*4-1000]); dump();
+mov (ecx, ptr[rdi+r15*8+0]); dump();
+mov (ecx, ptr[rdi+r15*8+1]); dump();
+mov (ecx, ptr[rdi+r15*8+1000]); dump();
+mov (ecx, ptr[rdi+r15*8-1]); dump();
+mov (ecx, ptr[rdi+r15*8-1000]); dump();
+mov (ecx, ptr[rdi+0]); dump();
+mov (ecx, ptr[rdi+1]); dump();
+mov (ecx, ptr[rdi+1000]); dump();
+mov (ecx, ptr[rdi-1]); dump();
+mov (ecx, ptr[rdi-1000]); dump();
+mov (ecx, ptr[rdi+0]); dump();
+mov (ecx, ptr[rdi+1]); dump();
+mov (ecx, ptr[rdi+1000]); dump();
+mov (ecx, ptr[rdi-1]); dump();
+mov (ecx, ptr[rdi-1000]); dump();
+mov (ecx, ptr[rdi+0]); dump();
+mov (ecx, ptr[rdi+1]); dump();
+mov (ecx, ptr[rdi+1000]); dump();
+mov (ecx, ptr[rdi-1]); dump();
+mov (ecx, ptr[rdi-1000]); dump();
+mov (ecx, ptr[rdi+0]); dump();
+mov (ecx, ptr[rdi+1]); dump();
+mov (ecx, ptr[rdi+1000]); dump();
+mov (ecx, ptr[rdi-1]); dump();
+mov (ecx, ptr[rdi-1000]); dump();
+mov (ecx, ptr[rdi+0]); dump();
+mov (ecx, ptr[rdi+1]); dump();
+mov (ecx, ptr[rdi+1000]); dump();
+mov (ecx, ptr[rdi-1]); dump();
+mov (ecx, ptr[rdi-1000]); dump();
+}
+    void gen30(){
+mov (ecx, ptr[r9+rax+0]); dump();
+mov (ecx, ptr[r9+rax+1]); dump();
+mov (ecx, ptr[r9+rax+1000]); dump();
+mov (ecx, ptr[r9+rax-1]); dump();
+mov (ecx, ptr[r9+rax-1000]); dump();
+mov (ecx, ptr[r9+rax*1+0]); dump();
+mov (ecx, ptr[r9+rax*1+1]); dump();
+mov (ecx, ptr[r9+rax*1+1000]); dump();
+mov (ecx, ptr[r9+rax*1-1]); dump();
+mov (ecx, ptr[r9+rax*1-1000]); dump();
+mov (ecx, ptr[r9+rax*2+0]); dump();
+mov (ecx, ptr[r9+rax*2+1]); dump();
+mov (ecx, ptr[r9+rax*2+1000]); dump();
+mov (ecx, ptr[r9+rax*2-1]); dump();
+mov (ecx, ptr[r9+rax*2-1000]); dump();
+mov (ecx, ptr[r9+rax*4+0]); dump();
+mov (ecx, ptr[r9+rax*4+1]); dump();
+mov (ecx, ptr[r9+rax*4+1000]); dump();
+mov (ecx, ptr[r9+rax*4-1]); dump();
+mov (ecx, ptr[r9+rax*4-1000]); dump();
+mov (ecx, ptr[r9+rax*8+0]); dump();
+mov (ecx, ptr[r9+rax*8+1]); dump();
+mov (ecx, ptr[r9+rax*8+1000]); dump();
+mov (ecx, ptr[r9+rax*8-1]); dump();
+mov (ecx, ptr[r9+rax*8-1000]); dump();
+mov (ecx, ptr[r9+rcx+0]); dump();
+mov (ecx, ptr[r9+rcx+1]); dump();
+mov (ecx, ptr[r9+rcx+1000]); dump();
+mov (ecx, ptr[r9+rcx-1]); dump();
+mov (ecx, ptr[r9+rcx-1000]); dump();
+mov (ecx, ptr[r9+rcx*1+0]); dump();
+mov (ecx, ptr[r9+rcx*1+1]); dump();
+mov (ecx, ptr[r9+rcx*1+1000]); dump();
+mov (ecx, ptr[r9+rcx*1-1]); dump();
+mov (ecx, ptr[r9+rcx*1-1000]); dump();
+mov (ecx, ptr[r9+rcx*2+0]); dump();
+mov (ecx, ptr[r9+rcx*2+1]); dump();
+mov (ecx, ptr[r9+rcx*2+1000]); dump();
+mov (ecx, ptr[r9+rcx*2-1]); dump();
+mov (ecx, ptr[r9+rcx*2-1000]); dump();
+mov (ecx, ptr[r9+rcx*4+0]); dump();
+mov (ecx, ptr[r9+rcx*4+1]); dump();
+mov (ecx, ptr[r9+rcx*4+1000]); dump();
+mov (ecx, ptr[r9+rcx*4-1]); dump();
+mov (ecx, ptr[r9+rcx*4-1000]); dump();
+mov (ecx, ptr[r9+rcx*8+0]); dump();
+mov (ecx, ptr[r9+rcx*8+1]); dump();
+mov (ecx, ptr[r9+rcx*8+1000]); dump();
+mov (ecx, ptr[r9+rcx*8-1]); dump();
+mov (ecx, ptr[r9+rcx*8-1000]); dump();
+mov (ecx, ptr[r9+rdx+0]); dump();
+mov (ecx, ptr[r9+rdx+1]); dump();
+mov (ecx, ptr[r9+rdx+1000]); dump();
+mov (ecx, ptr[r9+rdx-1]); dump();
+mov (ecx, ptr[r9+rdx-1000]); dump();
+mov (ecx, ptr[r9+rdx*1+0]); dump();
+mov (ecx, ptr[r9+rdx*1+1]); dump();
+mov (ecx, ptr[r9+rdx*1+1000]); dump();
+mov (ecx, ptr[r9+rdx*1-1]); dump();
+mov (ecx, ptr[r9+rdx*1-1000]); dump();
+mov (ecx, ptr[r9+rdx*2+0]); dump();
+mov (ecx, ptr[r9+rdx*2+1]); dump();
+mov (ecx, ptr[r9+rdx*2+1000]); dump();
+mov (ecx, ptr[r9+rdx*2-1]); dump();
+mov (ecx, ptr[r9+rdx*2-1000]); dump();
+mov (ecx, ptr[r9+rdx*4+0]); dump();
+mov (ecx, ptr[r9+rdx*4+1]); dump();
+mov (ecx, ptr[r9+rdx*4+1000]); dump();
+mov (ecx, ptr[r9+rdx*4-1]); dump();
+mov (ecx, ptr[r9+rdx*4-1000]); dump();
+mov (ecx, ptr[r9+rdx*8+0]); dump();
+mov (ecx, ptr[r9+rdx*8+1]); dump();
+mov (ecx, ptr[r9+rdx*8+1000]); dump();
+mov (ecx, ptr[r9+rdx*8-1]); dump();
+mov (ecx, ptr[r9+rdx*8-1000]); dump();
+mov (ecx, ptr[r9+rbx+0]); dump();
+mov (ecx, ptr[r9+rbx+1]); dump();
+mov (ecx, ptr[r9+rbx+1000]); dump();
+mov (ecx, ptr[r9+rbx-1]); dump();
+mov (ecx, ptr[r9+rbx-1000]); dump();
+mov (ecx, ptr[r9+rbx*1+0]); dump();
+mov (ecx, ptr[r9+rbx*1+1]); dump();
+mov (ecx, ptr[r9+rbx*1+1000]); dump();
+mov (ecx, ptr[r9+rbx*1-1]); dump();
+mov (ecx, ptr[r9+rbx*1-1000]); dump();
+mov (ecx, ptr[r9+rbx*2+0]); dump();
+mov (ecx, ptr[r9+rbx*2+1]); dump();
+mov (ecx, ptr[r9+rbx*2+1000]); dump();
+mov (ecx, ptr[r9+rbx*2-1]); dump();
+mov (ecx, ptr[r9+rbx*2-1000]); dump();
+mov (ecx, ptr[r9+rbx*4+0]); dump();
+mov (ecx, ptr[r9+rbx*4+1]); dump();
+mov (ecx, ptr[r9+rbx*4+1000]); dump();
+mov (ecx, ptr[r9+rbx*4-1]); dump();
+mov (ecx, ptr[r9+rbx*4-1000]); dump();
+mov (ecx, ptr[r9+rbx*8+0]); dump();
+mov (ecx, ptr[r9+rbx*8+1]); dump();
+mov (ecx, ptr[r9+rbx*8+1000]); dump();
+mov (ecx, ptr[r9+rbx*8-1]); dump();
+mov (ecx, ptr[r9+rbx*8-1000]); dump();
+}
+    void gen31(){
+mov (ecx, ptr[r9+rbp+0]); dump();
+mov (ecx, ptr[r9+rbp+1]); dump();
+mov (ecx, ptr[r9+rbp+1000]); dump();
+mov (ecx, ptr[r9+rbp-1]); dump();
+mov (ecx, ptr[r9+rbp-1000]); dump();
+mov (ecx, ptr[r9+rbp*1+0]); dump();
+mov (ecx, ptr[r9+rbp*1+1]); dump();
+mov (ecx, ptr[r9+rbp*1+1000]); dump();
+mov (ecx, ptr[r9+rbp*1-1]); dump();
+mov (ecx, ptr[r9+rbp*1-1000]); dump();
+mov (ecx, ptr[r9+rbp*2+0]); dump();
+mov (ecx, ptr[r9+rbp*2+1]); dump();
+mov (ecx, ptr[r9+rbp*2+1000]); dump();
+mov (ecx, ptr[r9+rbp*2-1]); dump();
+mov (ecx, ptr[r9+rbp*2-1000]); dump();
+mov (ecx, ptr[r9+rbp*4+0]); dump();
+mov (ecx, ptr[r9+rbp*4+1]); dump();
+mov (ecx, ptr[r9+rbp*4+1000]); dump();
+mov (ecx, ptr[r9+rbp*4-1]); dump();
+mov (ecx, ptr[r9+rbp*4-1000]); dump();
+mov (ecx, ptr[r9+rbp*8+0]); dump();
+mov (ecx, ptr[r9+rbp*8+1]); dump();
+mov (ecx, ptr[r9+rbp*8+1000]); dump();
+mov (ecx, ptr[r9+rbp*8-1]); dump();
+mov (ecx, ptr[r9+rbp*8-1000]); dump();
+mov (ecx, ptr[r9+rsi+0]); dump();
+mov (ecx, ptr[r9+rsi+1]); dump();
+mov (ecx, ptr[r9+rsi+1000]); dump();
+mov (ecx, ptr[r9+rsi-1]); dump();
+mov (ecx, ptr[r9+rsi-1000]); dump();
+mov (ecx, ptr[r9+rsi*1+0]); dump();
+mov (ecx, ptr[r9+rsi*1+1]); dump();
+mov (ecx, ptr[r9+rsi*1+1000]); dump();
+mov (ecx, ptr[r9+rsi*1-1]); dump();
+mov (ecx, ptr[r9+rsi*1-1000]); dump();
+mov (ecx, ptr[r9+rsi*2+0]); dump();
+mov (ecx, ptr[r9+rsi*2+1]); dump();
+mov (ecx, ptr[r9+rsi*2+1000]); dump();
+mov (ecx, ptr[r9+rsi*2-1]); dump();
+mov (ecx, ptr[r9+rsi*2-1000]); dump();
+mov (ecx, ptr[r9+rsi*4+0]); dump();
+mov (ecx, ptr[r9+rsi*4+1]); dump();
+mov (ecx, ptr[r9+rsi*4+1000]); dump();
+mov (ecx, ptr[r9+rsi*4-1]); dump();
+mov (ecx, ptr[r9+rsi*4-1000]); dump();
+mov (ecx, ptr[r9+rsi*8+0]); dump();
+mov (ecx, ptr[r9+rsi*8+1]); dump();
+mov (ecx, ptr[r9+rsi*8+1000]); dump();
+mov (ecx, ptr[r9+rsi*8-1]); dump();
+mov (ecx, ptr[r9+rsi*8-1000]); dump();
+mov (ecx, ptr[r9+rdi+0]); dump();
+mov (ecx, ptr[r9+rdi+1]); dump();
+mov (ecx, ptr[r9+rdi+1000]); dump();
+mov (ecx, ptr[r9+rdi-1]); dump();
+mov (ecx, ptr[r9+rdi-1000]); dump();
+mov (ecx, ptr[r9+rdi*1+0]); dump();
+mov (ecx, ptr[r9+rdi*1+1]); dump();
+mov (ecx, ptr[r9+rdi*1+1000]); dump();
+mov (ecx, ptr[r9+rdi*1-1]); dump();
+mov (ecx, ptr[r9+rdi*1-1000]); dump();
+mov (ecx, ptr[r9+rdi*2+0]); dump();
+mov (ecx, ptr[r9+rdi*2+1]); dump();
+mov (ecx, ptr[r9+rdi*2+1000]); dump();
+mov (ecx, ptr[r9+rdi*2-1]); dump();
+mov (ecx, ptr[r9+rdi*2-1000]); dump();
+mov (ecx, ptr[r9+rdi*4+0]); dump();
+mov (ecx, ptr[r9+rdi*4+1]); dump();
+mov (ecx, ptr[r9+rdi*4+1000]); dump();
+mov (ecx, ptr[r9+rdi*4-1]); dump();
+mov (ecx, ptr[r9+rdi*4-1000]); dump();
+mov (ecx, ptr[r9+rdi*8+0]); dump();
+mov (ecx, ptr[r9+rdi*8+1]); dump();
+mov (ecx, ptr[r9+rdi*8+1000]); dump();
+mov (ecx, ptr[r9+rdi*8-1]); dump();
+mov (ecx, ptr[r9+rdi*8-1000]); dump();
+mov (ecx, ptr[r9+r9+0]); dump();
+mov (ecx, ptr[r9+r9+1]); dump();
+mov (ecx, ptr[r9+r9+1000]); dump();
+mov (ecx, ptr[r9+r9-1]); dump();
+mov (ecx, ptr[r9+r9-1000]); dump();
+mov (ecx, ptr[r9+r9*1+0]); dump();
+mov (ecx, ptr[r9+r9*1+1]); dump();
+mov (ecx, ptr[r9+r9*1+1000]); dump();
+mov (ecx, ptr[r9+r9*1-1]); dump();
+mov (ecx, ptr[r9+r9*1-1000]); dump();
+mov (ecx, ptr[r9+r9*2+0]); dump();
+mov (ecx, ptr[r9+r9*2+1]); dump();
+mov (ecx, ptr[r9+r9*2+1000]); dump();
+mov (ecx, ptr[r9+r9*2-1]); dump();
+mov (ecx, ptr[r9+r9*2-1000]); dump();
+mov (ecx, ptr[r9+r9*4+0]); dump();
+mov (ecx, ptr[r9+r9*4+1]); dump();
+mov (ecx, ptr[r9+r9*4+1000]); dump();
+mov (ecx, ptr[r9+r9*4-1]); dump();
+mov (ecx, ptr[r9+r9*4-1000]); dump();
+mov (ecx, ptr[r9+r9*8+0]); dump();
+mov (ecx, ptr[r9+r9*8+1]); dump();
+mov (ecx, ptr[r9+r9*8+1000]); dump();
+mov (ecx, ptr[r9+r9*8-1]); dump();
+mov (ecx, ptr[r9+r9*8-1000]); dump();
+}
+    void gen32(){
+mov (ecx, ptr[r9+r10+0]); dump();
+mov (ecx, ptr[r9+r10+1]); dump();
+mov (ecx, ptr[r9+r10+1000]); dump();
+mov (ecx, ptr[r9+r10-1]); dump();
+mov (ecx, ptr[r9+r10-1000]); dump();
+mov (ecx, ptr[r9+r10*1+0]); dump();
+mov (ecx, ptr[r9+r10*1+1]); dump();
+mov (ecx, ptr[r9+r10*1+1000]); dump();
+mov (ecx, ptr[r9+r10*1-1]); dump();
+mov (ecx, ptr[r9+r10*1-1000]); dump();
+mov (ecx, ptr[r9+r10*2+0]); dump();
+mov (ecx, ptr[r9+r10*2+1]); dump();
+mov (ecx, ptr[r9+r10*2+1000]); dump();
+mov (ecx, ptr[r9+r10*2-1]); dump();
+mov (ecx, ptr[r9+r10*2-1000]); dump();
+mov (ecx, ptr[r9+r10*4+0]); dump();
+mov (ecx, ptr[r9+r10*4+1]); dump();
+mov (ecx, ptr[r9+r10*4+1000]); dump();
+mov (ecx, ptr[r9+r10*4-1]); dump();
+mov (ecx, ptr[r9+r10*4-1000]); dump();
+mov (ecx, ptr[r9+r10*8+0]); dump();
+mov (ecx, ptr[r9+r10*8+1]); dump();
+mov (ecx, ptr[r9+r10*8+1000]); dump();
+mov (ecx, ptr[r9+r10*8-1]); dump();
+mov (ecx, ptr[r9+r10*8-1000]); dump();
+mov (ecx, ptr[r9+r11+0]); dump();
+mov (ecx, ptr[r9+r11+1]); dump();
+mov (ecx, ptr[r9+r11+1000]); dump();
+mov (ecx, ptr[r9+r11-1]); dump();
+mov (ecx, ptr[r9+r11-1000]); dump();
+mov (ecx, ptr[r9+r11*1+0]); dump();
+mov (ecx, ptr[r9+r11*1+1]); dump();
+mov (ecx, ptr[r9+r11*1+1000]); dump();
+mov (ecx, ptr[r9+r11*1-1]); dump();
+mov (ecx, ptr[r9+r11*1-1000]); dump();
+mov (ecx, ptr[r9+r11*2+0]); dump();
+mov (ecx, ptr[r9+r11*2+1]); dump();
+mov (ecx, ptr[r9+r11*2+1000]); dump();
+mov (ecx, ptr[r9+r11*2-1]); dump();
+mov (ecx, ptr[r9+r11*2-1000]); dump();
+mov (ecx, ptr[r9+r11*4+0]); dump();
+mov (ecx, ptr[r9+r11*4+1]); dump();
+mov (ecx, ptr[r9+r11*4+1000]); dump();
+mov (ecx, ptr[r9+r11*4-1]); dump();
+mov (ecx, ptr[r9+r11*4-1000]); dump();
+mov (ecx, ptr[r9+r11*8+0]); dump();
+mov (ecx, ptr[r9+r11*8+1]); dump();
+mov (ecx, ptr[r9+r11*8+1000]); dump();
+mov (ecx, ptr[r9+r11*8-1]); dump();
+mov (ecx, ptr[r9+r11*8-1000]); dump();
+mov (ecx, ptr[r9+r12+0]); dump();
+mov (ecx, ptr[r9+r12+1]); dump();
+mov (ecx, ptr[r9+r12+1000]); dump();
+mov (ecx, ptr[r9+r12-1]); dump();
+mov (ecx, ptr[r9+r12-1000]); dump();
+mov (ecx, ptr[r9+r12*1+0]); dump();
+mov (ecx, ptr[r9+r12*1+1]); dump();
+mov (ecx, ptr[r9+r12*1+1000]); dump();
+mov (ecx, ptr[r9+r12*1-1]); dump();
+mov (ecx, ptr[r9+r12*1-1000]); dump();
+mov (ecx, ptr[r9+r12*2+0]); dump();
+mov (ecx, ptr[r9+r12*2+1]); dump();
+mov (ecx, ptr[r9+r12*2+1000]); dump();
+mov (ecx, ptr[r9+r12*2-1]); dump();
+mov (ecx, ptr[r9+r12*2-1000]); dump();
+mov (ecx, ptr[r9+r12*4+0]); dump();
+mov (ecx, ptr[r9+r12*4+1]); dump();
+mov (ecx, ptr[r9+r12*4+1000]); dump();
+mov (ecx, ptr[r9+r12*4-1]); dump();
+mov (ecx, ptr[r9+r12*4-1000]); dump();
+mov (ecx, ptr[r9+r12*8+0]); dump();
+mov (ecx, ptr[r9+r12*8+1]); dump();
+mov (ecx, ptr[r9+r12*8+1000]); dump();
+mov (ecx, ptr[r9+r12*8-1]); dump();
+mov (ecx, ptr[r9+r12*8-1000]); dump();
+mov (ecx, ptr[r9+r13+0]); dump();
+mov (ecx, ptr[r9+r13+1]); dump();
+mov (ecx, ptr[r9+r13+1000]); dump();
+mov (ecx, ptr[r9+r13-1]); dump();
+mov (ecx, ptr[r9+r13-1000]); dump();
+mov (ecx, ptr[r9+r13*1+0]); dump();
+mov (ecx, ptr[r9+r13*1+1]); dump();
+mov (ecx, ptr[r9+r13*1+1000]); dump();
+mov (ecx, ptr[r9+r13*1-1]); dump();
+mov (ecx, ptr[r9+r13*1-1000]); dump();
+mov (ecx, ptr[r9+r13*2+0]); dump();
+mov (ecx, ptr[r9+r13*2+1]); dump();
+mov (ecx, ptr[r9+r13*2+1000]); dump();
+mov (ecx, ptr[r9+r13*2-1]); dump();
+mov (ecx, ptr[r9+r13*2-1000]); dump();
+mov (ecx, ptr[r9+r13*4+0]); dump();
+mov (ecx, ptr[r9+r13*4+1]); dump();
+mov (ecx, ptr[r9+r13*4+1000]); dump();
+mov (ecx, ptr[r9+r13*4-1]); dump();
+mov (ecx, ptr[r9+r13*4-1000]); dump();
+mov (ecx, ptr[r9+r13*8+0]); dump();
+mov (ecx, ptr[r9+r13*8+1]); dump();
+mov (ecx, ptr[r9+r13*8+1000]); dump();
+mov (ecx, ptr[r9+r13*8-1]); dump();
+mov (ecx, ptr[r9+r13*8-1000]); dump();
+}
+    void gen33(){
+mov (ecx, ptr[r9+r14+0]); dump();
+mov (ecx, ptr[r9+r14+1]); dump();
+mov (ecx, ptr[r9+r14+1000]); dump();
+mov (ecx, ptr[r9+r14-1]); dump();
+mov (ecx, ptr[r9+r14-1000]); dump();
+mov (ecx, ptr[r9+r14*1+0]); dump();
+mov (ecx, ptr[r9+r14*1+1]); dump();
+mov (ecx, ptr[r9+r14*1+1000]); dump();
+mov (ecx, ptr[r9+r14*1-1]); dump();
+mov (ecx, ptr[r9+r14*1-1000]); dump();
+mov (ecx, ptr[r9+r14*2+0]); dump();
+mov (ecx, ptr[r9+r14*2+1]); dump();
+mov (ecx, ptr[r9+r14*2+1000]); dump();
+mov (ecx, ptr[r9+r14*2-1]); dump();
+mov (ecx, ptr[r9+r14*2-1000]); dump();
+mov (ecx, ptr[r9+r14*4+0]); dump();
+mov (ecx, ptr[r9+r14*4+1]); dump();
+mov (ecx, ptr[r9+r14*4+1000]); dump();
+mov (ecx, ptr[r9+r14*4-1]); dump();
+mov (ecx, ptr[r9+r14*4-1000]); dump();
+mov (ecx, ptr[r9+r14*8+0]); dump();
+mov (ecx, ptr[r9+r14*8+1]); dump();
+mov (ecx, ptr[r9+r14*8+1000]); dump();
+mov (ecx, ptr[r9+r14*8-1]); dump();
+mov (ecx, ptr[r9+r14*8-1000]); dump();
+mov (ecx, ptr[r9+r15+0]); dump();
+mov (ecx, ptr[r9+r15+1]); dump();
+mov (ecx, ptr[r9+r15+1000]); dump();
+mov (ecx, ptr[r9+r15-1]); dump();
+mov (ecx, ptr[r9+r15-1000]); dump();
+mov (ecx, ptr[r9+r15*1+0]); dump();
+mov (ecx, ptr[r9+r15*1+1]); dump();
+mov (ecx, ptr[r9+r15*1+1000]); dump();
+mov (ecx, ptr[r9+r15*1-1]); dump();
+mov (ecx, ptr[r9+r15*1-1000]); dump();
+mov (ecx, ptr[r9+r15*2+0]); dump();
+mov (ecx, ptr[r9+r15*2+1]); dump();
+mov (ecx, ptr[r9+r15*2+1000]); dump();
+mov (ecx, ptr[r9+r15*2-1]); dump();
+mov (ecx, ptr[r9+r15*2-1000]); dump();
+mov (ecx, ptr[r9+r15*4+0]); dump();
+mov (ecx, ptr[r9+r15*4+1]); dump();
+mov (ecx, ptr[r9+r15*4+1000]); dump();
+mov (ecx, ptr[r9+r15*4-1]); dump();
+mov (ecx, ptr[r9+r15*4-1000]); dump();
+mov (ecx, ptr[r9+r15*8+0]); dump();
+mov (ecx, ptr[r9+r15*8+1]); dump();
+mov (ecx, ptr[r9+r15*8+1000]); dump();
+mov (ecx, ptr[r9+r15*8-1]); dump();
+mov (ecx, ptr[r9+r15*8-1000]); dump();
+mov (ecx, ptr[r9+0]); dump();
+mov (ecx, ptr[r9+1]); dump();
+mov (ecx, ptr[r9+1000]); dump();
+mov (ecx, ptr[r9-1]); dump();
+mov (ecx, ptr[r9-1000]); dump();
+mov (ecx, ptr[r9+0]); dump();
+mov (ecx, ptr[r9+1]); dump();
+mov (ecx, ptr[r9+1000]); dump();
+mov (ecx, ptr[r9-1]); dump();
+mov (ecx, ptr[r9-1000]); dump();
+mov (ecx, ptr[r9+0]); dump();
+mov (ecx, ptr[r9+1]); dump();
+mov (ecx, ptr[r9+1000]); dump();
+mov (ecx, ptr[r9-1]); dump();
+mov (ecx, ptr[r9-1000]); dump();
+mov (ecx, ptr[r9+0]); dump();
+mov (ecx, ptr[r9+1]); dump();
+mov (ecx, ptr[r9+1000]); dump();
+mov (ecx, ptr[r9-1]); dump();
+mov (ecx, ptr[r9-1000]); dump();
+mov (ecx, ptr[r9+0]); dump();
+mov (ecx, ptr[r9+1]); dump();
+mov (ecx, ptr[r9+1000]); dump();
+mov (ecx, ptr[r9-1]); dump();
+mov (ecx, ptr[r9-1000]); dump();
+mov (ecx, ptr[r10+rax+0]); dump();
+mov (ecx, ptr[r10+rax+1]); dump();
+mov (ecx, ptr[r10+rax+1000]); dump();
+mov (ecx, ptr[r10+rax-1]); dump();
+mov (ecx, ptr[r10+rax-1000]); dump();
+mov (ecx, ptr[r10+rax*1+0]); dump();
+mov (ecx, ptr[r10+rax*1+1]); dump();
+mov (ecx, ptr[r10+rax*1+1000]); dump();
+mov (ecx, ptr[r10+rax*1-1]); dump();
+mov (ecx, ptr[r10+rax*1-1000]); dump();
+mov (ecx, ptr[r10+rax*2+0]); dump();
+mov (ecx, ptr[r10+rax*2+1]); dump();
+mov (ecx, ptr[r10+rax*2+1000]); dump();
+mov (ecx, ptr[r10+rax*2-1]); dump();
+mov (ecx, ptr[r10+rax*2-1000]); dump();
+mov (ecx, ptr[r10+rax*4+0]); dump();
+mov (ecx, ptr[r10+rax*4+1]); dump();
+mov (ecx, ptr[r10+rax*4+1000]); dump();
+mov (ecx, ptr[r10+rax*4-1]); dump();
+mov (ecx, ptr[r10+rax*4-1000]); dump();
+mov (ecx, ptr[r10+rax*8+0]); dump();
+mov (ecx, ptr[r10+rax*8+1]); dump();
+mov (ecx, ptr[r10+rax*8+1000]); dump();
+mov (ecx, ptr[r10+rax*8-1]); dump();
+mov (ecx, ptr[r10+rax*8-1000]); dump();
+}
+    void gen34(){
+mov (ecx, ptr[r10+rcx+0]); dump();
+mov (ecx, ptr[r10+rcx+1]); dump();
+mov (ecx, ptr[r10+rcx+1000]); dump();
+mov (ecx, ptr[r10+rcx-1]); dump();
+mov (ecx, ptr[r10+rcx-1000]); dump();
+mov (ecx, ptr[r10+rcx*1+0]); dump();
+mov (ecx, ptr[r10+rcx*1+1]); dump();
+mov (ecx, ptr[r10+rcx*1+1000]); dump();
+mov (ecx, ptr[r10+rcx*1-1]); dump();
+mov (ecx, ptr[r10+rcx*1-1000]); dump();
+mov (ecx, ptr[r10+rcx*2+0]); dump();
+mov (ecx, ptr[r10+rcx*2+1]); dump();
+mov (ecx, ptr[r10+rcx*2+1000]); dump();
+mov (ecx, ptr[r10+rcx*2-1]); dump();
+mov (ecx, ptr[r10+rcx*2-1000]); dump();
+mov (ecx, ptr[r10+rcx*4+0]); dump();
+mov (ecx, ptr[r10+rcx*4+1]); dump();
+mov (ecx, ptr[r10+rcx*4+1000]); dump();
+mov (ecx, ptr[r10+rcx*4-1]); dump();
+mov (ecx, ptr[r10+rcx*4-1000]); dump();
+mov (ecx, ptr[r10+rcx*8+0]); dump();
+mov (ecx, ptr[r10+rcx*8+1]); dump();
+mov (ecx, ptr[r10+rcx*8+1000]); dump();
+mov (ecx, ptr[r10+rcx*8-1]); dump();
+mov (ecx, ptr[r10+rcx*8-1000]); dump();
+mov (ecx, ptr[r10+rdx+0]); dump();
+mov (ecx, ptr[r10+rdx+1]); dump();
+mov (ecx, ptr[r10+rdx+1000]); dump();
+mov (ecx, ptr[r10+rdx-1]); dump();
+mov (ecx, ptr[r10+rdx-1000]); dump();
+mov (ecx, ptr[r10+rdx*1+0]); dump();
+mov (ecx, ptr[r10+rdx*1+1]); dump();
+mov (ecx, ptr[r10+rdx*1+1000]); dump();
+mov (ecx, ptr[r10+rdx*1-1]); dump();
+mov (ecx, ptr[r10+rdx*1-1000]); dump();
+mov (ecx, ptr[r10+rdx*2+0]); dump();
+mov (ecx, ptr[r10+rdx*2+1]); dump();
+mov (ecx, ptr[r10+rdx*2+1000]); dump();
+mov (ecx, ptr[r10+rdx*2-1]); dump();
+mov (ecx, ptr[r10+rdx*2-1000]); dump();
+mov (ecx, ptr[r10+rdx*4+0]); dump();
+mov (ecx, ptr[r10+rdx*4+1]); dump();
+mov (ecx, ptr[r10+rdx*4+1000]); dump();
+mov (ecx, ptr[r10+rdx*4-1]); dump();
+mov (ecx, ptr[r10+rdx*4-1000]); dump();
+mov (ecx, ptr[r10+rdx*8+0]); dump();
+mov (ecx, ptr[r10+rdx*8+1]); dump();
+mov (ecx, ptr[r10+rdx*8+1000]); dump();
+mov (ecx, ptr[r10+rdx*8-1]); dump();
+mov (ecx, ptr[r10+rdx*8-1000]); dump();
+mov (ecx, ptr[r10+rbx+0]); dump();
+mov (ecx, ptr[r10+rbx+1]); dump();
+mov (ecx, ptr[r10+rbx+1000]); dump();
+mov (ecx, ptr[r10+rbx-1]); dump();
+mov (ecx, ptr[r10+rbx-1000]); dump();
+mov (ecx, ptr[r10+rbx*1+0]); dump();
+mov (ecx, ptr[r10+rbx*1+1]); dump();
+mov (ecx, ptr[r10+rbx*1+1000]); dump();
+mov (ecx, ptr[r10+rbx*1-1]); dump();
+mov (ecx, ptr[r10+rbx*1-1000]); dump();
+mov (ecx, ptr[r10+rbx*2+0]); dump();
+mov (ecx, ptr[r10+rbx*2+1]); dump();
+mov (ecx, ptr[r10+rbx*2+1000]); dump();
+mov (ecx, ptr[r10+rbx*2-1]); dump();
+mov (ecx, ptr[r10+rbx*2-1000]); dump();
+mov (ecx, ptr[r10+rbx*4+0]); dump();
+mov (ecx, ptr[r10+rbx*4+1]); dump();
+mov (ecx, ptr[r10+rbx*4+1000]); dump();
+mov (ecx, ptr[r10+rbx*4-1]); dump();
+mov (ecx, ptr[r10+rbx*4-1000]); dump();
+mov (ecx, ptr[r10+rbx*8+0]); dump();
+mov (ecx, ptr[r10+rbx*8+1]); dump();
+mov (ecx, ptr[r10+rbx*8+1000]); dump();
+mov (ecx, ptr[r10+rbx*8-1]); dump();
+mov (ecx, ptr[r10+rbx*8-1000]); dump();
+mov (ecx, ptr[r10+rbp+0]); dump();
+mov (ecx, ptr[r10+rbp+1]); dump();
+mov (ecx, ptr[r10+rbp+1000]); dump();
+mov (ecx, ptr[r10+rbp-1]); dump();
+mov (ecx, ptr[r10+rbp-1000]); dump();
+mov (ecx, ptr[r10+rbp*1+0]); dump();
+mov (ecx, ptr[r10+rbp*1+1]); dump();
+mov (ecx, ptr[r10+rbp*1+1000]); dump();
+mov (ecx, ptr[r10+rbp*1-1]); dump();
+mov (ecx, ptr[r10+rbp*1-1000]); dump();
+mov (ecx, ptr[r10+rbp*2+0]); dump();
+mov (ecx, ptr[r10+rbp*2+1]); dump();
+mov (ecx, ptr[r10+rbp*2+1000]); dump();
+mov (ecx, ptr[r10+rbp*2-1]); dump();
+mov (ecx, ptr[r10+rbp*2-1000]); dump();
+mov (ecx, ptr[r10+rbp*4+0]); dump();
+mov (ecx, ptr[r10+rbp*4+1]); dump();
+mov (ecx, ptr[r10+rbp*4+1000]); dump();
+mov (ecx, ptr[r10+rbp*4-1]); dump();
+mov (ecx, ptr[r10+rbp*4-1000]); dump();
+mov (ecx, ptr[r10+rbp*8+0]); dump();
+mov (ecx, ptr[r10+rbp*8+1]); dump();
+mov (ecx, ptr[r10+rbp*8+1000]); dump();
+mov (ecx, ptr[r10+rbp*8-1]); dump();
+mov (ecx, ptr[r10+rbp*8-1000]); dump();
+}
+    void gen35(){
+mov (ecx, ptr[r10+rsi+0]); dump();
+mov (ecx, ptr[r10+rsi+1]); dump();
+mov (ecx, ptr[r10+rsi+1000]); dump();
+mov (ecx, ptr[r10+rsi-1]); dump();
+mov (ecx, ptr[r10+rsi-1000]); dump();
+mov (ecx, ptr[r10+rsi*1+0]); dump();
+mov (ecx, ptr[r10+rsi*1+1]); dump();
+mov (ecx, ptr[r10+rsi*1+1000]); dump();
+mov (ecx, ptr[r10+rsi*1-1]); dump();
+mov (ecx, ptr[r10+rsi*1-1000]); dump();
+mov (ecx, ptr[r10+rsi*2+0]); dump();
+mov (ecx, ptr[r10+rsi*2+1]); dump();
+mov (ecx, ptr[r10+rsi*2+1000]); dump();
+mov (ecx, ptr[r10+rsi*2-1]); dump();
+mov (ecx, ptr[r10+rsi*2-1000]); dump();
+mov (ecx, ptr[r10+rsi*4+0]); dump();
+mov (ecx, ptr[r10+rsi*4+1]); dump();
+mov (ecx, ptr[r10+rsi*4+1000]); dump();
+mov (ecx, ptr[r10+rsi*4-1]); dump();
+mov (ecx, ptr[r10+rsi*4-1000]); dump();
+mov (ecx, ptr[r10+rsi*8+0]); dump();
+mov (ecx, ptr[r10+rsi*8+1]); dump();
+mov (ecx, ptr[r10+rsi*8+1000]); dump();
+mov (ecx, ptr[r10+rsi*8-1]); dump();
+mov (ecx, ptr[r10+rsi*8-1000]); dump();
+mov (ecx, ptr[r10+rdi+0]); dump();
+mov (ecx, ptr[r10+rdi+1]); dump();
+mov (ecx, ptr[r10+rdi+1000]); dump();
+mov (ecx, ptr[r10+rdi-1]); dump();
+mov (ecx, ptr[r10+rdi-1000]); dump();
+mov (ecx, ptr[r10+rdi*1+0]); dump();
+mov (ecx, ptr[r10+rdi*1+1]); dump();
+mov (ecx, ptr[r10+rdi*1+1000]); dump();
+mov (ecx, ptr[r10+rdi*1-1]); dump();
+mov (ecx, ptr[r10+rdi*1-1000]); dump();
+mov (ecx, ptr[r10+rdi*2+0]); dump();
+mov (ecx, ptr[r10+rdi*2+1]); dump();
+mov (ecx, ptr[r10+rdi*2+1000]); dump();
+mov (ecx, ptr[r10+rdi*2-1]); dump();
+mov (ecx, ptr[r10+rdi*2-1000]); dump();
+mov (ecx, ptr[r10+rdi*4+0]); dump();
+mov (ecx, ptr[r10+rdi*4+1]); dump();
+mov (ecx, ptr[r10+rdi*4+1000]); dump();
+mov (ecx, ptr[r10+rdi*4-1]); dump();
+mov (ecx, ptr[r10+rdi*4-1000]); dump();
+mov (ecx, ptr[r10+rdi*8+0]); dump();
+mov (ecx, ptr[r10+rdi*8+1]); dump();
+mov (ecx, ptr[r10+rdi*8+1000]); dump();
+mov (ecx, ptr[r10+rdi*8-1]); dump();
+mov (ecx, ptr[r10+rdi*8-1000]); dump();
+mov (ecx, ptr[r10+r9+0]); dump();
+mov (ecx, ptr[r10+r9+1]); dump();
+mov (ecx, ptr[r10+r9+1000]); dump();
+mov (ecx, ptr[r10+r9-1]); dump();
+mov (ecx, ptr[r10+r9-1000]); dump();
+mov (ecx, ptr[r10+r9*1+0]); dump();
+mov (ecx, ptr[r10+r9*1+1]); dump();
+mov (ecx, ptr[r10+r9*1+1000]); dump();
+mov (ecx, ptr[r10+r9*1-1]); dump();
+mov (ecx, ptr[r10+r9*1-1000]); dump();
+mov (ecx, ptr[r10+r9*2+0]); dump();
+mov (ecx, ptr[r10+r9*2+1]); dump();
+mov (ecx, ptr[r10+r9*2+1000]); dump();
+mov (ecx, ptr[r10+r9*2-1]); dump();
+mov (ecx, ptr[r10+r9*2-1000]); dump();
+mov (ecx, ptr[r10+r9*4+0]); dump();
+mov (ecx, ptr[r10+r9*4+1]); dump();
+mov (ecx, ptr[r10+r9*4+1000]); dump();
+mov (ecx, ptr[r10+r9*4-1]); dump();
+mov (ecx, ptr[r10+r9*4-1000]); dump();
+mov (ecx, ptr[r10+r9*8+0]); dump();
+mov (ecx, ptr[r10+r9*8+1]); dump();
+mov (ecx, ptr[r10+r9*8+1000]); dump();
+mov (ecx, ptr[r10+r9*8-1]); dump();
+mov (ecx, ptr[r10+r9*8-1000]); dump();
+mov (ecx, ptr[r10+r10+0]); dump();
+mov (ecx, ptr[r10+r10+1]); dump();
+mov (ecx, ptr[r10+r10+1000]); dump();
+mov (ecx, ptr[r10+r10-1]); dump();
+mov (ecx, ptr[r10+r10-1000]); dump();
+mov (ecx, ptr[r10+r10*1+0]); dump();
+mov (ecx, ptr[r10+r10*1+1]); dump();
+mov (ecx, ptr[r10+r10*1+1000]); dump();
+mov (ecx, ptr[r10+r10*1-1]); dump();
+mov (ecx, ptr[r10+r10*1-1000]); dump();
+mov (ecx, ptr[r10+r10*2+0]); dump();
+mov (ecx, ptr[r10+r10*2+1]); dump();
+mov (ecx, ptr[r10+r10*2+1000]); dump();
+mov (ecx, ptr[r10+r10*2-1]); dump();
+mov (ecx, ptr[r10+r10*2-1000]); dump();
+mov (ecx, ptr[r10+r10*4+0]); dump();
+mov (ecx, ptr[r10+r10*4+1]); dump();
+mov (ecx, ptr[r10+r10*4+1000]); dump();
+mov (ecx, ptr[r10+r10*4-1]); dump();
+mov (ecx, ptr[r10+r10*4-1000]); dump();
+mov (ecx, ptr[r10+r10*8+0]); dump();
+mov (ecx, ptr[r10+r10*8+1]); dump();
+mov (ecx, ptr[r10+r10*8+1000]); dump();
+mov (ecx, ptr[r10+r10*8-1]); dump();
+mov (ecx, ptr[r10+r10*8-1000]); dump();
+}
+    void gen36(){
+mov (ecx, ptr[r10+r11+0]); dump();
+mov (ecx, ptr[r10+r11+1]); dump();
+mov (ecx, ptr[r10+r11+1000]); dump();
+mov (ecx, ptr[r10+r11-1]); dump();
+mov (ecx, ptr[r10+r11-1000]); dump();
+mov (ecx, ptr[r10+r11*1+0]); dump();
+mov (ecx, ptr[r10+r11*1+1]); dump();
+mov (ecx, ptr[r10+r11*1+1000]); dump();
+mov (ecx, ptr[r10+r11*1-1]); dump();
+mov (ecx, ptr[r10+r11*1-1000]); dump();
+mov (ecx, ptr[r10+r11*2+0]); dump();
+mov (ecx, ptr[r10+r11*2+1]); dump();
+mov (ecx, ptr[r10+r11*2+1000]); dump();
+mov (ecx, ptr[r10+r11*2-1]); dump();
+mov (ecx, ptr[r10+r11*2-1000]); dump();
+mov (ecx, ptr[r10+r11*4+0]); dump();
+mov (ecx, ptr[r10+r11*4+1]); dump();
+mov (ecx, ptr[r10+r11*4+1000]); dump();
+mov (ecx, ptr[r10+r11*4-1]); dump();
+mov (ecx, ptr[r10+r11*4-1000]); dump();
+mov (ecx, ptr[r10+r11*8+0]); dump();
+mov (ecx, ptr[r10+r11*8+1]); dump();
+mov (ecx, ptr[r10+r11*8+1000]); dump();
+mov (ecx, ptr[r10+r11*8-1]); dump();
+mov (ecx, ptr[r10+r11*8-1000]); dump();
+mov (ecx, ptr[r10+r12+0]); dump();
+mov (ecx, ptr[r10+r12+1]); dump();
+mov (ecx, ptr[r10+r12+1000]); dump();
+mov (ecx, ptr[r10+r12-1]); dump();
+mov (ecx, ptr[r10+r12-1000]); dump();
+mov (ecx, ptr[r10+r12*1+0]); dump();
+mov (ecx, ptr[r10+r12*1+1]); dump();
+mov (ecx, ptr[r10+r12*1+1000]); dump();
+mov (ecx, ptr[r10+r12*1-1]); dump();
+mov (ecx, ptr[r10+r12*1-1000]); dump();
+mov (ecx, ptr[r10+r12*2+0]); dump();
+mov (ecx, ptr[r10+r12*2+1]); dump();
+mov (ecx, ptr[r10+r12*2+1000]); dump();
+mov (ecx, ptr[r10+r12*2-1]); dump();
+mov (ecx, ptr[r10+r12*2-1000]); dump();
+mov (ecx, ptr[r10+r12*4+0]); dump();
+mov (ecx, ptr[r10+r12*4+1]); dump();
+mov (ecx, ptr[r10+r12*4+1000]); dump();
+mov (ecx, ptr[r10+r12*4-1]); dump();
+mov (ecx, ptr[r10+r12*4-1000]); dump();
+mov (ecx, ptr[r10+r12*8+0]); dump();
+mov (ecx, ptr[r10+r12*8+1]); dump();
+mov (ecx, ptr[r10+r12*8+1000]); dump();
+mov (ecx, ptr[r10+r12*8-1]); dump();
+mov (ecx, ptr[r10+r12*8-1000]); dump();
+mov (ecx, ptr[r10+r13+0]); dump();
+mov (ecx, ptr[r10+r13+1]); dump();
+mov (ecx, ptr[r10+r13+1000]); dump();
+mov (ecx, ptr[r10+r13-1]); dump();
+mov (ecx, ptr[r10+r13-1000]); dump();
+mov (ecx, ptr[r10+r13*1+0]); dump();
+mov (ecx, ptr[r10+r13*1+1]); dump();
+mov (ecx, ptr[r10+r13*1+1000]); dump();
+mov (ecx, ptr[r10+r13*1-1]); dump();
+mov (ecx, ptr[r10+r13*1-1000]); dump();
+mov (ecx, ptr[r10+r13*2+0]); dump();
+mov (ecx, ptr[r10+r13*2+1]); dump();
+mov (ecx, ptr[r10+r13*2+1000]); dump();
+mov (ecx, ptr[r10+r13*2-1]); dump();
+mov (ecx, ptr[r10+r13*2-1000]); dump();
+mov (ecx, ptr[r10+r13*4+0]); dump();
+mov (ecx, ptr[r10+r13*4+1]); dump();
+mov (ecx, ptr[r10+r13*4+1000]); dump();
+mov (ecx, ptr[r10+r13*4-1]); dump();
+mov (ecx, ptr[r10+r13*4-1000]); dump();
+mov (ecx, ptr[r10+r13*8+0]); dump();
+mov (ecx, ptr[r10+r13*8+1]); dump();
+mov (ecx, ptr[r10+r13*8+1000]); dump();
+mov (ecx, ptr[r10+r13*8-1]); dump();
+mov (ecx, ptr[r10+r13*8-1000]); dump();
+mov (ecx, ptr[r10+r14+0]); dump();
+mov (ecx, ptr[r10+r14+1]); dump();
+mov (ecx, ptr[r10+r14+1000]); dump();
+mov (ecx, ptr[r10+r14-1]); dump();
+mov (ecx, ptr[r10+r14-1000]); dump();
+mov (ecx, ptr[r10+r14*1+0]); dump();
+mov (ecx, ptr[r10+r14*1+1]); dump();
+mov (ecx, ptr[r10+r14*1+1000]); dump();
+mov (ecx, ptr[r10+r14*1-1]); dump();
+mov (ecx, ptr[r10+r14*1-1000]); dump();
+mov (ecx, ptr[r10+r14*2+0]); dump();
+mov (ecx, ptr[r10+r14*2+1]); dump();
+mov (ecx, ptr[r10+r14*2+1000]); dump();
+mov (ecx, ptr[r10+r14*2-1]); dump();
+mov (ecx, ptr[r10+r14*2-1000]); dump();
+mov (ecx, ptr[r10+r14*4+0]); dump();
+mov (ecx, ptr[r10+r14*4+1]); dump();
+mov (ecx, ptr[r10+r14*4+1000]); dump();
+mov (ecx, ptr[r10+r14*4-1]); dump();
+mov (ecx, ptr[r10+r14*4-1000]); dump();
+mov (ecx, ptr[r10+r14*8+0]); dump();
+mov (ecx, ptr[r10+r14*8+1]); dump();
+mov (ecx, ptr[r10+r14*8+1000]); dump();
+mov (ecx, ptr[r10+r14*8-1]); dump();
+mov (ecx, ptr[r10+r14*8-1000]); dump();
+}
+    void gen37(){
+mov (ecx, ptr[r10+r15+0]); dump();
+mov (ecx, ptr[r10+r15+1]); dump();
+mov (ecx, ptr[r10+r15+1000]); dump();
+mov (ecx, ptr[r10+r15-1]); dump();
+mov (ecx, ptr[r10+r15-1000]); dump();
+mov (ecx, ptr[r10+r15*1+0]); dump();
+mov (ecx, ptr[r10+r15*1+1]); dump();
+mov (ecx, ptr[r10+r15*1+1000]); dump();
+mov (ecx, ptr[r10+r15*1-1]); dump();
+mov (ecx, ptr[r10+r15*1-1000]); dump();
+mov (ecx, ptr[r10+r15*2+0]); dump();
+mov (ecx, ptr[r10+r15*2+1]); dump();
+mov (ecx, ptr[r10+r15*2+1000]); dump();
+mov (ecx, ptr[r10+r15*2-1]); dump();
+mov (ecx, ptr[r10+r15*2-1000]); dump();
+mov (ecx, ptr[r10+r15*4+0]); dump();
+mov (ecx, ptr[r10+r15*4+1]); dump();
+mov (ecx, ptr[r10+r15*4+1000]); dump();
+mov (ecx, ptr[r10+r15*4-1]); dump();
+mov (ecx, ptr[r10+r15*4-1000]); dump();
+mov (ecx, ptr[r10+r15*8+0]); dump();
+mov (ecx, ptr[r10+r15*8+1]); dump();
+mov (ecx, ptr[r10+r15*8+1000]); dump();
+mov (ecx, ptr[r10+r15*8-1]); dump();
+mov (ecx, ptr[r10+r15*8-1000]); dump();
+mov (ecx, ptr[r10+0]); dump();
+mov (ecx, ptr[r10+1]); dump();
+mov (ecx, ptr[r10+1000]); dump();
+mov (ecx, ptr[r10-1]); dump();
+mov (ecx, ptr[r10-1000]); dump();
+mov (ecx, ptr[r10+0]); dump();
+mov (ecx, ptr[r10+1]); dump();
+mov (ecx, ptr[r10+1000]); dump();
+mov (ecx, ptr[r10-1]); dump();
+mov (ecx, ptr[r10-1000]); dump();
+mov (ecx, ptr[r10+0]); dump();
+mov (ecx, ptr[r10+1]); dump();
+mov (ecx, ptr[r10+1000]); dump();
+mov (ecx, ptr[r10-1]); dump();
+mov (ecx, ptr[r10-1000]); dump();
+mov (ecx, ptr[r10+0]); dump();
+mov (ecx, ptr[r10+1]); dump();
+mov (ecx, ptr[r10+1000]); dump();
+mov (ecx, ptr[r10-1]); dump();
+mov (ecx, ptr[r10-1000]); dump();
+mov (ecx, ptr[r10+0]); dump();
+mov (ecx, ptr[r10+1]); dump();
+mov (ecx, ptr[r10+1000]); dump();
+mov (ecx, ptr[r10-1]); dump();
+mov (ecx, ptr[r10-1000]); dump();
+mov (ecx, ptr[r11+rax+0]); dump();
+mov (ecx, ptr[r11+rax+1]); dump();
+mov (ecx, ptr[r11+rax+1000]); dump();
+mov (ecx, ptr[r11+rax-1]); dump();
+mov (ecx, ptr[r11+rax-1000]); dump();
+mov (ecx, ptr[r11+rax*1+0]); dump();
+mov (ecx, ptr[r11+rax*1+1]); dump();
+mov (ecx, ptr[r11+rax*1+1000]); dump();
+mov (ecx, ptr[r11+rax*1-1]); dump();
+mov (ecx, ptr[r11+rax*1-1000]); dump();
+mov (ecx, ptr[r11+rax*2+0]); dump();
+mov (ecx, ptr[r11+rax*2+1]); dump();
+mov (ecx, ptr[r11+rax*2+1000]); dump();
+mov (ecx, ptr[r11+rax*2-1]); dump();
+mov (ecx, ptr[r11+rax*2-1000]); dump();
+mov (ecx, ptr[r11+rax*4+0]); dump();
+mov (ecx, ptr[r11+rax*4+1]); dump();
+mov (ecx, ptr[r11+rax*4+1000]); dump();
+mov (ecx, ptr[r11+rax*4-1]); dump();
+mov (ecx, ptr[r11+rax*4-1000]); dump();
+mov (ecx, ptr[r11+rax*8+0]); dump();
+mov (ecx, ptr[r11+rax*8+1]); dump();
+mov (ecx, ptr[r11+rax*8+1000]); dump();
+mov (ecx, ptr[r11+rax*8-1]); dump();
+mov (ecx, ptr[r11+rax*8-1000]); dump();
+mov (ecx, ptr[r11+rcx+0]); dump();
+mov (ecx, ptr[r11+rcx+1]); dump();
+mov (ecx, ptr[r11+rcx+1000]); dump();
+mov (ecx, ptr[r11+rcx-1]); dump();
+mov (ecx, ptr[r11+rcx-1000]); dump();
+mov (ecx, ptr[r11+rcx*1+0]); dump();
+mov (ecx, ptr[r11+rcx*1+1]); dump();
+mov (ecx, ptr[r11+rcx*1+1000]); dump();
+mov (ecx, ptr[r11+rcx*1-1]); dump();
+mov (ecx, ptr[r11+rcx*1-1000]); dump();
+mov (ecx, ptr[r11+rcx*2+0]); dump();
+mov (ecx, ptr[r11+rcx*2+1]); dump();
+mov (ecx, ptr[r11+rcx*2+1000]); dump();
+mov (ecx, ptr[r11+rcx*2-1]); dump();
+mov (ecx, ptr[r11+rcx*2-1000]); dump();
+mov (ecx, ptr[r11+rcx*4+0]); dump();
+mov (ecx, ptr[r11+rcx*4+1]); dump();
+mov (ecx, ptr[r11+rcx*4+1000]); dump();
+mov (ecx, ptr[r11+rcx*4-1]); dump();
+mov (ecx, ptr[r11+rcx*4-1000]); dump();
+mov (ecx, ptr[r11+rcx*8+0]); dump();
+mov (ecx, ptr[r11+rcx*8+1]); dump();
+mov (ecx, ptr[r11+rcx*8+1000]); dump();
+mov (ecx, ptr[r11+rcx*8-1]); dump();
+mov (ecx, ptr[r11+rcx*8-1000]); dump();
+}
+    void gen38(){
+mov (ecx, ptr[r11+rdx+0]); dump();
+mov (ecx, ptr[r11+rdx+1]); dump();
+mov (ecx, ptr[r11+rdx+1000]); dump();
+mov (ecx, ptr[r11+rdx-1]); dump();
+mov (ecx, ptr[r11+rdx-1000]); dump();
+mov (ecx, ptr[r11+rdx*1+0]); dump();
+mov (ecx, ptr[r11+rdx*1+1]); dump();
+mov (ecx, ptr[r11+rdx*1+1000]); dump();
+mov (ecx, ptr[r11+rdx*1-1]); dump();
+mov (ecx, ptr[r11+rdx*1-1000]); dump();
+mov (ecx, ptr[r11+rdx*2+0]); dump();
+mov (ecx, ptr[r11+rdx*2+1]); dump();
+mov (ecx, ptr[r11+rdx*2+1000]); dump();
+mov (ecx, ptr[r11+rdx*2-1]); dump();
+mov (ecx, ptr[r11+rdx*2-1000]); dump();
+mov (ecx, ptr[r11+rdx*4+0]); dump();
+mov (ecx, ptr[r11+rdx*4+1]); dump();
+mov (ecx, ptr[r11+rdx*4+1000]); dump();
+mov (ecx, ptr[r11+rdx*4-1]); dump();
+mov (ecx, ptr[r11+rdx*4-1000]); dump();
+mov (ecx, ptr[r11+rdx*8+0]); dump();
+mov (ecx, ptr[r11+rdx*8+1]); dump();
+mov (ecx, ptr[r11+rdx*8+1000]); dump();
+mov (ecx, ptr[r11+rdx*8-1]); dump();
+mov (ecx, ptr[r11+rdx*8-1000]); dump();
+mov (ecx, ptr[r11+rbx+0]); dump();
+mov (ecx, ptr[r11+rbx+1]); dump();
+mov (ecx, ptr[r11+rbx+1000]); dump();
+mov (ecx, ptr[r11+rbx-1]); dump();
+mov (ecx, ptr[r11+rbx-1000]); dump();
+mov (ecx, ptr[r11+rbx*1+0]); dump();
+mov (ecx, ptr[r11+rbx*1+1]); dump();
+mov (ecx, ptr[r11+rbx*1+1000]); dump();
+mov (ecx, ptr[r11+rbx*1-1]); dump();
+mov (ecx, ptr[r11+rbx*1-1000]); dump();
+mov (ecx, ptr[r11+rbx*2+0]); dump();
+mov (ecx, ptr[r11+rbx*2+1]); dump();
+mov (ecx, ptr[r11+rbx*2+1000]); dump();
+mov (ecx, ptr[r11+rbx*2-1]); dump();
+mov (ecx, ptr[r11+rbx*2-1000]); dump();
+mov (ecx, ptr[r11+rbx*4+0]); dump();
+mov (ecx, ptr[r11+rbx*4+1]); dump();
+mov (ecx, ptr[r11+rbx*4+1000]); dump();
+mov (ecx, ptr[r11+rbx*4-1]); dump();
+mov (ecx, ptr[r11+rbx*4-1000]); dump();
+mov (ecx, ptr[r11+rbx*8+0]); dump();
+mov (ecx, ptr[r11+rbx*8+1]); dump();
+mov (ecx, ptr[r11+rbx*8+1000]); dump();
+mov (ecx, ptr[r11+rbx*8-1]); dump();
+mov (ecx, ptr[r11+rbx*8-1000]); dump();
+mov (ecx, ptr[r11+rbp+0]); dump();
+mov (ecx, ptr[r11+rbp+1]); dump();
+mov (ecx, ptr[r11+rbp+1000]); dump();
+mov (ecx, ptr[r11+rbp-1]); dump();
+mov (ecx, ptr[r11+rbp-1000]); dump();
+mov (ecx, ptr[r11+rbp*1+0]); dump();
+mov (ecx, ptr[r11+rbp*1+1]); dump();
+mov (ecx, ptr[r11+rbp*1+1000]); dump();
+mov (ecx, ptr[r11+rbp*1-1]); dump();
+mov (ecx, ptr[r11+rbp*1-1000]); dump();
+mov (ecx, ptr[r11+rbp*2+0]); dump();
+mov (ecx, ptr[r11+rbp*2+1]); dump();
+mov (ecx, ptr[r11+rbp*2+1000]); dump();
+mov (ecx, ptr[r11+rbp*2-1]); dump();
+mov (ecx, ptr[r11+rbp*2-1000]); dump();
+mov (ecx, ptr[r11+rbp*4+0]); dump();
+mov (ecx, ptr[r11+rbp*4+1]); dump();
+mov (ecx, ptr[r11+rbp*4+1000]); dump();
+mov (ecx, ptr[r11+rbp*4-1]); dump();
+mov (ecx, ptr[r11+rbp*4-1000]); dump();
+mov (ecx, ptr[r11+rbp*8+0]); dump();
+mov (ecx, ptr[r11+rbp*8+1]); dump();
+mov (ecx, ptr[r11+rbp*8+1000]); dump();
+mov (ecx, ptr[r11+rbp*8-1]); dump();
+mov (ecx, ptr[r11+rbp*8-1000]); dump();
+mov (ecx, ptr[r11+rsi+0]); dump();
+mov (ecx, ptr[r11+rsi+1]); dump();
+mov (ecx, ptr[r11+rsi+1000]); dump();
+mov (ecx, ptr[r11+rsi-1]); dump();
+mov (ecx, ptr[r11+rsi-1000]); dump();
+mov (ecx, ptr[r11+rsi*1+0]); dump();
+mov (ecx, ptr[r11+rsi*1+1]); dump();
+mov (ecx, ptr[r11+rsi*1+1000]); dump();
+mov (ecx, ptr[r11+rsi*1-1]); dump();
+mov (ecx, ptr[r11+rsi*1-1000]); dump();
+mov (ecx, ptr[r11+rsi*2+0]); dump();
+mov (ecx, ptr[r11+rsi*2+1]); dump();
+mov (ecx, ptr[r11+rsi*2+1000]); dump();
+mov (ecx, ptr[r11+rsi*2-1]); dump();
+mov (ecx, ptr[r11+rsi*2-1000]); dump();
+mov (ecx, ptr[r11+rsi*4+0]); dump();
+mov (ecx, ptr[r11+rsi*4+1]); dump();
+mov (ecx, ptr[r11+rsi*4+1000]); dump();
+mov (ecx, ptr[r11+rsi*4-1]); dump();
+mov (ecx, ptr[r11+rsi*4-1000]); dump();
+mov (ecx, ptr[r11+rsi*8+0]); dump();
+mov (ecx, ptr[r11+rsi*8+1]); dump();
+mov (ecx, ptr[r11+rsi*8+1000]); dump();
+mov (ecx, ptr[r11+rsi*8-1]); dump();
+mov (ecx, ptr[r11+rsi*8-1000]); dump();
+}
+    void gen39(){
+mov (ecx, ptr[r11+rdi+0]); dump();
+mov (ecx, ptr[r11+rdi+1]); dump();
+mov (ecx, ptr[r11+rdi+1000]); dump();
+mov (ecx, ptr[r11+rdi-1]); dump();
+mov (ecx, ptr[r11+rdi-1000]); dump();
+mov (ecx, ptr[r11+rdi*1+0]); dump();
+mov (ecx, ptr[r11+rdi*1+1]); dump();
+mov (ecx, ptr[r11+rdi*1+1000]); dump();
+mov (ecx, ptr[r11+rdi*1-1]); dump();
+mov (ecx, ptr[r11+rdi*1-1000]); dump();
+mov (ecx, ptr[r11+rdi*2+0]); dump();
+mov (ecx, ptr[r11+rdi*2+1]); dump();
+mov (ecx, ptr[r11+rdi*2+1000]); dump();
+mov (ecx, ptr[r11+rdi*2-1]); dump();
+mov (ecx, ptr[r11+rdi*2-1000]); dump();
+mov (ecx, ptr[r11+rdi*4+0]); dump();
+mov (ecx, ptr[r11+rdi*4+1]); dump();
+mov (ecx, ptr[r11+rdi*4+1000]); dump();
+mov (ecx, ptr[r11+rdi*4-1]); dump();
+mov (ecx, ptr[r11+rdi*4-1000]); dump();
+mov (ecx, ptr[r11+rdi*8+0]); dump();
+mov (ecx, ptr[r11+rdi*8+1]); dump();
+mov (ecx, ptr[r11+rdi*8+1000]); dump();
+mov (ecx, ptr[r11+rdi*8-1]); dump();
+mov (ecx, ptr[r11+rdi*8-1000]); dump();
+mov (ecx, ptr[r11+r9+0]); dump();
+mov (ecx, ptr[r11+r9+1]); dump();
+mov (ecx, ptr[r11+r9+1000]); dump();
+mov (ecx, ptr[r11+r9-1]); dump();
+mov (ecx, ptr[r11+r9-1000]); dump();
+mov (ecx, ptr[r11+r9*1+0]); dump();
+mov (ecx, ptr[r11+r9*1+1]); dump();
+mov (ecx, ptr[r11+r9*1+1000]); dump();
+mov (ecx, ptr[r11+r9*1-1]); dump();
+mov (ecx, ptr[r11+r9*1-1000]); dump();
+mov (ecx, ptr[r11+r9*2+0]); dump();
+mov (ecx, ptr[r11+r9*2+1]); dump();
+mov (ecx, ptr[r11+r9*2+1000]); dump();
+mov (ecx, ptr[r11+r9*2-1]); dump();
+mov (ecx, ptr[r11+r9*2-1000]); dump();
+mov (ecx, ptr[r11+r9*4+0]); dump();
+mov (ecx, ptr[r11+r9*4+1]); dump();
+mov (ecx, ptr[r11+r9*4+1000]); dump();
+mov (ecx, ptr[r11+r9*4-1]); dump();
+mov (ecx, ptr[r11+r9*4-1000]); dump();
+mov (ecx, ptr[r11+r9*8+0]); dump();
+mov (ecx, ptr[r11+r9*8+1]); dump();
+mov (ecx, ptr[r11+r9*8+1000]); dump();
+mov (ecx, ptr[r11+r9*8-1]); dump();
+mov (ecx, ptr[r11+r9*8-1000]); dump();
+mov (ecx, ptr[r11+r10+0]); dump();
+mov (ecx, ptr[r11+r10+1]); dump();
+mov (ecx, ptr[r11+r10+1000]); dump();
+mov (ecx, ptr[r11+r10-1]); dump();
+mov (ecx, ptr[r11+r10-1000]); dump();
+mov (ecx, ptr[r11+r10*1+0]); dump();
+mov (ecx, ptr[r11+r10*1+1]); dump();
+mov (ecx, ptr[r11+r10*1+1000]); dump();
+mov (ecx, ptr[r11+r10*1-1]); dump();
+mov (ecx, ptr[r11+r10*1-1000]); dump();
+mov (ecx, ptr[r11+r10*2+0]); dump();
+mov (ecx, ptr[r11+r10*2+1]); dump();
+mov (ecx, ptr[r11+r10*2+1000]); dump();
+mov (ecx, ptr[r11+r10*2-1]); dump();
+mov (ecx, ptr[r11+r10*2-1000]); dump();
+mov (ecx, ptr[r11+r10*4+0]); dump();
+mov (ecx, ptr[r11+r10*4+1]); dump();
+mov (ecx, ptr[r11+r10*4+1000]); dump();
+mov (ecx, ptr[r11+r10*4-1]); dump();
+mov (ecx, ptr[r11+r10*4-1000]); dump();
+mov (ecx, ptr[r11+r10*8+0]); dump();
+mov (ecx, ptr[r11+r10*8+1]); dump();
+mov (ecx, ptr[r11+r10*8+1000]); dump();
+mov (ecx, ptr[r11+r10*8-1]); dump();
+mov (ecx, ptr[r11+r10*8-1000]); dump();
+mov (ecx, ptr[r11+r11+0]); dump();
+mov (ecx, ptr[r11+r11+1]); dump();
+mov (ecx, ptr[r11+r11+1000]); dump();
+mov (ecx, ptr[r11+r11-1]); dump();
+mov (ecx, ptr[r11+r11-1000]); dump();
+mov (ecx, ptr[r11+r11*1+0]); dump();
+mov (ecx, ptr[r11+r11*1+1]); dump();
+mov (ecx, ptr[r11+r11*1+1000]); dump();
+mov (ecx, ptr[r11+r11*1-1]); dump();
+mov (ecx, ptr[r11+r11*1-1000]); dump();
+mov (ecx, ptr[r11+r11*2+0]); dump();
+mov (ecx, ptr[r11+r11*2+1]); dump();
+mov (ecx, ptr[r11+r11*2+1000]); dump();
+mov (ecx, ptr[r11+r11*2-1]); dump();
+mov (ecx, ptr[r11+r11*2-1000]); dump();
+mov (ecx, ptr[r11+r11*4+0]); dump();
+mov (ecx, ptr[r11+r11*4+1]); dump();
+mov (ecx, ptr[r11+r11*4+1000]); dump();
+mov (ecx, ptr[r11+r11*4-1]); dump();
+mov (ecx, ptr[r11+r11*4-1000]); dump();
+mov (ecx, ptr[r11+r11*8+0]); dump();
+mov (ecx, ptr[r11+r11*8+1]); dump();
+mov (ecx, ptr[r11+r11*8+1000]); dump();
+mov (ecx, ptr[r11+r11*8-1]); dump();
+mov (ecx, ptr[r11+r11*8-1000]); dump();
+}
+    void gen40(){
+mov (ecx, ptr[r11+r12+0]); dump();
+mov (ecx, ptr[r11+r12+1]); dump();
+mov (ecx, ptr[r11+r12+1000]); dump();
+mov (ecx, ptr[r11+r12-1]); dump();
+mov (ecx, ptr[r11+r12-1000]); dump();
+mov (ecx, ptr[r11+r12*1+0]); dump();
+mov (ecx, ptr[r11+r12*1+1]); dump();
+mov (ecx, ptr[r11+r12*1+1000]); dump();
+mov (ecx, ptr[r11+r12*1-1]); dump();
+mov (ecx, ptr[r11+r12*1-1000]); dump();
+mov (ecx, ptr[r11+r12*2+0]); dump();
+mov (ecx, ptr[r11+r12*2+1]); dump();
+mov (ecx, ptr[r11+r12*2+1000]); dump();
+mov (ecx, ptr[r11+r12*2-1]); dump();
+mov (ecx, ptr[r11+r12*2-1000]); dump();
+mov (ecx, ptr[r11+r12*4+0]); dump();
+mov (ecx, ptr[r11+r12*4+1]); dump();
+mov (ecx, ptr[r11+r12*4+1000]); dump();
+mov (ecx, ptr[r11+r12*4-1]); dump();
+mov (ecx, ptr[r11+r12*4-1000]); dump();
+mov (ecx, ptr[r11+r12*8+0]); dump();
+mov (ecx, ptr[r11+r12*8+1]); dump();
+mov (ecx, ptr[r11+r12*8+1000]); dump();
+mov (ecx, ptr[r11+r12*8-1]); dump();
+mov (ecx, ptr[r11+r12*8-1000]); dump();
+mov (ecx, ptr[r11+r13+0]); dump();
+mov (ecx, ptr[r11+r13+1]); dump();
+mov (ecx, ptr[r11+r13+1000]); dump();
+mov (ecx, ptr[r11+r13-1]); dump();
+mov (ecx, ptr[r11+r13-1000]); dump();
+mov (ecx, ptr[r11+r13*1+0]); dump();
+mov (ecx, ptr[r11+r13*1+1]); dump();
+mov (ecx, ptr[r11+r13*1+1000]); dump();
+mov (ecx, ptr[r11+r13*1-1]); dump();
+mov (ecx, ptr[r11+r13*1-1000]); dump();
+mov (ecx, ptr[r11+r13*2+0]); dump();
+mov (ecx, ptr[r11+r13*2+1]); dump();
+mov (ecx, ptr[r11+r13*2+1000]); dump();
+mov (ecx, ptr[r11+r13*2-1]); dump();
+mov (ecx, ptr[r11+r13*2-1000]); dump();
+mov (ecx, ptr[r11+r13*4+0]); dump();
+mov (ecx, ptr[r11+r13*4+1]); dump();
+mov (ecx, ptr[r11+r13*4+1000]); dump();
+mov (ecx, ptr[r11+r13*4-1]); dump();
+mov (ecx, ptr[r11+r13*4-1000]); dump();
+mov (ecx, ptr[r11+r13*8+0]); dump();
+mov (ecx, ptr[r11+r13*8+1]); dump();
+mov (ecx, ptr[r11+r13*8+1000]); dump();
+mov (ecx, ptr[r11+r13*8-1]); dump();
+mov (ecx, ptr[r11+r13*8-1000]); dump();
+mov (ecx, ptr[r11+r14+0]); dump();
+mov (ecx, ptr[r11+r14+1]); dump();
+mov (ecx, ptr[r11+r14+1000]); dump();
+mov (ecx, ptr[r11+r14-1]); dump();
+mov (ecx, ptr[r11+r14-1000]); dump();
+mov (ecx, ptr[r11+r14*1+0]); dump();
+mov (ecx, ptr[r11+r14*1+1]); dump();
+mov (ecx, ptr[r11+r14*1+1000]); dump();
+mov (ecx, ptr[r11+r14*1-1]); dump();
+mov (ecx, ptr[r11+r14*1-1000]); dump();
+mov (ecx, ptr[r11+r14*2+0]); dump();
+mov (ecx, ptr[r11+r14*2+1]); dump();
+mov (ecx, ptr[r11+r14*2+1000]); dump();
+mov (ecx, ptr[r11+r14*2-1]); dump();
+mov (ecx, ptr[r11+r14*2-1000]); dump();
+mov (ecx, ptr[r11+r14*4+0]); dump();
+mov (ecx, ptr[r11+r14*4+1]); dump();
+mov (ecx, ptr[r11+r14*4+1000]); dump();
+mov (ecx, ptr[r11+r14*4-1]); dump();
+mov (ecx, ptr[r11+r14*4-1000]); dump();
+mov (ecx, ptr[r11+r14*8+0]); dump();
+mov (ecx, ptr[r11+r14*8+1]); dump();
+mov (ecx, ptr[r11+r14*8+1000]); dump();
+mov (ecx, ptr[r11+r14*8-1]); dump();
+mov (ecx, ptr[r11+r14*8-1000]); dump();
+mov (ecx, ptr[r11+r15+0]); dump();
+mov (ecx, ptr[r11+r15+1]); dump();
+mov (ecx, ptr[r11+r15+1000]); dump();
+mov (ecx, ptr[r11+r15-1]); dump();
+mov (ecx, ptr[r11+r15-1000]); dump();
+mov (ecx, ptr[r11+r15*1+0]); dump();
+mov (ecx, ptr[r11+r15*1+1]); dump();
+mov (ecx, ptr[r11+r15*1+1000]); dump();
+mov (ecx, ptr[r11+r15*1-1]); dump();
+mov (ecx, ptr[r11+r15*1-1000]); dump();
+mov (ecx, ptr[r11+r15*2+0]); dump();
+mov (ecx, ptr[r11+r15*2+1]); dump();
+mov (ecx, ptr[r11+r15*2+1000]); dump();
+mov (ecx, ptr[r11+r15*2-1]); dump();
+mov (ecx, ptr[r11+r15*2-1000]); dump();
+mov (ecx, ptr[r11+r15*4+0]); dump();
+mov (ecx, ptr[r11+r15*4+1]); dump();
+mov (ecx, ptr[r11+r15*4+1000]); dump();
+mov (ecx, ptr[r11+r15*4-1]); dump();
+mov (ecx, ptr[r11+r15*4-1000]); dump();
+mov (ecx, ptr[r11+r15*8+0]); dump();
+mov (ecx, ptr[r11+r15*8+1]); dump();
+mov (ecx, ptr[r11+r15*8+1000]); dump();
+mov (ecx, ptr[r11+r15*8-1]); dump();
+mov (ecx, ptr[r11+r15*8-1000]); dump();
+}
+    void gen41(){
+mov (ecx, ptr[r11+0]); dump();
+mov (ecx, ptr[r11+1]); dump();
+mov (ecx, ptr[r11+1000]); dump();
+mov (ecx, ptr[r11-1]); dump();
+mov (ecx, ptr[r11-1000]); dump();
+mov (ecx, ptr[r11+0]); dump();
+mov (ecx, ptr[r11+1]); dump();
+mov (ecx, ptr[r11+1000]); dump();
+mov (ecx, ptr[r11-1]); dump();
+mov (ecx, ptr[r11-1000]); dump();
+mov (ecx, ptr[r11+0]); dump();
+mov (ecx, ptr[r11+1]); dump();
+mov (ecx, ptr[r11+1000]); dump();
+mov (ecx, ptr[r11-1]); dump();
+mov (ecx, ptr[r11-1000]); dump();
+mov (ecx, ptr[r11+0]); dump();
+mov (ecx, ptr[r11+1]); dump();
+mov (ecx, ptr[r11+1000]); dump();
+mov (ecx, ptr[r11-1]); dump();
+mov (ecx, ptr[r11-1000]); dump();
+mov (ecx, ptr[r11+0]); dump();
+mov (ecx, ptr[r11+1]); dump();
+mov (ecx, ptr[r11+1000]); dump();
+mov (ecx, ptr[r11-1]); dump();
+mov (ecx, ptr[r11-1000]); dump();
+mov (ecx, ptr[r12+rax+0]); dump();
+mov (ecx, ptr[r12+rax+1]); dump();
+mov (ecx, ptr[r12+rax+1000]); dump();
+mov (ecx, ptr[r12+rax-1]); dump();
+mov (ecx, ptr[r12+rax-1000]); dump();
+mov (ecx, ptr[r12+rax*1+0]); dump();
+mov (ecx, ptr[r12+rax*1+1]); dump();
+mov (ecx, ptr[r12+rax*1+1000]); dump();
+mov (ecx, ptr[r12+rax*1-1]); dump();
+mov (ecx, ptr[r12+rax*1-1000]); dump();
+mov (ecx, ptr[r12+rax*2+0]); dump();
+mov (ecx, ptr[r12+rax*2+1]); dump();
+mov (ecx, ptr[r12+rax*2+1000]); dump();
+mov (ecx, ptr[r12+rax*2-1]); dump();
+mov (ecx, ptr[r12+rax*2-1000]); dump();
+mov (ecx, ptr[r12+rax*4+0]); dump();
+mov (ecx, ptr[r12+rax*4+1]); dump();
+mov (ecx, ptr[r12+rax*4+1000]); dump();
+mov (ecx, ptr[r12+rax*4-1]); dump();
+mov (ecx, ptr[r12+rax*4-1000]); dump();
+mov (ecx, ptr[r12+rax*8+0]); dump();
+mov (ecx, ptr[r12+rax*8+1]); dump();
+mov (ecx, ptr[r12+rax*8+1000]); dump();
+mov (ecx, ptr[r12+rax*8-1]); dump();
+mov (ecx, ptr[r12+rax*8-1000]); dump();
+mov (ecx, ptr[r12+rcx+0]); dump();
+mov (ecx, ptr[r12+rcx+1]); dump();
+mov (ecx, ptr[r12+rcx+1000]); dump();
+mov (ecx, ptr[r12+rcx-1]); dump();
+mov (ecx, ptr[r12+rcx-1000]); dump();
+mov (ecx, ptr[r12+rcx*1+0]); dump();
+mov (ecx, ptr[r12+rcx*1+1]); dump();
+mov (ecx, ptr[r12+rcx*1+1000]); dump();
+mov (ecx, ptr[r12+rcx*1-1]); dump();
+mov (ecx, ptr[r12+rcx*1-1000]); dump();
+mov (ecx, ptr[r12+rcx*2+0]); dump();
+mov (ecx, ptr[r12+rcx*2+1]); dump();
+mov (ecx, ptr[r12+rcx*2+1000]); dump();
+mov (ecx, ptr[r12+rcx*2-1]); dump();
+mov (ecx, ptr[r12+rcx*2-1000]); dump();
+mov (ecx, ptr[r12+rcx*4+0]); dump();
+mov (ecx, ptr[r12+rcx*4+1]); dump();
+mov (ecx, ptr[r12+rcx*4+1000]); dump();
+mov (ecx, ptr[r12+rcx*4-1]); dump();
+mov (ecx, ptr[r12+rcx*4-1000]); dump();
+mov (ecx, ptr[r12+rcx*8+0]); dump();
+mov (ecx, ptr[r12+rcx*8+1]); dump();
+mov (ecx, ptr[r12+rcx*8+1000]); dump();
+mov (ecx, ptr[r12+rcx*8-1]); dump();
+mov (ecx, ptr[r12+rcx*8-1000]); dump();
+mov (ecx, ptr[r12+rdx+0]); dump();
+mov (ecx, ptr[r12+rdx+1]); dump();
+mov (ecx, ptr[r12+rdx+1000]); dump();
+mov (ecx, ptr[r12+rdx-1]); dump();
+mov (ecx, ptr[r12+rdx-1000]); dump();
+mov (ecx, ptr[r12+rdx*1+0]); dump();
+mov (ecx, ptr[r12+rdx*1+1]); dump();
+mov (ecx, ptr[r12+rdx*1+1000]); dump();
+mov (ecx, ptr[r12+rdx*1-1]); dump();
+mov (ecx, ptr[r12+rdx*1-1000]); dump();
+mov (ecx, ptr[r12+rdx*2+0]); dump();
+mov (ecx, ptr[r12+rdx*2+1]); dump();
+mov (ecx, ptr[r12+rdx*2+1000]); dump();
+mov (ecx, ptr[r12+rdx*2-1]); dump();
+mov (ecx, ptr[r12+rdx*2-1000]); dump();
+mov (ecx, ptr[r12+rdx*4+0]); dump();
+mov (ecx, ptr[r12+rdx*4+1]); dump();
+mov (ecx, ptr[r12+rdx*4+1000]); dump();
+mov (ecx, ptr[r12+rdx*4-1]); dump();
+mov (ecx, ptr[r12+rdx*4-1000]); dump();
+mov (ecx, ptr[r12+rdx*8+0]); dump();
+mov (ecx, ptr[r12+rdx*8+1]); dump();
+mov (ecx, ptr[r12+rdx*8+1000]); dump();
+mov (ecx, ptr[r12+rdx*8-1]); dump();
+mov (ecx, ptr[r12+rdx*8-1000]); dump();
+}
+    void gen42(){
+mov (ecx, ptr[r12+rbx+0]); dump();
+mov (ecx, ptr[r12+rbx+1]); dump();
+mov (ecx, ptr[r12+rbx+1000]); dump();
+mov (ecx, ptr[r12+rbx-1]); dump();
+mov (ecx, ptr[r12+rbx-1000]); dump();
+mov (ecx, ptr[r12+rbx*1+0]); dump();
+mov (ecx, ptr[r12+rbx*1+1]); dump();
+mov (ecx, ptr[r12+rbx*1+1000]); dump();
+mov (ecx, ptr[r12+rbx*1-1]); dump();
+mov (ecx, ptr[r12+rbx*1-1000]); dump();
+mov (ecx, ptr[r12+rbx*2+0]); dump();
+mov (ecx, ptr[r12+rbx*2+1]); dump();
+mov (ecx, ptr[r12+rbx*2+1000]); dump();
+mov (ecx, ptr[r12+rbx*2-1]); dump();
+mov (ecx, ptr[r12+rbx*2-1000]); dump();
+mov (ecx, ptr[r12+rbx*4+0]); dump();
+mov (ecx, ptr[r12+rbx*4+1]); dump();
+mov (ecx, ptr[r12+rbx*4+1000]); dump();
+mov (ecx, ptr[r12+rbx*4-1]); dump();
+mov (ecx, ptr[r12+rbx*4-1000]); dump();
+mov (ecx, ptr[r12+rbx*8+0]); dump();
+mov (ecx, ptr[r12+rbx*8+1]); dump();
+mov (ecx, ptr[r12+rbx*8+1000]); dump();
+mov (ecx, ptr[r12+rbx*8-1]); dump();
+mov (ecx, ptr[r12+rbx*8-1000]); dump();
+mov (ecx, ptr[r12+rbp+0]); dump();
+mov (ecx, ptr[r12+rbp+1]); dump();
+mov (ecx, ptr[r12+rbp+1000]); dump();
+mov (ecx, ptr[r12+rbp-1]); dump();
+mov (ecx, ptr[r12+rbp-1000]); dump();
+mov (ecx, ptr[r12+rbp*1+0]); dump();
+mov (ecx, ptr[r12+rbp*1+1]); dump();
+mov (ecx, ptr[r12+rbp*1+1000]); dump();
+mov (ecx, ptr[r12+rbp*1-1]); dump();
+mov (ecx, ptr[r12+rbp*1-1000]); dump();
+mov (ecx, ptr[r12+rbp*2+0]); dump();
+mov (ecx, ptr[r12+rbp*2+1]); dump();
+mov (ecx, ptr[r12+rbp*2+1000]); dump();
+mov (ecx, ptr[r12+rbp*2-1]); dump();
+mov (ecx, ptr[r12+rbp*2-1000]); dump();
+mov (ecx, ptr[r12+rbp*4+0]); dump();
+mov (ecx, ptr[r12+rbp*4+1]); dump();
+mov (ecx, ptr[r12+rbp*4+1000]); dump();
+mov (ecx, ptr[r12+rbp*4-1]); dump();
+mov (ecx, ptr[r12+rbp*4-1000]); dump();
+mov (ecx, ptr[r12+rbp*8+0]); dump();
+mov (ecx, ptr[r12+rbp*8+1]); dump();
+mov (ecx, ptr[r12+rbp*8+1000]); dump();
+mov (ecx, ptr[r12+rbp*8-1]); dump();
+mov (ecx, ptr[r12+rbp*8-1000]); dump();
+mov (ecx, ptr[r12+rsi+0]); dump();
+mov (ecx, ptr[r12+rsi+1]); dump();
+mov (ecx, ptr[r12+rsi+1000]); dump();
+mov (ecx, ptr[r12+rsi-1]); dump();
+mov (ecx, ptr[r12+rsi-1000]); dump();
+mov (ecx, ptr[r12+rsi*1+0]); dump();
+mov (ecx, ptr[r12+rsi*1+1]); dump();
+mov (ecx, ptr[r12+rsi*1+1000]); dump();
+mov (ecx, ptr[r12+rsi*1-1]); dump();
+mov (ecx, ptr[r12+rsi*1-1000]); dump();
+mov (ecx, ptr[r12+rsi*2+0]); dump();
+mov (ecx, ptr[r12+rsi*2+1]); dump();
+mov (ecx, ptr[r12+rsi*2+1000]); dump();
+mov (ecx, ptr[r12+rsi*2-1]); dump();
+mov (ecx, ptr[r12+rsi*2-1000]); dump();
+mov (ecx, ptr[r12+rsi*4+0]); dump();
+mov (ecx, ptr[r12+rsi*4+1]); dump();
+mov (ecx, ptr[r12+rsi*4+1000]); dump();
+mov (ecx, ptr[r12+rsi*4-1]); dump();
+mov (ecx, ptr[r12+rsi*4-1000]); dump();
+mov (ecx, ptr[r12+rsi*8+0]); dump();
+mov (ecx, ptr[r12+rsi*8+1]); dump();
+mov (ecx, ptr[r12+rsi*8+1000]); dump();
+mov (ecx, ptr[r12+rsi*8-1]); dump();
+mov (ecx, ptr[r12+rsi*8-1000]); dump();
+mov (ecx, ptr[r12+rdi+0]); dump();
+mov (ecx, ptr[r12+rdi+1]); dump();
+mov (ecx, ptr[r12+rdi+1000]); dump();
+mov (ecx, ptr[r12+rdi-1]); dump();
+mov (ecx, ptr[r12+rdi-1000]); dump();
+mov (ecx, ptr[r12+rdi*1+0]); dump();
+mov (ecx, ptr[r12+rdi*1+1]); dump();
+mov (ecx, ptr[r12+rdi*1+1000]); dump();
+mov (ecx, ptr[r12+rdi*1-1]); dump();
+mov (ecx, ptr[r12+rdi*1-1000]); dump();
+mov (ecx, ptr[r12+rdi*2+0]); dump();
+mov (ecx, ptr[r12+rdi*2+1]); dump();
+mov (ecx, ptr[r12+rdi*2+1000]); dump();
+mov (ecx, ptr[r12+rdi*2-1]); dump();
+mov (ecx, ptr[r12+rdi*2-1000]); dump();
+mov (ecx, ptr[r12+rdi*4+0]); dump();
+mov (ecx, ptr[r12+rdi*4+1]); dump();
+mov (ecx, ptr[r12+rdi*4+1000]); dump();
+mov (ecx, ptr[r12+rdi*4-1]); dump();
+mov (ecx, ptr[r12+rdi*4-1000]); dump();
+mov (ecx, ptr[r12+rdi*8+0]); dump();
+mov (ecx, ptr[r12+rdi*8+1]); dump();
+mov (ecx, ptr[r12+rdi*8+1000]); dump();
+mov (ecx, ptr[r12+rdi*8-1]); dump();
+mov (ecx, ptr[r12+rdi*8-1000]); dump();
+}
+    void gen43(){
+mov (ecx, ptr[r12+r9+0]); dump();
+mov (ecx, ptr[r12+r9+1]); dump();
+mov (ecx, ptr[r12+r9+1000]); dump();
+mov (ecx, ptr[r12+r9-1]); dump();
+mov (ecx, ptr[r12+r9-1000]); dump();
+mov (ecx, ptr[r12+r9*1+0]); dump();
+mov (ecx, ptr[r12+r9*1+1]); dump();
+mov (ecx, ptr[r12+r9*1+1000]); dump();
+mov (ecx, ptr[r12+r9*1-1]); dump();
+mov (ecx, ptr[r12+r9*1-1000]); dump();
+mov (ecx, ptr[r12+r9*2+0]); dump();
+mov (ecx, ptr[r12+r9*2+1]); dump();
+mov (ecx, ptr[r12+r9*2+1000]); dump();
+mov (ecx, ptr[r12+r9*2-1]); dump();
+mov (ecx, ptr[r12+r9*2-1000]); dump();
+mov (ecx, ptr[r12+r9*4+0]); dump();
+mov (ecx, ptr[r12+r9*4+1]); dump();
+mov (ecx, ptr[r12+r9*4+1000]); dump();
+mov (ecx, ptr[r12+r9*4-1]); dump();
+mov (ecx, ptr[r12+r9*4-1000]); dump();
+mov (ecx, ptr[r12+r9*8+0]); dump();
+mov (ecx, ptr[r12+r9*8+1]); dump();
+mov (ecx, ptr[r12+r9*8+1000]); dump();
+mov (ecx, ptr[r12+r9*8-1]); dump();
+mov (ecx, ptr[r12+r9*8-1000]); dump();
+mov (ecx, ptr[r12+r10+0]); dump();
+mov (ecx, ptr[r12+r10+1]); dump();
+mov (ecx, ptr[r12+r10+1000]); dump();
+mov (ecx, ptr[r12+r10-1]); dump();
+mov (ecx, ptr[r12+r10-1000]); dump();
+mov (ecx, ptr[r12+r10*1+0]); dump();
+mov (ecx, ptr[r12+r10*1+1]); dump();
+mov (ecx, ptr[r12+r10*1+1000]); dump();
+mov (ecx, ptr[r12+r10*1-1]); dump();
+mov (ecx, ptr[r12+r10*1-1000]); dump();
+mov (ecx, ptr[r12+r10*2+0]); dump();
+mov (ecx, ptr[r12+r10*2+1]); dump();
+mov (ecx, ptr[r12+r10*2+1000]); dump();
+mov (ecx, ptr[r12+r10*2-1]); dump();
+mov (ecx, ptr[r12+r10*2-1000]); dump();
+mov (ecx, ptr[r12+r10*4+0]); dump();
+mov (ecx, ptr[r12+r10*4+1]); dump();
+mov (ecx, ptr[r12+r10*4+1000]); dump();
+mov (ecx, ptr[r12+r10*4-1]); dump();
+mov (ecx, ptr[r12+r10*4-1000]); dump();
+mov (ecx, ptr[r12+r10*8+0]); dump();
+mov (ecx, ptr[r12+r10*8+1]); dump();
+mov (ecx, ptr[r12+r10*8+1000]); dump();
+mov (ecx, ptr[r12+r10*8-1]); dump();
+mov (ecx, ptr[r12+r10*8-1000]); dump();
+mov (ecx, ptr[r12+r11+0]); dump();
+mov (ecx, ptr[r12+r11+1]); dump();
+mov (ecx, ptr[r12+r11+1000]); dump();
+mov (ecx, ptr[r12+r11-1]); dump();
+mov (ecx, ptr[r12+r11-1000]); dump();
+mov (ecx, ptr[r12+r11*1+0]); dump();
+mov (ecx, ptr[r12+r11*1+1]); dump();
+mov (ecx, ptr[r12+r11*1+1000]); dump();
+mov (ecx, ptr[r12+r11*1-1]); dump();
+mov (ecx, ptr[r12+r11*1-1000]); dump();
+mov (ecx, ptr[r12+r11*2+0]); dump();
+mov (ecx, ptr[r12+r11*2+1]); dump();
+mov (ecx, ptr[r12+r11*2+1000]); dump();
+mov (ecx, ptr[r12+r11*2-1]); dump();
+mov (ecx, ptr[r12+r11*2-1000]); dump();
+mov (ecx, ptr[r12+r11*4+0]); dump();
+mov (ecx, ptr[r12+r11*4+1]); dump();
+mov (ecx, ptr[r12+r11*4+1000]); dump();
+mov (ecx, ptr[r12+r11*4-1]); dump();
+mov (ecx, ptr[r12+r11*4-1000]); dump();
+mov (ecx, ptr[r12+r11*8+0]); dump();
+mov (ecx, ptr[r12+r11*8+1]); dump();
+mov (ecx, ptr[r12+r11*8+1000]); dump();
+mov (ecx, ptr[r12+r11*8-1]); dump();
+mov (ecx, ptr[r12+r11*8-1000]); dump();
+mov (ecx, ptr[r12+r12+0]); dump();
+mov (ecx, ptr[r12+r12+1]); dump();
+mov (ecx, ptr[r12+r12+1000]); dump();
+mov (ecx, ptr[r12+r12-1]); dump();
+mov (ecx, ptr[r12+r12-1000]); dump();
+mov (ecx, ptr[r12+r12*1+0]); dump();
+mov (ecx, ptr[r12+r12*1+1]); dump();
+mov (ecx, ptr[r12+r12*1+1000]); dump();
+mov (ecx, ptr[r12+r12*1-1]); dump();
+mov (ecx, ptr[r12+r12*1-1000]); dump();
+mov (ecx, ptr[r12+r12*2+0]); dump();
+mov (ecx, ptr[r12+r12*2+1]); dump();
+mov (ecx, ptr[r12+r12*2+1000]); dump();
+mov (ecx, ptr[r12+r12*2-1]); dump();
+mov (ecx, ptr[r12+r12*2-1000]); dump();
+mov (ecx, ptr[r12+r12*4+0]); dump();
+mov (ecx, ptr[r12+r12*4+1]); dump();
+mov (ecx, ptr[r12+r12*4+1000]); dump();
+mov (ecx, ptr[r12+r12*4-1]); dump();
+mov (ecx, ptr[r12+r12*4-1000]); dump();
+mov (ecx, ptr[r12+r12*8+0]); dump();
+mov (ecx, ptr[r12+r12*8+1]); dump();
+mov (ecx, ptr[r12+r12*8+1000]); dump();
+mov (ecx, ptr[r12+r12*8-1]); dump();
+mov (ecx, ptr[r12+r12*8-1000]); dump();
+}
+    void gen44(){
+mov (ecx, ptr[r12+r13+0]); dump();
+mov (ecx, ptr[r12+r13+1]); dump();
+mov (ecx, ptr[r12+r13+1000]); dump();
+mov (ecx, ptr[r12+r13-1]); dump();
+mov (ecx, ptr[r12+r13-1000]); dump();
+mov (ecx, ptr[r12+r13*1+0]); dump();
+mov (ecx, ptr[r12+r13*1+1]); dump();
+mov (ecx, ptr[r12+r13*1+1000]); dump();
+mov (ecx, ptr[r12+r13*1-1]); dump();
+mov (ecx, ptr[r12+r13*1-1000]); dump();
+mov (ecx, ptr[r12+r13*2+0]); dump();
+mov (ecx, ptr[r12+r13*2+1]); dump();
+mov (ecx, ptr[r12+r13*2+1000]); dump();
+mov (ecx, ptr[r12+r13*2-1]); dump();
+mov (ecx, ptr[r12+r13*2-1000]); dump();
+mov (ecx, ptr[r12+r13*4+0]); dump();
+mov (ecx, ptr[r12+r13*4+1]); dump();
+mov (ecx, ptr[r12+r13*4+1000]); dump();
+mov (ecx, ptr[r12+r13*4-1]); dump();
+mov (ecx, ptr[r12+r13*4-1000]); dump();
+mov (ecx, ptr[r12+r13*8+0]); dump();
+mov (ecx, ptr[r12+r13*8+1]); dump();
+mov (ecx, ptr[r12+r13*8+1000]); dump();
+mov (ecx, ptr[r12+r13*8-1]); dump();
+mov (ecx, ptr[r12+r13*8-1000]); dump();
+mov (ecx, ptr[r12+r14+0]); dump();
+mov (ecx, ptr[r12+r14+1]); dump();
+mov (ecx, ptr[r12+r14+1000]); dump();
+mov (ecx, ptr[r12+r14-1]); dump();
+mov (ecx, ptr[r12+r14-1000]); dump();
+mov (ecx, ptr[r12+r14*1+0]); dump();
+mov (ecx, ptr[r12+r14*1+1]); dump();
+mov (ecx, ptr[r12+r14*1+1000]); dump();
+mov (ecx, ptr[r12+r14*1-1]); dump();
+mov (ecx, ptr[r12+r14*1-1000]); dump();
+mov (ecx, ptr[r12+r14*2+0]); dump();
+mov (ecx, ptr[r12+r14*2+1]); dump();
+mov (ecx, ptr[r12+r14*2+1000]); dump();
+mov (ecx, ptr[r12+r14*2-1]); dump();
+mov (ecx, ptr[r12+r14*2-1000]); dump();
+mov (ecx, ptr[r12+r14*4+0]); dump();
+mov (ecx, ptr[r12+r14*4+1]); dump();
+mov (ecx, ptr[r12+r14*4+1000]); dump();
+mov (ecx, ptr[r12+r14*4-1]); dump();
+mov (ecx, ptr[r12+r14*4-1000]); dump();
+mov (ecx, ptr[r12+r14*8+0]); dump();
+mov (ecx, ptr[r12+r14*8+1]); dump();
+mov (ecx, ptr[r12+r14*8+1000]); dump();
+mov (ecx, ptr[r12+r14*8-1]); dump();
+mov (ecx, ptr[r12+r14*8-1000]); dump();
+mov (ecx, ptr[r12+r15+0]); dump();
+mov (ecx, ptr[r12+r15+1]); dump();
+mov (ecx, ptr[r12+r15+1000]); dump();
+mov (ecx, ptr[r12+r15-1]); dump();
+mov (ecx, ptr[r12+r15-1000]); dump();
+mov (ecx, ptr[r12+r15*1+0]); dump();
+mov (ecx, ptr[r12+r15*1+1]); dump();
+mov (ecx, ptr[r12+r15*1+1000]); dump();
+mov (ecx, ptr[r12+r15*1-1]); dump();
+mov (ecx, ptr[r12+r15*1-1000]); dump();
+mov (ecx, ptr[r12+r15*2+0]); dump();
+mov (ecx, ptr[r12+r15*2+1]); dump();
+mov (ecx, ptr[r12+r15*2+1000]); dump();
+mov (ecx, ptr[r12+r15*2-1]); dump();
+mov (ecx, ptr[r12+r15*2-1000]); dump();
+mov (ecx, ptr[r12+r15*4+0]); dump();
+mov (ecx, ptr[r12+r15*4+1]); dump();
+mov (ecx, ptr[r12+r15*4+1000]); dump();
+mov (ecx, ptr[r12+r15*4-1]); dump();
+mov (ecx, ptr[r12+r15*4-1000]); dump();
+mov (ecx, ptr[r12+r15*8+0]); dump();
+mov (ecx, ptr[r12+r15*8+1]); dump();
+mov (ecx, ptr[r12+r15*8+1000]); dump();
+mov (ecx, ptr[r12+r15*8-1]); dump();
+mov (ecx, ptr[r12+r15*8-1000]); dump();
+mov (ecx, ptr[r12+0]); dump();
+mov (ecx, ptr[r12+1]); dump();
+mov (ecx, ptr[r12+1000]); dump();
+mov (ecx, ptr[r12-1]); dump();
+mov (ecx, ptr[r12-1000]); dump();
+mov (ecx, ptr[r12+0]); dump();
+mov (ecx, ptr[r12+1]); dump();
+mov (ecx, ptr[r12+1000]); dump();
+mov (ecx, ptr[r12-1]); dump();
+mov (ecx, ptr[r12-1000]); dump();
+mov (ecx, ptr[r12+0]); dump();
+mov (ecx, ptr[r12+1]); dump();
+mov (ecx, ptr[r12+1000]); dump();
+mov (ecx, ptr[r12-1]); dump();
+mov (ecx, ptr[r12-1000]); dump();
+mov (ecx, ptr[r12+0]); dump();
+mov (ecx, ptr[r12+1]); dump();
+mov (ecx, ptr[r12+1000]); dump();
+mov (ecx, ptr[r12-1]); dump();
+mov (ecx, ptr[r12-1000]); dump();
+mov (ecx, ptr[r12+0]); dump();
+mov (ecx, ptr[r12+1]); dump();
+mov (ecx, ptr[r12+1000]); dump();
+mov (ecx, ptr[r12-1]); dump();
+mov (ecx, ptr[r12-1000]); dump();
+}
+    void gen45(){
+mov (ecx, ptr[r13+rax+0]); dump();
+mov (ecx, ptr[r13+rax+1]); dump();
+mov (ecx, ptr[r13+rax+1000]); dump();
+mov (ecx, ptr[r13+rax-1]); dump();
+mov (ecx, ptr[r13+rax-1000]); dump();
+mov (ecx, ptr[r13+rax*1+0]); dump();
+mov (ecx, ptr[r13+rax*1+1]); dump();
+mov (ecx, ptr[r13+rax*1+1000]); dump();
+mov (ecx, ptr[r13+rax*1-1]); dump();
+mov (ecx, ptr[r13+rax*1-1000]); dump();
+mov (ecx, ptr[r13+rax*2+0]); dump();
+mov (ecx, ptr[r13+rax*2+1]); dump();
+mov (ecx, ptr[r13+rax*2+1000]); dump();
+mov (ecx, ptr[r13+rax*2-1]); dump();
+mov (ecx, ptr[r13+rax*2-1000]); dump();
+mov (ecx, ptr[r13+rax*4+0]); dump();
+mov (ecx, ptr[r13+rax*4+1]); dump();
+mov (ecx, ptr[r13+rax*4+1000]); dump();
+mov (ecx, ptr[r13+rax*4-1]); dump();
+mov (ecx, ptr[r13+rax*4-1000]); dump();
+mov (ecx, ptr[r13+rax*8+0]); dump();
+mov (ecx, ptr[r13+rax*8+1]); dump();
+mov (ecx, ptr[r13+rax*8+1000]); dump();
+mov (ecx, ptr[r13+rax*8-1]); dump();
+mov (ecx, ptr[r13+rax*8-1000]); dump();
+mov (ecx, ptr[r13+rcx+0]); dump();
+mov (ecx, ptr[r13+rcx+1]); dump();
+mov (ecx, ptr[r13+rcx+1000]); dump();
+mov (ecx, ptr[r13+rcx-1]); dump();
+mov (ecx, ptr[r13+rcx-1000]); dump();
+mov (ecx, ptr[r13+rcx*1+0]); dump();
+mov (ecx, ptr[r13+rcx*1+1]); dump();
+mov (ecx, ptr[r13+rcx*1+1000]); dump();
+mov (ecx, ptr[r13+rcx*1-1]); dump();
+mov (ecx, ptr[r13+rcx*1-1000]); dump();
+mov (ecx, ptr[r13+rcx*2+0]); dump();
+mov (ecx, ptr[r13+rcx*2+1]); dump();
+mov (ecx, ptr[r13+rcx*2+1000]); dump();
+mov (ecx, ptr[r13+rcx*2-1]); dump();
+mov (ecx, ptr[r13+rcx*2-1000]); dump();
+mov (ecx, ptr[r13+rcx*4+0]); dump();
+mov (ecx, ptr[r13+rcx*4+1]); dump();
+mov (ecx, ptr[r13+rcx*4+1000]); dump();
+mov (ecx, ptr[r13+rcx*4-1]); dump();
+mov (ecx, ptr[r13+rcx*4-1000]); dump();
+mov (ecx, ptr[r13+rcx*8+0]); dump();
+mov (ecx, ptr[r13+rcx*8+1]); dump();
+mov (ecx, ptr[r13+rcx*8+1000]); dump();
+mov (ecx, ptr[r13+rcx*8-1]); dump();
+mov (ecx, ptr[r13+rcx*8-1000]); dump();
+mov (ecx, ptr[r13+rdx+0]); dump();
+mov (ecx, ptr[r13+rdx+1]); dump();
+mov (ecx, ptr[r13+rdx+1000]); dump();
+mov (ecx, ptr[r13+rdx-1]); dump();
+mov (ecx, ptr[r13+rdx-1000]); dump();
+mov (ecx, ptr[r13+rdx*1+0]); dump();
+mov (ecx, ptr[r13+rdx*1+1]); dump();
+mov (ecx, ptr[r13+rdx*1+1000]); dump();
+mov (ecx, ptr[r13+rdx*1-1]); dump();
+mov (ecx, ptr[r13+rdx*1-1000]); dump();
+mov (ecx, ptr[r13+rdx*2+0]); dump();
+mov (ecx, ptr[r13+rdx*2+1]); dump();
+mov (ecx, ptr[r13+rdx*2+1000]); dump();
+mov (ecx, ptr[r13+rdx*2-1]); dump();
+mov (ecx, ptr[r13+rdx*2-1000]); dump();
+mov (ecx, ptr[r13+rdx*4+0]); dump();
+mov (ecx, ptr[r13+rdx*4+1]); dump();
+mov (ecx, ptr[r13+rdx*4+1000]); dump();
+mov (ecx, ptr[r13+rdx*4-1]); dump();
+mov (ecx, ptr[r13+rdx*4-1000]); dump();
+mov (ecx, ptr[r13+rdx*8+0]); dump();
+mov (ecx, ptr[r13+rdx*8+1]); dump();
+mov (ecx, ptr[r13+rdx*8+1000]); dump();
+mov (ecx, ptr[r13+rdx*8-1]); dump();
+mov (ecx, ptr[r13+rdx*8-1000]); dump();
+mov (ecx, ptr[r13+rbx+0]); dump();
+mov (ecx, ptr[r13+rbx+1]); dump();
+mov (ecx, ptr[r13+rbx+1000]); dump();
+mov (ecx, ptr[r13+rbx-1]); dump();
+mov (ecx, ptr[r13+rbx-1000]); dump();
+mov (ecx, ptr[r13+rbx*1+0]); dump();
+mov (ecx, ptr[r13+rbx*1+1]); dump();
+mov (ecx, ptr[r13+rbx*1+1000]); dump();
+mov (ecx, ptr[r13+rbx*1-1]); dump();
+mov (ecx, ptr[r13+rbx*1-1000]); dump();
+mov (ecx, ptr[r13+rbx*2+0]); dump();
+mov (ecx, ptr[r13+rbx*2+1]); dump();
+mov (ecx, ptr[r13+rbx*2+1000]); dump();
+mov (ecx, ptr[r13+rbx*2-1]); dump();
+mov (ecx, ptr[r13+rbx*2-1000]); dump();
+mov (ecx, ptr[r13+rbx*4+0]); dump();
+mov (ecx, ptr[r13+rbx*4+1]); dump();
+mov (ecx, ptr[r13+rbx*4+1000]); dump();
+mov (ecx, ptr[r13+rbx*4-1]); dump();
+mov (ecx, ptr[r13+rbx*4-1000]); dump();
+mov (ecx, ptr[r13+rbx*8+0]); dump();
+mov (ecx, ptr[r13+rbx*8+1]); dump();
+mov (ecx, ptr[r13+rbx*8+1000]); dump();
+mov (ecx, ptr[r13+rbx*8-1]); dump();
+mov (ecx, ptr[r13+rbx*8-1000]); dump();
+}
+    void gen46(){
+mov (ecx, ptr[r13+rbp+0]); dump();
+mov (ecx, ptr[r13+rbp+1]); dump();
+mov (ecx, ptr[r13+rbp+1000]); dump();
+mov (ecx, ptr[r13+rbp-1]); dump();
+mov (ecx, ptr[r13+rbp-1000]); dump();
+mov (ecx, ptr[r13+rbp*1+0]); dump();
+mov (ecx, ptr[r13+rbp*1+1]); dump();
+mov (ecx, ptr[r13+rbp*1+1000]); dump();
+mov (ecx, ptr[r13+rbp*1-1]); dump();
+mov (ecx, ptr[r13+rbp*1-1000]); dump();
+mov (ecx, ptr[r13+rbp*2+0]); dump();
+mov (ecx, ptr[r13+rbp*2+1]); dump();
+mov (ecx, ptr[r13+rbp*2+1000]); dump();
+mov (ecx, ptr[r13+rbp*2-1]); dump();
+mov (ecx, ptr[r13+rbp*2-1000]); dump();
+mov (ecx, ptr[r13+rbp*4+0]); dump();
+mov (ecx, ptr[r13+rbp*4+1]); dump();
+mov (ecx, ptr[r13+rbp*4+1000]); dump();
+mov (ecx, ptr[r13+rbp*4-1]); dump();
+mov (ecx, ptr[r13+rbp*4-1000]); dump();
+mov (ecx, ptr[r13+rbp*8+0]); dump();
+mov (ecx, ptr[r13+rbp*8+1]); dump();
+mov (ecx, ptr[r13+rbp*8+1000]); dump();
+mov (ecx, ptr[r13+rbp*8-1]); dump();
+mov (ecx, ptr[r13+rbp*8-1000]); dump();
+mov (ecx, ptr[r13+rsi+0]); dump();
+mov (ecx, ptr[r13+rsi+1]); dump();
+mov (ecx, ptr[r13+rsi+1000]); dump();
+mov (ecx, ptr[r13+rsi-1]); dump();
+mov (ecx, ptr[r13+rsi-1000]); dump();
+mov (ecx, ptr[r13+rsi*1+0]); dump();
+mov (ecx, ptr[r13+rsi*1+1]); dump();
+mov (ecx, ptr[r13+rsi*1+1000]); dump();
+mov (ecx, ptr[r13+rsi*1-1]); dump();
+mov (ecx, ptr[r13+rsi*1-1000]); dump();
+mov (ecx, ptr[r13+rsi*2+0]); dump();
+mov (ecx, ptr[r13+rsi*2+1]); dump();
+mov (ecx, ptr[r13+rsi*2+1000]); dump();
+mov (ecx, ptr[r13+rsi*2-1]); dump();
+mov (ecx, ptr[r13+rsi*2-1000]); dump();
+mov (ecx, ptr[r13+rsi*4+0]); dump();
+mov (ecx, ptr[r13+rsi*4+1]); dump();
+mov (ecx, ptr[r13+rsi*4+1000]); dump();
+mov (ecx, ptr[r13+rsi*4-1]); dump();
+mov (ecx, ptr[r13+rsi*4-1000]); dump();
+mov (ecx, ptr[r13+rsi*8+0]); dump();
+mov (ecx, ptr[r13+rsi*8+1]); dump();
+mov (ecx, ptr[r13+rsi*8+1000]); dump();
+mov (ecx, ptr[r13+rsi*8-1]); dump();
+mov (ecx, ptr[r13+rsi*8-1000]); dump();
+mov (ecx, ptr[r13+rdi+0]); dump();
+mov (ecx, ptr[r13+rdi+1]); dump();
+mov (ecx, ptr[r13+rdi+1000]); dump();
+mov (ecx, ptr[r13+rdi-1]); dump();
+mov (ecx, ptr[r13+rdi-1000]); dump();
+mov (ecx, ptr[r13+rdi*1+0]); dump();
+mov (ecx, ptr[r13+rdi*1+1]); dump();
+mov (ecx, ptr[r13+rdi*1+1000]); dump();
+mov (ecx, ptr[r13+rdi*1-1]); dump();
+mov (ecx, ptr[r13+rdi*1-1000]); dump();
+mov (ecx, ptr[r13+rdi*2+0]); dump();
+mov (ecx, ptr[r13+rdi*2+1]); dump();
+mov (ecx, ptr[r13+rdi*2+1000]); dump();
+mov (ecx, ptr[r13+rdi*2-1]); dump();
+mov (ecx, ptr[r13+rdi*2-1000]); dump();
+mov (ecx, ptr[r13+rdi*4+0]); dump();
+mov (ecx, ptr[r13+rdi*4+1]); dump();
+mov (ecx, ptr[r13+rdi*4+1000]); dump();
+mov (ecx, ptr[r13+rdi*4-1]); dump();
+mov (ecx, ptr[r13+rdi*4-1000]); dump();
+mov (ecx, ptr[r13+rdi*8+0]); dump();
+mov (ecx, ptr[r13+rdi*8+1]); dump();
+mov (ecx, ptr[r13+rdi*8+1000]); dump();
+mov (ecx, ptr[r13+rdi*8-1]); dump();
+mov (ecx, ptr[r13+rdi*8-1000]); dump();
+mov (ecx, ptr[r13+r9+0]); dump();
+mov (ecx, ptr[r13+r9+1]); dump();
+mov (ecx, ptr[r13+r9+1000]); dump();
+mov (ecx, ptr[r13+r9-1]); dump();
+mov (ecx, ptr[r13+r9-1000]); dump();
+mov (ecx, ptr[r13+r9*1+0]); dump();
+mov (ecx, ptr[r13+r9*1+1]); dump();
+mov (ecx, ptr[r13+r9*1+1000]); dump();
+mov (ecx, ptr[r13+r9*1-1]); dump();
+mov (ecx, ptr[r13+r9*1-1000]); dump();
+mov (ecx, ptr[r13+r9*2+0]); dump();
+mov (ecx, ptr[r13+r9*2+1]); dump();
+mov (ecx, ptr[r13+r9*2+1000]); dump();
+mov (ecx, ptr[r13+r9*2-1]); dump();
+mov (ecx, ptr[r13+r9*2-1000]); dump();
+mov (ecx, ptr[r13+r9*4+0]); dump();
+mov (ecx, ptr[r13+r9*4+1]); dump();
+mov (ecx, ptr[r13+r9*4+1000]); dump();
+mov (ecx, ptr[r13+r9*4-1]); dump();
+mov (ecx, ptr[r13+r9*4-1000]); dump();
+mov (ecx, ptr[r13+r9*8+0]); dump();
+mov (ecx, ptr[r13+r9*8+1]); dump();
+mov (ecx, ptr[r13+r9*8+1000]); dump();
+mov (ecx, ptr[r13+r9*8-1]); dump();
+mov (ecx, ptr[r13+r9*8-1000]); dump();
+}
+    void gen47(){
+mov (ecx, ptr[r13+r10+0]); dump();
+mov (ecx, ptr[r13+r10+1]); dump();
+mov (ecx, ptr[r13+r10+1000]); dump();
+mov (ecx, ptr[r13+r10-1]); dump();
+mov (ecx, ptr[r13+r10-1000]); dump();
+mov (ecx, ptr[r13+r10*1+0]); dump();
+mov (ecx, ptr[r13+r10*1+1]); dump();
+mov (ecx, ptr[r13+r10*1+1000]); dump();
+mov (ecx, ptr[r13+r10*1-1]); dump();
+mov (ecx, ptr[r13+r10*1-1000]); dump();
+mov (ecx, ptr[r13+r10*2+0]); dump();
+mov (ecx, ptr[r13+r10*2+1]); dump();
+mov (ecx, ptr[r13+r10*2+1000]); dump();
+mov (ecx, ptr[r13+r10*2-1]); dump();
+mov (ecx, ptr[r13+r10*2-1000]); dump();
+mov (ecx, ptr[r13+r10*4+0]); dump();
+mov (ecx, ptr[r13+r10*4+1]); dump();
+mov (ecx, ptr[r13+r10*4+1000]); dump();
+mov (ecx, ptr[r13+r10*4-1]); dump();
+mov (ecx, ptr[r13+r10*4-1000]); dump();
+mov (ecx, ptr[r13+r10*8+0]); dump();
+mov (ecx, ptr[r13+r10*8+1]); dump();
+mov (ecx, ptr[r13+r10*8+1000]); dump();
+mov (ecx, ptr[r13+r10*8-1]); dump();
+mov (ecx, ptr[r13+r10*8-1000]); dump();
+mov (ecx, ptr[r13+r11+0]); dump();
+mov (ecx, ptr[r13+r11+1]); dump();
+mov (ecx, ptr[r13+r11+1000]); dump();
+mov (ecx, ptr[r13+r11-1]); dump();
+mov (ecx, ptr[r13+r11-1000]); dump();
+mov (ecx, ptr[r13+r11*1+0]); dump();
+mov (ecx, ptr[r13+r11*1+1]); dump();
+mov (ecx, ptr[r13+r11*1+1000]); dump();
+mov (ecx, ptr[r13+r11*1-1]); dump();
+mov (ecx, ptr[r13+r11*1-1000]); dump();
+mov (ecx, ptr[r13+r11*2+0]); dump();
+mov (ecx, ptr[r13+r11*2+1]); dump();
+mov (ecx, ptr[r13+r11*2+1000]); dump();
+mov (ecx, ptr[r13+r11*2-1]); dump();
+mov (ecx, ptr[r13+r11*2-1000]); dump();
+mov (ecx, ptr[r13+r11*4+0]); dump();
+mov (ecx, ptr[r13+r11*4+1]); dump();
+mov (ecx, ptr[r13+r11*4+1000]); dump();
+mov (ecx, ptr[r13+r11*4-1]); dump();
+mov (ecx, ptr[r13+r11*4-1000]); dump();
+mov (ecx, ptr[r13+r11*8+0]); dump();
+mov (ecx, ptr[r13+r11*8+1]); dump();
+mov (ecx, ptr[r13+r11*8+1000]); dump();
+mov (ecx, ptr[r13+r11*8-1]); dump();
+mov (ecx, ptr[r13+r11*8-1000]); dump();
+mov (ecx, ptr[r13+r12+0]); dump();
+mov (ecx, ptr[r13+r12+1]); dump();
+mov (ecx, ptr[r13+r12+1000]); dump();
+mov (ecx, ptr[r13+r12-1]); dump();
+mov (ecx, ptr[r13+r12-1000]); dump();
+mov (ecx, ptr[r13+r12*1+0]); dump();
+mov (ecx, ptr[r13+r12*1+1]); dump();
+mov (ecx, ptr[r13+r12*1+1000]); dump();
+mov (ecx, ptr[r13+r12*1-1]); dump();
+mov (ecx, ptr[r13+r12*1-1000]); dump();
+mov (ecx, ptr[r13+r12*2+0]); dump();
+mov (ecx, ptr[r13+r12*2+1]); dump();
+mov (ecx, ptr[r13+r12*2+1000]); dump();
+mov (ecx, ptr[r13+r12*2-1]); dump();
+mov (ecx, ptr[r13+r12*2-1000]); dump();
+mov (ecx, ptr[r13+r12*4+0]); dump();
+mov (ecx, ptr[r13+r12*4+1]); dump();
+mov (ecx, ptr[r13+r12*4+1000]); dump();
+mov (ecx, ptr[r13+r12*4-1]); dump();
+mov (ecx, ptr[r13+r12*4-1000]); dump();
+mov (ecx, ptr[r13+r12*8+0]); dump();
+mov (ecx, ptr[r13+r12*8+1]); dump();
+mov (ecx, ptr[r13+r12*8+1000]); dump();
+mov (ecx, ptr[r13+r12*8-1]); dump();
+mov (ecx, ptr[r13+r12*8-1000]); dump();
+mov (ecx, ptr[r13+r13+0]); dump();
+mov (ecx, ptr[r13+r13+1]); dump();
+mov (ecx, ptr[r13+r13+1000]); dump();
+mov (ecx, ptr[r13+r13-1]); dump();
+mov (ecx, ptr[r13+r13-1000]); dump();
+mov (ecx, ptr[r13+r13*1+0]); dump();
+mov (ecx, ptr[r13+r13*1+1]); dump();
+mov (ecx, ptr[r13+r13*1+1000]); dump();
+mov (ecx, ptr[r13+r13*1-1]); dump();
+mov (ecx, ptr[r13+r13*1-1000]); dump();
+mov (ecx, ptr[r13+r13*2+0]); dump();
+mov (ecx, ptr[r13+r13*2+1]); dump();
+mov (ecx, ptr[r13+r13*2+1000]); dump();
+mov (ecx, ptr[r13+r13*2-1]); dump();
+mov (ecx, ptr[r13+r13*2-1000]); dump();
+mov (ecx, ptr[r13+r13*4+0]); dump();
+mov (ecx, ptr[r13+r13*4+1]); dump();
+mov (ecx, ptr[r13+r13*4+1000]); dump();
+mov (ecx, ptr[r13+r13*4-1]); dump();
+mov (ecx, ptr[r13+r13*4-1000]); dump();
+mov (ecx, ptr[r13+r13*8+0]); dump();
+mov (ecx, ptr[r13+r13*8+1]); dump();
+mov (ecx, ptr[r13+r13*8+1000]); dump();
+mov (ecx, ptr[r13+r13*8-1]); dump();
+mov (ecx, ptr[r13+r13*8-1000]); dump();
+}
+    void gen48(){
+mov (ecx, ptr[r13+r14+0]); dump();
+mov (ecx, ptr[r13+r14+1]); dump();
+mov (ecx, ptr[r13+r14+1000]); dump();
+mov (ecx, ptr[r13+r14-1]); dump();
+mov (ecx, ptr[r13+r14-1000]); dump();
+mov (ecx, ptr[r13+r14*1+0]); dump();
+mov (ecx, ptr[r13+r14*1+1]); dump();
+mov (ecx, ptr[r13+r14*1+1000]); dump();
+mov (ecx, ptr[r13+r14*1-1]); dump();
+mov (ecx, ptr[r13+r14*1-1000]); dump();
+mov (ecx, ptr[r13+r14*2+0]); dump();
+mov (ecx, ptr[r13+r14*2+1]); dump();
+mov (ecx, ptr[r13+r14*2+1000]); dump();
+mov (ecx, ptr[r13+r14*2-1]); dump();
+mov (ecx, ptr[r13+r14*2-1000]); dump();
+mov (ecx, ptr[r13+r14*4+0]); dump();
+mov (ecx, ptr[r13+r14*4+1]); dump();
+mov (ecx, ptr[r13+r14*4+1000]); dump();
+mov (ecx, ptr[r13+r14*4-1]); dump();
+mov (ecx, ptr[r13+r14*4-1000]); dump();
+mov (ecx, ptr[r13+r14*8+0]); dump();
+mov (ecx, ptr[r13+r14*8+1]); dump();
+mov (ecx, ptr[r13+r14*8+1000]); dump();
+mov (ecx, ptr[r13+r14*8-1]); dump();
+mov (ecx, ptr[r13+r14*8-1000]); dump();
+mov (ecx, ptr[r13+r15+0]); dump();
+mov (ecx, ptr[r13+r15+1]); dump();
+mov (ecx, ptr[r13+r15+1000]); dump();
+mov (ecx, ptr[r13+r15-1]); dump();
+mov (ecx, ptr[r13+r15-1000]); dump();
+mov (ecx, ptr[r13+r15*1+0]); dump();
+mov (ecx, ptr[r13+r15*1+1]); dump();
+mov (ecx, ptr[r13+r15*1+1000]); dump();
+mov (ecx, ptr[r13+r15*1-1]); dump();
+mov (ecx, ptr[r13+r15*1-1000]); dump();
+mov (ecx, ptr[r13+r15*2+0]); dump();
+mov (ecx, ptr[r13+r15*2+1]); dump();
+mov (ecx, ptr[r13+r15*2+1000]); dump();
+mov (ecx, ptr[r13+r15*2-1]); dump();
+mov (ecx, ptr[r13+r15*2-1000]); dump();
+mov (ecx, ptr[r13+r15*4+0]); dump();
+mov (ecx, ptr[r13+r15*4+1]); dump();
+mov (ecx, ptr[r13+r15*4+1000]); dump();
+mov (ecx, ptr[r13+r15*4-1]); dump();
+mov (ecx, ptr[r13+r15*4-1000]); dump();
+mov (ecx, ptr[r13+r15*8+0]); dump();
+mov (ecx, ptr[r13+r15*8+1]); dump();
+mov (ecx, ptr[r13+r15*8+1000]); dump();
+mov (ecx, ptr[r13+r15*8-1]); dump();
+mov (ecx, ptr[r13+r15*8-1000]); dump();
+mov (ecx, ptr[r13+0]); dump();
+mov (ecx, ptr[r13+1]); dump();
+mov (ecx, ptr[r13+1000]); dump();
+mov (ecx, ptr[r13-1]); dump();
+mov (ecx, ptr[r13-1000]); dump();
+mov (ecx, ptr[r13+0]); dump();
+mov (ecx, ptr[r13+1]); dump();
+mov (ecx, ptr[r13+1000]); dump();
+mov (ecx, ptr[r13-1]); dump();
+mov (ecx, ptr[r13-1000]); dump();
+mov (ecx, ptr[r13+0]); dump();
+mov (ecx, ptr[r13+1]); dump();
+mov (ecx, ptr[r13+1000]); dump();
+mov (ecx, ptr[r13-1]); dump();
+mov (ecx, ptr[r13-1000]); dump();
+mov (ecx, ptr[r13+0]); dump();
+mov (ecx, ptr[r13+1]); dump();
+mov (ecx, ptr[r13+1000]); dump();
+mov (ecx, ptr[r13-1]); dump();
+mov (ecx, ptr[r13-1000]); dump();
+mov (ecx, ptr[r13+0]); dump();
+mov (ecx, ptr[r13+1]); dump();
+mov (ecx, ptr[r13+1000]); dump();
+mov (ecx, ptr[r13-1]); dump();
+mov (ecx, ptr[r13-1000]); dump();
+mov (ecx, ptr[r14+rax+0]); dump();
+mov (ecx, ptr[r14+rax+1]); dump();
+mov (ecx, ptr[r14+rax+1000]); dump();
+mov (ecx, ptr[r14+rax-1]); dump();
+mov (ecx, ptr[r14+rax-1000]); dump();
+mov (ecx, ptr[r14+rax*1+0]); dump();
+mov (ecx, ptr[r14+rax*1+1]); dump();
+mov (ecx, ptr[r14+rax*1+1000]); dump();
+mov (ecx, ptr[r14+rax*1-1]); dump();
+mov (ecx, ptr[r14+rax*1-1000]); dump();
+mov (ecx, ptr[r14+rax*2+0]); dump();
+mov (ecx, ptr[r14+rax*2+1]); dump();
+mov (ecx, ptr[r14+rax*2+1000]); dump();
+mov (ecx, ptr[r14+rax*2-1]); dump();
+mov (ecx, ptr[r14+rax*2-1000]); dump();
+mov (ecx, ptr[r14+rax*4+0]); dump();
+mov (ecx, ptr[r14+rax*4+1]); dump();
+mov (ecx, ptr[r14+rax*4+1000]); dump();
+mov (ecx, ptr[r14+rax*4-1]); dump();
+mov (ecx, ptr[r14+rax*4-1000]); dump();
+mov (ecx, ptr[r14+rax*8+0]); dump();
+mov (ecx, ptr[r14+rax*8+1]); dump();
+mov (ecx, ptr[r14+rax*8+1000]); dump();
+mov (ecx, ptr[r14+rax*8-1]); dump();
+mov (ecx, ptr[r14+rax*8-1000]); dump();
+}
+    void gen49(){
+mov (ecx, ptr[r14+rcx+0]); dump();
+mov (ecx, ptr[r14+rcx+1]); dump();
+mov (ecx, ptr[r14+rcx+1000]); dump();
+mov (ecx, ptr[r14+rcx-1]); dump();
+mov (ecx, ptr[r14+rcx-1000]); dump();
+mov (ecx, ptr[r14+rcx*1+0]); dump();
+mov (ecx, ptr[r14+rcx*1+1]); dump();
+mov (ecx, ptr[r14+rcx*1+1000]); dump();
+mov (ecx, ptr[r14+rcx*1-1]); dump();
+mov (ecx, ptr[r14+rcx*1-1000]); dump();
+mov (ecx, ptr[r14+rcx*2+0]); dump();
+mov (ecx, ptr[r14+rcx*2+1]); dump();
+mov (ecx, ptr[r14+rcx*2+1000]); dump();
+mov (ecx, ptr[r14+rcx*2-1]); dump();
+mov (ecx, ptr[r14+rcx*2-1000]); dump();
+mov (ecx, ptr[r14+rcx*4+0]); dump();
+mov (ecx, ptr[r14+rcx*4+1]); dump();
+mov (ecx, ptr[r14+rcx*4+1000]); dump();
+mov (ecx, ptr[r14+rcx*4-1]); dump();
+mov (ecx, ptr[r14+rcx*4-1000]); dump();
+mov (ecx, ptr[r14+rcx*8+0]); dump();
+mov (ecx, ptr[r14+rcx*8+1]); dump();
+mov (ecx, ptr[r14+rcx*8+1000]); dump();
+mov (ecx, ptr[r14+rcx*8-1]); dump();
+mov (ecx, ptr[r14+rcx*8-1000]); dump();
+mov (ecx, ptr[r14+rdx+0]); dump();
+mov (ecx, ptr[r14+rdx+1]); dump();
+mov (ecx, ptr[r14+rdx+1000]); dump();
+mov (ecx, ptr[r14+rdx-1]); dump();
+mov (ecx, ptr[r14+rdx-1000]); dump();
+mov (ecx, ptr[r14+rdx*1+0]); dump();
+mov (ecx, ptr[r14+rdx*1+1]); dump();
+mov (ecx, ptr[r14+rdx*1+1000]); dump();
+mov (ecx, ptr[r14+rdx*1-1]); dump();
+mov (ecx, ptr[r14+rdx*1-1000]); dump();
+mov (ecx, ptr[r14+rdx*2+0]); dump();
+mov (ecx, ptr[r14+rdx*2+1]); dump();
+mov (ecx, ptr[r14+rdx*2+1000]); dump();
+mov (ecx, ptr[r14+rdx*2-1]); dump();
+mov (ecx, ptr[r14+rdx*2-1000]); dump();
+mov (ecx, ptr[r14+rdx*4+0]); dump();
+mov (ecx, ptr[r14+rdx*4+1]); dump();
+mov (ecx, ptr[r14+rdx*4+1000]); dump();
+mov (ecx, ptr[r14+rdx*4-1]); dump();
+mov (ecx, ptr[r14+rdx*4-1000]); dump();
+mov (ecx, ptr[r14+rdx*8+0]); dump();
+mov (ecx, ptr[r14+rdx*8+1]); dump();
+mov (ecx, ptr[r14+rdx*8+1000]); dump();
+mov (ecx, ptr[r14+rdx*8-1]); dump();
+mov (ecx, ptr[r14+rdx*8-1000]); dump();
+mov (ecx, ptr[r14+rbx+0]); dump();
+mov (ecx, ptr[r14+rbx+1]); dump();
+mov (ecx, ptr[r14+rbx+1000]); dump();
+mov (ecx, ptr[r14+rbx-1]); dump();
+mov (ecx, ptr[r14+rbx-1000]); dump();
+mov (ecx, ptr[r14+rbx*1+0]); dump();
+mov (ecx, ptr[r14+rbx*1+1]); dump();
+mov (ecx, ptr[r14+rbx*1+1000]); dump();
+mov (ecx, ptr[r14+rbx*1-1]); dump();
+mov (ecx, ptr[r14+rbx*1-1000]); dump();
+mov (ecx, ptr[r14+rbx*2+0]); dump();
+mov (ecx, ptr[r14+rbx*2+1]); dump();
+mov (ecx, ptr[r14+rbx*2+1000]); dump();
+mov (ecx, ptr[r14+rbx*2-1]); dump();
+mov (ecx, ptr[r14+rbx*2-1000]); dump();
+mov (ecx, ptr[r14+rbx*4+0]); dump();
+mov (ecx, ptr[r14+rbx*4+1]); dump();
+mov (ecx, ptr[r14+rbx*4+1000]); dump();
+mov (ecx, ptr[r14+rbx*4-1]); dump();
+mov (ecx, ptr[r14+rbx*4-1000]); dump();
+mov (ecx, ptr[r14+rbx*8+0]); dump();
+mov (ecx, ptr[r14+rbx*8+1]); dump();
+mov (ecx, ptr[r14+rbx*8+1000]); dump();
+mov (ecx, ptr[r14+rbx*8-1]); dump();
+mov (ecx, ptr[r14+rbx*8-1000]); dump();
+mov (ecx, ptr[r14+rbp+0]); dump();
+mov (ecx, ptr[r14+rbp+1]); dump();
+mov (ecx, ptr[r14+rbp+1000]); dump();
+mov (ecx, ptr[r14+rbp-1]); dump();
+mov (ecx, ptr[r14+rbp-1000]); dump();
+mov (ecx, ptr[r14+rbp*1+0]); dump();
+mov (ecx, ptr[r14+rbp*1+1]); dump();
+mov (ecx, ptr[r14+rbp*1+1000]); dump();
+mov (ecx, ptr[r14+rbp*1-1]); dump();
+mov (ecx, ptr[r14+rbp*1-1000]); dump();
+mov (ecx, ptr[r14+rbp*2+0]); dump();
+mov (ecx, ptr[r14+rbp*2+1]); dump();
+mov (ecx, ptr[r14+rbp*2+1000]); dump();
+mov (ecx, ptr[r14+rbp*2-1]); dump();
+mov (ecx, ptr[r14+rbp*2-1000]); dump();
+mov (ecx, ptr[r14+rbp*4+0]); dump();
+mov (ecx, ptr[r14+rbp*4+1]); dump();
+mov (ecx, ptr[r14+rbp*4+1000]); dump();
+mov (ecx, ptr[r14+rbp*4-1]); dump();
+mov (ecx, ptr[r14+rbp*4-1000]); dump();
+mov (ecx, ptr[r14+rbp*8+0]); dump();
+mov (ecx, ptr[r14+rbp*8+1]); dump();
+mov (ecx, ptr[r14+rbp*8+1000]); dump();
+mov (ecx, ptr[r14+rbp*8-1]); dump();
+mov (ecx, ptr[r14+rbp*8-1000]); dump();
+}
+    void gen50(){
+mov (ecx, ptr[r14+rsi+0]); dump();
+mov (ecx, ptr[r14+rsi+1]); dump();
+mov (ecx, ptr[r14+rsi+1000]); dump();
+mov (ecx, ptr[r14+rsi-1]); dump();
+mov (ecx, ptr[r14+rsi-1000]); dump();
+mov (ecx, ptr[r14+rsi*1+0]); dump();
+mov (ecx, ptr[r14+rsi*1+1]); dump();
+mov (ecx, ptr[r14+rsi*1+1000]); dump();
+mov (ecx, ptr[r14+rsi*1-1]); dump();
+mov (ecx, ptr[r14+rsi*1-1000]); dump();
+mov (ecx, ptr[r14+rsi*2+0]); dump();
+mov (ecx, ptr[r14+rsi*2+1]); dump();
+mov (ecx, ptr[r14+rsi*2+1000]); dump();
+mov (ecx, ptr[r14+rsi*2-1]); dump();
+mov (ecx, ptr[r14+rsi*2-1000]); dump();
+mov (ecx, ptr[r14+rsi*4+0]); dump();
+mov (ecx, ptr[r14+rsi*4+1]); dump();
+mov (ecx, ptr[r14+rsi*4+1000]); dump();
+mov (ecx, ptr[r14+rsi*4-1]); dump();
+mov (ecx, ptr[r14+rsi*4-1000]); dump();
+mov (ecx, ptr[r14+rsi*8+0]); dump();
+mov (ecx, ptr[r14+rsi*8+1]); dump();
+mov (ecx, ptr[r14+rsi*8+1000]); dump();
+mov (ecx, ptr[r14+rsi*8-1]); dump();
+mov (ecx, ptr[r14+rsi*8-1000]); dump();
+mov (ecx, ptr[r14+rdi+0]); dump();
+mov (ecx, ptr[r14+rdi+1]); dump();
+mov (ecx, ptr[r14+rdi+1000]); dump();
+mov (ecx, ptr[r14+rdi-1]); dump();
+mov (ecx, ptr[r14+rdi-1000]); dump();
+mov (ecx, ptr[r14+rdi*1+0]); dump();
+mov (ecx, ptr[r14+rdi*1+1]); dump();
+mov (ecx, ptr[r14+rdi*1+1000]); dump();
+mov (ecx, ptr[r14+rdi*1-1]); dump();
+mov (ecx, ptr[r14+rdi*1-1000]); dump();
+mov (ecx, ptr[r14+rdi*2+0]); dump();
+mov (ecx, ptr[r14+rdi*2+1]); dump();
+mov (ecx, ptr[r14+rdi*2+1000]); dump();
+mov (ecx, ptr[r14+rdi*2-1]); dump();
+mov (ecx, ptr[r14+rdi*2-1000]); dump();
+mov (ecx, ptr[r14+rdi*4+0]); dump();
+mov (ecx, ptr[r14+rdi*4+1]); dump();
+mov (ecx, ptr[r14+rdi*4+1000]); dump();
+mov (ecx, ptr[r14+rdi*4-1]); dump();
+mov (ecx, ptr[r14+rdi*4-1000]); dump();
+mov (ecx, ptr[r14+rdi*8+0]); dump();
+mov (ecx, ptr[r14+rdi*8+1]); dump();
+mov (ecx, ptr[r14+rdi*8+1000]); dump();
+mov (ecx, ptr[r14+rdi*8-1]); dump();
+mov (ecx, ptr[r14+rdi*8-1000]); dump();
+mov (ecx, ptr[r14+r9+0]); dump();
+mov (ecx, ptr[r14+r9+1]); dump();
+mov (ecx, ptr[r14+r9+1000]); dump();
+mov (ecx, ptr[r14+r9-1]); dump();
+mov (ecx, ptr[r14+r9-1000]); dump();
+mov (ecx, ptr[r14+r9*1+0]); dump();
+mov (ecx, ptr[r14+r9*1+1]); dump();
+mov (ecx, ptr[r14+r9*1+1000]); dump();
+mov (ecx, ptr[r14+r9*1-1]); dump();
+mov (ecx, ptr[r14+r9*1-1000]); dump();
+mov (ecx, ptr[r14+r9*2+0]); dump();
+mov (ecx, ptr[r14+r9*2+1]); dump();
+mov (ecx, ptr[r14+r9*2+1000]); dump();
+mov (ecx, ptr[r14+r9*2-1]); dump();
+mov (ecx, ptr[r14+r9*2-1000]); dump();
+mov (ecx, ptr[r14+r9*4+0]); dump();
+mov (ecx, ptr[r14+r9*4+1]); dump();
+mov (ecx, ptr[r14+r9*4+1000]); dump();
+mov (ecx, ptr[r14+r9*4-1]); dump();
+mov (ecx, ptr[r14+r9*4-1000]); dump();
+mov (ecx, ptr[r14+r9*8+0]); dump();
+mov (ecx, ptr[r14+r9*8+1]); dump();
+mov (ecx, ptr[r14+r9*8+1000]); dump();
+mov (ecx, ptr[r14+r9*8-1]); dump();
+mov (ecx, ptr[r14+r9*8-1000]); dump();
+mov (ecx, ptr[r14+r10+0]); dump();
+mov (ecx, ptr[r14+r10+1]); dump();
+mov (ecx, ptr[r14+r10+1000]); dump();
+mov (ecx, ptr[r14+r10-1]); dump();
+mov (ecx, ptr[r14+r10-1000]); dump();
+mov (ecx, ptr[r14+r10*1+0]); dump();
+mov (ecx, ptr[r14+r10*1+1]); dump();
+mov (ecx, ptr[r14+r10*1+1000]); dump();
+mov (ecx, ptr[r14+r10*1-1]); dump();
+mov (ecx, ptr[r14+r10*1-1000]); dump();
+mov (ecx, ptr[r14+r10*2+0]); dump();
+mov (ecx, ptr[r14+r10*2+1]); dump();
+mov (ecx, ptr[r14+r10*2+1000]); dump();
+mov (ecx, ptr[r14+r10*2-1]); dump();
+mov (ecx, ptr[r14+r10*2-1000]); dump();
+mov (ecx, ptr[r14+r10*4+0]); dump();
+mov (ecx, ptr[r14+r10*4+1]); dump();
+mov (ecx, ptr[r14+r10*4+1000]); dump();
+mov (ecx, ptr[r14+r10*4-1]); dump();
+mov (ecx, ptr[r14+r10*4-1000]); dump();
+mov (ecx, ptr[r14+r10*8+0]); dump();
+mov (ecx, ptr[r14+r10*8+1]); dump();
+mov (ecx, ptr[r14+r10*8+1000]); dump();
+mov (ecx, ptr[r14+r10*8-1]); dump();
+mov (ecx, ptr[r14+r10*8-1000]); dump();
+}
+    void gen51(){
+mov (ecx, ptr[r14+r11+0]); dump();
+mov (ecx, ptr[r14+r11+1]); dump();
+mov (ecx, ptr[r14+r11+1000]); dump();
+mov (ecx, ptr[r14+r11-1]); dump();
+mov (ecx, ptr[r14+r11-1000]); dump();
+mov (ecx, ptr[r14+r11*1+0]); dump();
+mov (ecx, ptr[r14+r11*1+1]); dump();
+mov (ecx, ptr[r14+r11*1+1000]); dump();
+mov (ecx, ptr[r14+r11*1-1]); dump();
+mov (ecx, ptr[r14+r11*1-1000]); dump();
+mov (ecx, ptr[r14+r11*2+0]); dump();
+mov (ecx, ptr[r14+r11*2+1]); dump();
+mov (ecx, ptr[r14+r11*2+1000]); dump();
+mov (ecx, ptr[r14+r11*2-1]); dump();
+mov (ecx, ptr[r14+r11*2-1000]); dump();
+mov (ecx, ptr[r14+r11*4+0]); dump();
+mov (ecx, ptr[r14+r11*4+1]); dump();
+mov (ecx, ptr[r14+r11*4+1000]); dump();
+mov (ecx, ptr[r14+r11*4-1]); dump();
+mov (ecx, ptr[r14+r11*4-1000]); dump();
+mov (ecx, ptr[r14+r11*8+0]); dump();
+mov (ecx, ptr[r14+r11*8+1]); dump();
+mov (ecx, ptr[r14+r11*8+1000]); dump();
+mov (ecx, ptr[r14+r11*8-1]); dump();
+mov (ecx, ptr[r14+r11*8-1000]); dump();
+mov (ecx, ptr[r14+r12+0]); dump();
+mov (ecx, ptr[r14+r12+1]); dump();
+mov (ecx, ptr[r14+r12+1000]); dump();
+mov (ecx, ptr[r14+r12-1]); dump();
+mov (ecx, ptr[r14+r12-1000]); dump();
+mov (ecx, ptr[r14+r12*1+0]); dump();
+mov (ecx, ptr[r14+r12*1+1]); dump();
+mov (ecx, ptr[r14+r12*1+1000]); dump();
+mov (ecx, ptr[r14+r12*1-1]); dump();
+mov (ecx, ptr[r14+r12*1-1000]); dump();
+mov (ecx, ptr[r14+r12*2+0]); dump();
+mov (ecx, ptr[r14+r12*2+1]); dump();
+mov (ecx, ptr[r14+r12*2+1000]); dump();
+mov (ecx, ptr[r14+r12*2-1]); dump();
+mov (ecx, ptr[r14+r12*2-1000]); dump();
+mov (ecx, ptr[r14+r12*4+0]); dump();
+mov (ecx, ptr[r14+r12*4+1]); dump();
+mov (ecx, ptr[r14+r12*4+1000]); dump();
+mov (ecx, ptr[r14+r12*4-1]); dump();
+mov (ecx, ptr[r14+r12*4-1000]); dump();
+mov (ecx, ptr[r14+r12*8+0]); dump();
+mov (ecx, ptr[r14+r12*8+1]); dump();
+mov (ecx, ptr[r14+r12*8+1000]); dump();
+mov (ecx, ptr[r14+r12*8-1]); dump();
+mov (ecx, ptr[r14+r12*8-1000]); dump();
+mov (ecx, ptr[r14+r13+0]); dump();
+mov (ecx, ptr[r14+r13+1]); dump();
+mov (ecx, ptr[r14+r13+1000]); dump();
+mov (ecx, ptr[r14+r13-1]); dump();
+mov (ecx, ptr[r14+r13-1000]); dump();
+mov (ecx, ptr[r14+r13*1+0]); dump();
+mov (ecx, ptr[r14+r13*1+1]); dump();
+mov (ecx, ptr[r14+r13*1+1000]); dump();
+mov (ecx, ptr[r14+r13*1-1]); dump();
+mov (ecx, ptr[r14+r13*1-1000]); dump();
+mov (ecx, ptr[r14+r13*2+0]); dump();
+mov (ecx, ptr[r14+r13*2+1]); dump();
+mov (ecx, ptr[r14+r13*2+1000]); dump();
+mov (ecx, ptr[r14+r13*2-1]); dump();
+mov (ecx, ptr[r14+r13*2-1000]); dump();
+mov (ecx, ptr[r14+r13*4+0]); dump();
+mov (ecx, ptr[r14+r13*4+1]); dump();
+mov (ecx, ptr[r14+r13*4+1000]); dump();
+mov (ecx, ptr[r14+r13*4-1]); dump();
+mov (ecx, ptr[r14+r13*4-1000]); dump();
+mov (ecx, ptr[r14+r13*8+0]); dump();
+mov (ecx, ptr[r14+r13*8+1]); dump();
+mov (ecx, ptr[r14+r13*8+1000]); dump();
+mov (ecx, ptr[r14+r13*8-1]); dump();
+mov (ecx, ptr[r14+r13*8-1000]); dump();
+mov (ecx, ptr[r14+r14+0]); dump();
+mov (ecx, ptr[r14+r14+1]); dump();
+mov (ecx, ptr[r14+r14+1000]); dump();
+mov (ecx, ptr[r14+r14-1]); dump();
+mov (ecx, ptr[r14+r14-1000]); dump();
+mov (ecx, ptr[r14+r14*1+0]); dump();
+mov (ecx, ptr[r14+r14*1+1]); dump();
+mov (ecx, ptr[r14+r14*1+1000]); dump();
+mov (ecx, ptr[r14+r14*1-1]); dump();
+mov (ecx, ptr[r14+r14*1-1000]); dump();
+mov (ecx, ptr[r14+r14*2+0]); dump();
+mov (ecx, ptr[r14+r14*2+1]); dump();
+mov (ecx, ptr[r14+r14*2+1000]); dump();
+mov (ecx, ptr[r14+r14*2-1]); dump();
+mov (ecx, ptr[r14+r14*2-1000]); dump();
+mov (ecx, ptr[r14+r14*4+0]); dump();
+mov (ecx, ptr[r14+r14*4+1]); dump();
+mov (ecx, ptr[r14+r14*4+1000]); dump();
+mov (ecx, ptr[r14+r14*4-1]); dump();
+mov (ecx, ptr[r14+r14*4-1000]); dump();
+mov (ecx, ptr[r14+r14*8+0]); dump();
+mov (ecx, ptr[r14+r14*8+1]); dump();
+mov (ecx, ptr[r14+r14*8+1000]); dump();
+mov (ecx, ptr[r14+r14*8-1]); dump();
+mov (ecx, ptr[r14+r14*8-1000]); dump();
+}
+    void gen52(){
+mov (ecx, ptr[r14+r15+0]); dump();
+mov (ecx, ptr[r14+r15+1]); dump();
+mov (ecx, ptr[r14+r15+1000]); dump();
+mov (ecx, ptr[r14+r15-1]); dump();
+mov (ecx, ptr[r14+r15-1000]); dump();
+mov (ecx, ptr[r14+r15*1+0]); dump();
+mov (ecx, ptr[r14+r15*1+1]); dump();
+mov (ecx, ptr[r14+r15*1+1000]); dump();
+mov (ecx, ptr[r14+r15*1-1]); dump();
+mov (ecx, ptr[r14+r15*1-1000]); dump();
+mov (ecx, ptr[r14+r15*2+0]); dump();
+mov (ecx, ptr[r14+r15*2+1]); dump();
+mov (ecx, ptr[r14+r15*2+1000]); dump();
+mov (ecx, ptr[r14+r15*2-1]); dump();
+mov (ecx, ptr[r14+r15*2-1000]); dump();
+mov (ecx, ptr[r14+r15*4+0]); dump();
+mov (ecx, ptr[r14+r15*4+1]); dump();
+mov (ecx, ptr[r14+r15*4+1000]); dump();
+mov (ecx, ptr[r14+r15*4-1]); dump();
+mov (ecx, ptr[r14+r15*4-1000]); dump();
+mov (ecx, ptr[r14+r15*8+0]); dump();
+mov (ecx, ptr[r14+r15*8+1]); dump();
+mov (ecx, ptr[r14+r15*8+1000]); dump();
+mov (ecx, ptr[r14+r15*8-1]); dump();
+mov (ecx, ptr[r14+r15*8-1000]); dump();
+mov (ecx, ptr[r14+0]); dump();
+mov (ecx, ptr[r14+1]); dump();
+mov (ecx, ptr[r14+1000]); dump();
+mov (ecx, ptr[r14-1]); dump();
+mov (ecx, ptr[r14-1000]); dump();
+mov (ecx, ptr[r14+0]); dump();
+mov (ecx, ptr[r14+1]); dump();
+mov (ecx, ptr[r14+1000]); dump();
+mov (ecx, ptr[r14-1]); dump();
+mov (ecx, ptr[r14-1000]); dump();
+mov (ecx, ptr[r14+0]); dump();
+mov (ecx, ptr[r14+1]); dump();
+mov (ecx, ptr[r14+1000]); dump();
+mov (ecx, ptr[r14-1]); dump();
+mov (ecx, ptr[r14-1000]); dump();
+mov (ecx, ptr[r14+0]); dump();
+mov (ecx, ptr[r14+1]); dump();
+mov (ecx, ptr[r14+1000]); dump();
+mov (ecx, ptr[r14-1]); dump();
+mov (ecx, ptr[r14-1000]); dump();
+mov (ecx, ptr[r14+0]); dump();
+mov (ecx, ptr[r14+1]); dump();
+mov (ecx, ptr[r14+1000]); dump();
+mov (ecx, ptr[r14-1]); dump();
+mov (ecx, ptr[r14-1000]); dump();
+mov (ecx, ptr[r15+rax+0]); dump();
+mov (ecx, ptr[r15+rax+1]); dump();
+mov (ecx, ptr[r15+rax+1000]); dump();
+mov (ecx, ptr[r15+rax-1]); dump();
+mov (ecx, ptr[r15+rax-1000]); dump();
+mov (ecx, ptr[r15+rax*1+0]); dump();
+mov (ecx, ptr[r15+rax*1+1]); dump();
+mov (ecx, ptr[r15+rax*1+1000]); dump();
+mov (ecx, ptr[r15+rax*1-1]); dump();
+mov (ecx, ptr[r15+rax*1-1000]); dump();
+mov (ecx, ptr[r15+rax*2+0]); dump();
+mov (ecx, ptr[r15+rax*2+1]); dump();
+mov (ecx, ptr[r15+rax*2+1000]); dump();
+mov (ecx, ptr[r15+rax*2-1]); dump();
+mov (ecx, ptr[r15+rax*2-1000]); dump();
+mov (ecx, ptr[r15+rax*4+0]); dump();
+mov (ecx, ptr[r15+rax*4+1]); dump();
+mov (ecx, ptr[r15+rax*4+1000]); dump();
+mov (ecx, ptr[r15+rax*4-1]); dump();
+mov (ecx, ptr[r15+rax*4-1000]); dump();
+mov (ecx, ptr[r15+rax*8+0]); dump();
+mov (ecx, ptr[r15+rax*8+1]); dump();
+mov (ecx, ptr[r15+rax*8+1000]); dump();
+mov (ecx, ptr[r15+rax*8-1]); dump();
+mov (ecx, ptr[r15+rax*8-1000]); dump();
+mov (ecx, ptr[r15+rcx+0]); dump();
+mov (ecx, ptr[r15+rcx+1]); dump();
+mov (ecx, ptr[r15+rcx+1000]); dump();
+mov (ecx, ptr[r15+rcx-1]); dump();
+mov (ecx, ptr[r15+rcx-1000]); dump();
+mov (ecx, ptr[r15+rcx*1+0]); dump();
+mov (ecx, ptr[r15+rcx*1+1]); dump();
+mov (ecx, ptr[r15+rcx*1+1000]); dump();
+mov (ecx, ptr[r15+rcx*1-1]); dump();
+mov (ecx, ptr[r15+rcx*1-1000]); dump();
+mov (ecx, ptr[r15+rcx*2+0]); dump();
+mov (ecx, ptr[r15+rcx*2+1]); dump();
+mov (ecx, ptr[r15+rcx*2+1000]); dump();
+mov (ecx, ptr[r15+rcx*2-1]); dump();
+mov (ecx, ptr[r15+rcx*2-1000]); dump();
+mov (ecx, ptr[r15+rcx*4+0]); dump();
+mov (ecx, ptr[r15+rcx*4+1]); dump();
+mov (ecx, ptr[r15+rcx*4+1000]); dump();
+mov (ecx, ptr[r15+rcx*4-1]); dump();
+mov (ecx, ptr[r15+rcx*4-1000]); dump();
+mov (ecx, ptr[r15+rcx*8+0]); dump();
+mov (ecx, ptr[r15+rcx*8+1]); dump();
+mov (ecx, ptr[r15+rcx*8+1000]); dump();
+mov (ecx, ptr[r15+rcx*8-1]); dump();
+mov (ecx, ptr[r15+rcx*8-1000]); dump();
+}
+    void gen53(){
+mov (ecx, ptr[r15+rdx+0]); dump();
+mov (ecx, ptr[r15+rdx+1]); dump();
+mov (ecx, ptr[r15+rdx+1000]); dump();
+mov (ecx, ptr[r15+rdx-1]); dump();
+mov (ecx, ptr[r15+rdx-1000]); dump();
+mov (ecx, ptr[r15+rdx*1+0]); dump();
+mov (ecx, ptr[r15+rdx*1+1]); dump();
+mov (ecx, ptr[r15+rdx*1+1000]); dump();
+mov (ecx, ptr[r15+rdx*1-1]); dump();
+mov (ecx, ptr[r15+rdx*1-1000]); dump();
+mov (ecx, ptr[r15+rdx*2+0]); dump();
+mov (ecx, ptr[r15+rdx*2+1]); dump();
+mov (ecx, ptr[r15+rdx*2+1000]); dump();
+mov (ecx, ptr[r15+rdx*2-1]); dump();
+mov (ecx, ptr[r15+rdx*2-1000]); dump();
+mov (ecx, ptr[r15+rdx*4+0]); dump();
+mov (ecx, ptr[r15+rdx*4+1]); dump();
+mov (ecx, ptr[r15+rdx*4+1000]); dump();
+mov (ecx, ptr[r15+rdx*4-1]); dump();
+mov (ecx, ptr[r15+rdx*4-1000]); dump();
+mov (ecx, ptr[r15+rdx*8+0]); dump();
+mov (ecx, ptr[r15+rdx*8+1]); dump();
+mov (ecx, ptr[r15+rdx*8+1000]); dump();
+mov (ecx, ptr[r15+rdx*8-1]); dump();
+mov (ecx, ptr[r15+rdx*8-1000]); dump();
+mov (ecx, ptr[r15+rbx+0]); dump();
+mov (ecx, ptr[r15+rbx+1]); dump();
+mov (ecx, ptr[r15+rbx+1000]); dump();
+mov (ecx, ptr[r15+rbx-1]); dump();
+mov (ecx, ptr[r15+rbx-1000]); dump();
+mov (ecx, ptr[r15+rbx*1+0]); dump();
+mov (ecx, ptr[r15+rbx*1+1]); dump();
+mov (ecx, ptr[r15+rbx*1+1000]); dump();
+mov (ecx, ptr[r15+rbx*1-1]); dump();
+mov (ecx, ptr[r15+rbx*1-1000]); dump();
+mov (ecx, ptr[r15+rbx*2+0]); dump();
+mov (ecx, ptr[r15+rbx*2+1]); dump();
+mov (ecx, ptr[r15+rbx*2+1000]); dump();
+mov (ecx, ptr[r15+rbx*2-1]); dump();
+mov (ecx, ptr[r15+rbx*2-1000]); dump();
+mov (ecx, ptr[r15+rbx*4+0]); dump();
+mov (ecx, ptr[r15+rbx*4+1]); dump();
+mov (ecx, ptr[r15+rbx*4+1000]); dump();
+mov (ecx, ptr[r15+rbx*4-1]); dump();
+mov (ecx, ptr[r15+rbx*4-1000]); dump();
+mov (ecx, ptr[r15+rbx*8+0]); dump();
+mov (ecx, ptr[r15+rbx*8+1]); dump();
+mov (ecx, ptr[r15+rbx*8+1000]); dump();
+mov (ecx, ptr[r15+rbx*8-1]); dump();
+mov (ecx, ptr[r15+rbx*8-1000]); dump();
+mov (ecx, ptr[r15+rbp+0]); dump();
+mov (ecx, ptr[r15+rbp+1]); dump();
+mov (ecx, ptr[r15+rbp+1000]); dump();
+mov (ecx, ptr[r15+rbp-1]); dump();
+mov (ecx, ptr[r15+rbp-1000]); dump();
+mov (ecx, ptr[r15+rbp*1+0]); dump();
+mov (ecx, ptr[r15+rbp*1+1]); dump();
+mov (ecx, ptr[r15+rbp*1+1000]); dump();
+mov (ecx, ptr[r15+rbp*1-1]); dump();
+mov (ecx, ptr[r15+rbp*1-1000]); dump();
+mov (ecx, ptr[r15+rbp*2+0]); dump();
+mov (ecx, ptr[r15+rbp*2+1]); dump();
+mov (ecx, ptr[r15+rbp*2+1000]); dump();
+mov (ecx, ptr[r15+rbp*2-1]); dump();
+mov (ecx, ptr[r15+rbp*2-1000]); dump();
+mov (ecx, ptr[r15+rbp*4+0]); dump();
+mov (ecx, ptr[r15+rbp*4+1]); dump();
+mov (ecx, ptr[r15+rbp*4+1000]); dump();
+mov (ecx, ptr[r15+rbp*4-1]); dump();
+mov (ecx, ptr[r15+rbp*4-1000]); dump();
+mov (ecx, ptr[r15+rbp*8+0]); dump();
+mov (ecx, ptr[r15+rbp*8+1]); dump();
+mov (ecx, ptr[r15+rbp*8+1000]); dump();
+mov (ecx, ptr[r15+rbp*8-1]); dump();
+mov (ecx, ptr[r15+rbp*8-1000]); dump();
+mov (ecx, ptr[r15+rsi+0]); dump();
+mov (ecx, ptr[r15+rsi+1]); dump();
+mov (ecx, ptr[r15+rsi+1000]); dump();
+mov (ecx, ptr[r15+rsi-1]); dump();
+mov (ecx, ptr[r15+rsi-1000]); dump();
+mov (ecx, ptr[r15+rsi*1+0]); dump();
+mov (ecx, ptr[r15+rsi*1+1]); dump();
+mov (ecx, ptr[r15+rsi*1+1000]); dump();
+mov (ecx, ptr[r15+rsi*1-1]); dump();
+mov (ecx, ptr[r15+rsi*1-1000]); dump();
+mov (ecx, ptr[r15+rsi*2+0]); dump();
+mov (ecx, ptr[r15+rsi*2+1]); dump();
+mov (ecx, ptr[r15+rsi*2+1000]); dump();
+mov (ecx, ptr[r15+rsi*2-1]); dump();
+mov (ecx, ptr[r15+rsi*2-1000]); dump();
+mov (ecx, ptr[r15+rsi*4+0]); dump();
+mov (ecx, ptr[r15+rsi*4+1]); dump();
+mov (ecx, ptr[r15+rsi*4+1000]); dump();
+mov (ecx, ptr[r15+rsi*4-1]); dump();
+mov (ecx, ptr[r15+rsi*4-1000]); dump();
+mov (ecx, ptr[r15+rsi*8+0]); dump();
+mov (ecx, ptr[r15+rsi*8+1]); dump();
+mov (ecx, ptr[r15+rsi*8+1000]); dump();
+mov (ecx, ptr[r15+rsi*8-1]); dump();
+mov (ecx, ptr[r15+rsi*8-1000]); dump();
+}
+    void gen54(){
+mov (ecx, ptr[r15+rdi+0]); dump();
+mov (ecx, ptr[r15+rdi+1]); dump();
+mov (ecx, ptr[r15+rdi+1000]); dump();
+mov (ecx, ptr[r15+rdi-1]); dump();
+mov (ecx, ptr[r15+rdi-1000]); dump();
+mov (ecx, ptr[r15+rdi*1+0]); dump();
+mov (ecx, ptr[r15+rdi*1+1]); dump();
+mov (ecx, ptr[r15+rdi*1+1000]); dump();
+mov (ecx, ptr[r15+rdi*1-1]); dump();
+mov (ecx, ptr[r15+rdi*1-1000]); dump();
+mov (ecx, ptr[r15+rdi*2+0]); dump();
+mov (ecx, ptr[r15+rdi*2+1]); dump();
+mov (ecx, ptr[r15+rdi*2+1000]); dump();
+mov (ecx, ptr[r15+rdi*2-1]); dump();
+mov (ecx, ptr[r15+rdi*2-1000]); dump();
+mov (ecx, ptr[r15+rdi*4+0]); dump();
+mov (ecx, ptr[r15+rdi*4+1]); dump();
+mov (ecx, ptr[r15+rdi*4+1000]); dump();
+mov (ecx, ptr[r15+rdi*4-1]); dump();
+mov (ecx, ptr[r15+rdi*4-1000]); dump();
+mov (ecx, ptr[r15+rdi*8+0]); dump();
+mov (ecx, ptr[r15+rdi*8+1]); dump();
+mov (ecx, ptr[r15+rdi*8+1000]); dump();
+mov (ecx, ptr[r15+rdi*8-1]); dump();
+mov (ecx, ptr[r15+rdi*8-1000]); dump();
+mov (ecx, ptr[r15+r9+0]); dump();
+mov (ecx, ptr[r15+r9+1]); dump();
+mov (ecx, ptr[r15+r9+1000]); dump();
+mov (ecx, ptr[r15+r9-1]); dump();
+mov (ecx, ptr[r15+r9-1000]); dump();
+mov (ecx, ptr[r15+r9*1+0]); dump();
+mov (ecx, ptr[r15+r9*1+1]); dump();
+mov (ecx, ptr[r15+r9*1+1000]); dump();
+mov (ecx, ptr[r15+r9*1-1]); dump();
+mov (ecx, ptr[r15+r9*1-1000]); dump();
+mov (ecx, ptr[r15+r9*2+0]); dump();
+mov (ecx, ptr[r15+r9*2+1]); dump();
+mov (ecx, ptr[r15+r9*2+1000]); dump();
+mov (ecx, ptr[r15+r9*2-1]); dump();
+mov (ecx, ptr[r15+r9*2-1000]); dump();
+mov (ecx, ptr[r15+r9*4+0]); dump();
+mov (ecx, ptr[r15+r9*4+1]); dump();
+mov (ecx, ptr[r15+r9*4+1000]); dump();
+mov (ecx, ptr[r15+r9*4-1]); dump();
+mov (ecx, ptr[r15+r9*4-1000]); dump();
+mov (ecx, ptr[r15+r9*8+0]); dump();
+mov (ecx, ptr[r15+r9*8+1]); dump();
+mov (ecx, ptr[r15+r9*8+1000]); dump();
+mov (ecx, ptr[r15+r9*8-1]); dump();
+mov (ecx, ptr[r15+r9*8-1000]); dump();
+mov (ecx, ptr[r15+r10+0]); dump();
+mov (ecx, ptr[r15+r10+1]); dump();
+mov (ecx, ptr[r15+r10+1000]); dump();
+mov (ecx, ptr[r15+r10-1]); dump();
+mov (ecx, ptr[r15+r10-1000]); dump();
+mov (ecx, ptr[r15+r10*1+0]); dump();
+mov (ecx, ptr[r15+r10*1+1]); dump();
+mov (ecx, ptr[r15+r10*1+1000]); dump();
+mov (ecx, ptr[r15+r10*1-1]); dump();
+mov (ecx, ptr[r15+r10*1-1000]); dump();
+mov (ecx, ptr[r15+r10*2+0]); dump();
+mov (ecx, ptr[r15+r10*2+1]); dump();
+mov (ecx, ptr[r15+r10*2+1000]); dump();
+mov (ecx, ptr[r15+r10*2-1]); dump();
+mov (ecx, ptr[r15+r10*2-1000]); dump();
+mov (ecx, ptr[r15+r10*4+0]); dump();
+mov (ecx, ptr[r15+r10*4+1]); dump();
+mov (ecx, ptr[r15+r10*4+1000]); dump();
+mov (ecx, ptr[r15+r10*4-1]); dump();
+mov (ecx, ptr[r15+r10*4-1000]); dump();
+mov (ecx, ptr[r15+r10*8+0]); dump();
+mov (ecx, ptr[r15+r10*8+1]); dump();
+mov (ecx, ptr[r15+r10*8+1000]); dump();
+mov (ecx, ptr[r15+r10*8-1]); dump();
+mov (ecx, ptr[r15+r10*8-1000]); dump();
+mov (ecx, ptr[r15+r11+0]); dump();
+mov (ecx, ptr[r15+r11+1]); dump();
+mov (ecx, ptr[r15+r11+1000]); dump();
+mov (ecx, ptr[r15+r11-1]); dump();
+mov (ecx, ptr[r15+r11-1000]); dump();
+mov (ecx, ptr[r15+r11*1+0]); dump();
+mov (ecx, ptr[r15+r11*1+1]); dump();
+mov (ecx, ptr[r15+r11*1+1000]); dump();
+mov (ecx, ptr[r15+r11*1-1]); dump();
+mov (ecx, ptr[r15+r11*1-1000]); dump();
+mov (ecx, ptr[r15+r11*2+0]); dump();
+mov (ecx, ptr[r15+r11*2+1]); dump();
+mov (ecx, ptr[r15+r11*2+1000]); dump();
+mov (ecx, ptr[r15+r11*2-1]); dump();
+mov (ecx, ptr[r15+r11*2-1000]); dump();
+mov (ecx, ptr[r15+r11*4+0]); dump();
+mov (ecx, ptr[r15+r11*4+1]); dump();
+mov (ecx, ptr[r15+r11*4+1000]); dump();
+mov (ecx, ptr[r15+r11*4-1]); dump();
+mov (ecx, ptr[r15+r11*4-1000]); dump();
+mov (ecx, ptr[r15+r11*8+0]); dump();
+mov (ecx, ptr[r15+r11*8+1]); dump();
+mov (ecx, ptr[r15+r11*8+1000]); dump();
+mov (ecx, ptr[r15+r11*8-1]); dump();
+mov (ecx, ptr[r15+r11*8-1000]); dump();
+}
+    void gen55(){
+mov (ecx, ptr[r15+r12+0]); dump();
+mov (ecx, ptr[r15+r12+1]); dump();
+mov (ecx, ptr[r15+r12+1000]); dump();
+mov (ecx, ptr[r15+r12-1]); dump();
+mov (ecx, ptr[r15+r12-1000]); dump();
+mov (ecx, ptr[r15+r12*1+0]); dump();
+mov (ecx, ptr[r15+r12*1+1]); dump();
+mov (ecx, ptr[r15+r12*1+1000]); dump();
+mov (ecx, ptr[r15+r12*1-1]); dump();
+mov (ecx, ptr[r15+r12*1-1000]); dump();
+mov (ecx, ptr[r15+r12*2+0]); dump();
+mov (ecx, ptr[r15+r12*2+1]); dump();
+mov (ecx, ptr[r15+r12*2+1000]); dump();
+mov (ecx, ptr[r15+r12*2-1]); dump();
+mov (ecx, ptr[r15+r12*2-1000]); dump();
+mov (ecx, ptr[r15+r12*4+0]); dump();
+mov (ecx, ptr[r15+r12*4+1]); dump();
+mov (ecx, ptr[r15+r12*4+1000]); dump();
+mov (ecx, ptr[r15+r12*4-1]); dump();
+mov (ecx, ptr[r15+r12*4-1000]); dump();
+mov (ecx, ptr[r15+r12*8+0]); dump();
+mov (ecx, ptr[r15+r12*8+1]); dump();
+mov (ecx, ptr[r15+r12*8+1000]); dump();
+mov (ecx, ptr[r15+r12*8-1]); dump();
+mov (ecx, ptr[r15+r12*8-1000]); dump();
+mov (ecx, ptr[r15+r13+0]); dump();
+mov (ecx, ptr[r15+r13+1]); dump();
+mov (ecx, ptr[r15+r13+1000]); dump();
+mov (ecx, ptr[r15+r13-1]); dump();
+mov (ecx, ptr[r15+r13-1000]); dump();
+mov (ecx, ptr[r15+r13*1+0]); dump();
+mov (ecx, ptr[r15+r13*1+1]); dump();
+mov (ecx, ptr[r15+r13*1+1000]); dump();
+mov (ecx, ptr[r15+r13*1-1]); dump();
+mov (ecx, ptr[r15+r13*1-1000]); dump();
+mov (ecx, ptr[r15+r13*2+0]); dump();
+mov (ecx, ptr[r15+r13*2+1]); dump();
+mov (ecx, ptr[r15+r13*2+1000]); dump();
+mov (ecx, ptr[r15+r13*2-1]); dump();
+mov (ecx, ptr[r15+r13*2-1000]); dump();
+mov (ecx, ptr[r15+r13*4+0]); dump();
+mov (ecx, ptr[r15+r13*4+1]); dump();
+mov (ecx, ptr[r15+r13*4+1000]); dump();
+mov (ecx, ptr[r15+r13*4-1]); dump();
+mov (ecx, ptr[r15+r13*4-1000]); dump();
+mov (ecx, ptr[r15+r13*8+0]); dump();
+mov (ecx, ptr[r15+r13*8+1]); dump();
+mov (ecx, ptr[r15+r13*8+1000]); dump();
+mov (ecx, ptr[r15+r13*8-1]); dump();
+mov (ecx, ptr[r15+r13*8-1000]); dump();
+mov (ecx, ptr[r15+r14+0]); dump();
+mov (ecx, ptr[r15+r14+1]); dump();
+mov (ecx, ptr[r15+r14+1000]); dump();
+mov (ecx, ptr[r15+r14-1]); dump();
+mov (ecx, ptr[r15+r14-1000]); dump();
+mov (ecx, ptr[r15+r14*1+0]); dump();
+mov (ecx, ptr[r15+r14*1+1]); dump();
+mov (ecx, ptr[r15+r14*1+1000]); dump();
+mov (ecx, ptr[r15+r14*1-1]); dump();
+mov (ecx, ptr[r15+r14*1-1000]); dump();
+mov (ecx, ptr[r15+r14*2+0]); dump();
+mov (ecx, ptr[r15+r14*2+1]); dump();
+mov (ecx, ptr[r15+r14*2+1000]); dump();
+mov (ecx, ptr[r15+r14*2-1]); dump();
+mov (ecx, ptr[r15+r14*2-1000]); dump();
+mov (ecx, ptr[r15+r14*4+0]); dump();
+mov (ecx, ptr[r15+r14*4+1]); dump();
+mov (ecx, ptr[r15+r14*4+1000]); dump();
+mov (ecx, ptr[r15+r14*4-1]); dump();
+mov (ecx, ptr[r15+r14*4-1000]); dump();
+mov (ecx, ptr[r15+r14*8+0]); dump();
+mov (ecx, ptr[r15+r14*8+1]); dump();
+mov (ecx, ptr[r15+r14*8+1000]); dump();
+mov (ecx, ptr[r15+r14*8-1]); dump();
+mov (ecx, ptr[r15+r14*8-1000]); dump();
+mov (ecx, ptr[r15+r15+0]); dump();
+mov (ecx, ptr[r15+r15+1]); dump();
+mov (ecx, ptr[r15+r15+1000]); dump();
+mov (ecx, ptr[r15+r15-1]); dump();
+mov (ecx, ptr[r15+r15-1000]); dump();
+mov (ecx, ptr[r15+r15*1+0]); dump();
+mov (ecx, ptr[r15+r15*1+1]); dump();
+mov (ecx, ptr[r15+r15*1+1000]); dump();
+mov (ecx, ptr[r15+r15*1-1]); dump();
+mov (ecx, ptr[r15+r15*1-1000]); dump();
+mov (ecx, ptr[r15+r15*2+0]); dump();
+mov (ecx, ptr[r15+r15*2+1]); dump();
+mov (ecx, ptr[r15+r15*2+1000]); dump();
+mov (ecx, ptr[r15+r15*2-1]); dump();
+mov (ecx, ptr[r15+r15*2-1000]); dump();
+mov (ecx, ptr[r15+r15*4+0]); dump();
+mov (ecx, ptr[r15+r15*4+1]); dump();
+mov (ecx, ptr[r15+r15*4+1000]); dump();
+mov (ecx, ptr[r15+r15*4-1]); dump();
+mov (ecx, ptr[r15+r15*4-1000]); dump();
+mov (ecx, ptr[r15+r15*8+0]); dump();
+mov (ecx, ptr[r15+r15*8+1]); dump();
+mov (ecx, ptr[r15+r15*8+1000]); dump();
+mov (ecx, ptr[r15+r15*8-1]); dump();
+mov (ecx, ptr[r15+r15*8-1000]); dump();
+}
+    void gen56(){
+mov (ecx, ptr[r15+0]); dump();
+mov (ecx, ptr[r15+1]); dump();
+mov (ecx, ptr[r15+1000]); dump();
+mov (ecx, ptr[r15-1]); dump();
+mov (ecx, ptr[r15-1000]); dump();
+mov (ecx, ptr[r15+0]); dump();
+mov (ecx, ptr[r15+1]); dump();
+mov (ecx, ptr[r15+1000]); dump();
+mov (ecx, ptr[r15-1]); dump();
+mov (ecx, ptr[r15-1000]); dump();
+mov (ecx, ptr[r15+0]); dump();
+mov (ecx, ptr[r15+1]); dump();
+mov (ecx, ptr[r15+1000]); dump();
+mov (ecx, ptr[r15-1]); dump();
+mov (ecx, ptr[r15-1000]); dump();
+mov (ecx, ptr[r15+0]); dump();
+mov (ecx, ptr[r15+1]); dump();
+mov (ecx, ptr[r15+1000]); dump();
+mov (ecx, ptr[r15-1]); dump();
+mov (ecx, ptr[r15-1000]); dump();
+mov (ecx, ptr[r15+0]); dump();
+mov (ecx, ptr[r15+1]); dump();
+mov (ecx, ptr[r15+1000]); dump();
+mov (ecx, ptr[r15-1]); dump();
+mov (ecx, ptr[r15-1000]); dump();
+mov (ecx, ptr[rax+0]); dump();
+mov (ecx, ptr[rax+1]); dump();
+mov (ecx, ptr[rax+1000]); dump();
+mov (ecx, ptr[rax-1]); dump();
+mov (ecx, ptr[rax-1000]); dump();
+mov (ecx, ptr[rax*1+0]); dump();
+mov (ecx, ptr[rax*1+1]); dump();
+mov (ecx, ptr[rax*1+1000]); dump();
+mov (ecx, ptr[rax*1-1]); dump();
+mov (ecx, ptr[rax*1-1000]); dump();
+mov (ecx, ptr[rax*2+0]); dump();
+mov (ecx, ptr[rax*2+1]); dump();
+mov (ecx, ptr[rax*2+1000]); dump();
+mov (ecx, ptr[rax*2-1]); dump();
+mov (ecx, ptr[rax*2-1000]); dump();
+mov (ecx, ptr[rax*4+0]); dump();
+mov (ecx, ptr[rax*4+1]); dump();
+mov (ecx, ptr[rax*4+1000]); dump();
+mov (ecx, ptr[rax*4-1]); dump();
+mov (ecx, ptr[rax*4-1000]); dump();
+mov (ecx, ptr[rax*8+0]); dump();
+mov (ecx, ptr[rax*8+1]); dump();
+mov (ecx, ptr[rax*8+1000]); dump();
+mov (ecx, ptr[rax*8-1]); dump();
+mov (ecx, ptr[rax*8-1000]); dump();
+mov (ecx, ptr[rcx+0]); dump();
+mov (ecx, ptr[rcx+1]); dump();
+mov (ecx, ptr[rcx+1000]); dump();
+mov (ecx, ptr[rcx-1]); dump();
+mov (ecx, ptr[rcx-1000]); dump();
+mov (ecx, ptr[rcx*1+0]); dump();
+mov (ecx, ptr[rcx*1+1]); dump();
+mov (ecx, ptr[rcx*1+1000]); dump();
+mov (ecx, ptr[rcx*1-1]); dump();
+mov (ecx, ptr[rcx*1-1000]); dump();
+mov (ecx, ptr[rcx*2+0]); dump();
+mov (ecx, ptr[rcx*2+1]); dump();
+mov (ecx, ptr[rcx*2+1000]); dump();
+mov (ecx, ptr[rcx*2-1]); dump();
+mov (ecx, ptr[rcx*2-1000]); dump();
+mov (ecx, ptr[rcx*4+0]); dump();
+mov (ecx, ptr[rcx*4+1]); dump();
+mov (ecx, ptr[rcx*4+1000]); dump();
+mov (ecx, ptr[rcx*4-1]); dump();
+mov (ecx, ptr[rcx*4-1000]); dump();
+mov (ecx, ptr[rcx*8+0]); dump();
+mov (ecx, ptr[rcx*8+1]); dump();
+mov (ecx, ptr[rcx*8+1000]); dump();
+mov (ecx, ptr[rcx*8-1]); dump();
+mov (ecx, ptr[rcx*8-1000]); dump();
+mov (ecx, ptr[rdx+0]); dump();
+mov (ecx, ptr[rdx+1]); dump();
+mov (ecx, ptr[rdx+1000]); dump();
+mov (ecx, ptr[rdx-1]); dump();
+mov (ecx, ptr[rdx-1000]); dump();
+mov (ecx, ptr[rdx*1+0]); dump();
+mov (ecx, ptr[rdx*1+1]); dump();
+mov (ecx, ptr[rdx*1+1000]); dump();
+mov (ecx, ptr[rdx*1-1]); dump();
+mov (ecx, ptr[rdx*1-1000]); dump();
+mov (ecx, ptr[rdx*2+0]); dump();
+mov (ecx, ptr[rdx*2+1]); dump();
+mov (ecx, ptr[rdx*2+1000]); dump();
+mov (ecx, ptr[rdx*2-1]); dump();
+mov (ecx, ptr[rdx*2-1000]); dump();
+mov (ecx, ptr[rdx*4+0]); dump();
+mov (ecx, ptr[rdx*4+1]); dump();
+mov (ecx, ptr[rdx*4+1000]); dump();
+mov (ecx, ptr[rdx*4-1]); dump();
+mov (ecx, ptr[rdx*4-1000]); dump();
+mov (ecx, ptr[rdx*8+0]); dump();
+mov (ecx, ptr[rdx*8+1]); dump();
+mov (ecx, ptr[rdx*8+1000]); dump();
+mov (ecx, ptr[rdx*8-1]); dump();
+mov (ecx, ptr[rdx*8-1000]); dump();
+}
+    void gen57(){
+mov (ecx, ptr[rbx+0]); dump();
+mov (ecx, ptr[rbx+1]); dump();
+mov (ecx, ptr[rbx+1000]); dump();
+mov (ecx, ptr[rbx-1]); dump();
+mov (ecx, ptr[rbx-1000]); dump();
+mov (ecx, ptr[rbx*1+0]); dump();
+mov (ecx, ptr[rbx*1+1]); dump();
+mov (ecx, ptr[rbx*1+1000]); dump();
+mov (ecx, ptr[rbx*1-1]); dump();
+mov (ecx, ptr[rbx*1-1000]); dump();
+mov (ecx, ptr[rbx*2+0]); dump();
+mov (ecx, ptr[rbx*2+1]); dump();
+mov (ecx, ptr[rbx*2+1000]); dump();
+mov (ecx, ptr[rbx*2-1]); dump();
+mov (ecx, ptr[rbx*2-1000]); dump();
+mov (ecx, ptr[rbx*4+0]); dump();
+mov (ecx, ptr[rbx*4+1]); dump();
+mov (ecx, ptr[rbx*4+1000]); dump();
+mov (ecx, ptr[rbx*4-1]); dump();
+mov (ecx, ptr[rbx*4-1000]); dump();
+mov (ecx, ptr[rbx*8+0]); dump();
+mov (ecx, ptr[rbx*8+1]); dump();
+mov (ecx, ptr[rbx*8+1000]); dump();
+mov (ecx, ptr[rbx*8-1]); dump();
+mov (ecx, ptr[rbx*8-1000]); dump();
+mov (ecx, ptr[rbp+0]); dump();
+mov (ecx, ptr[rbp+1]); dump();
+mov (ecx, ptr[rbp+1000]); dump();
+mov (ecx, ptr[rbp-1]); dump();
+mov (ecx, ptr[rbp-1000]); dump();
+mov (ecx, ptr[rbp*1+0]); dump();
+mov (ecx, ptr[rbp*1+1]); dump();
+mov (ecx, ptr[rbp*1+1000]); dump();
+mov (ecx, ptr[rbp*1-1]); dump();
+mov (ecx, ptr[rbp*1-1000]); dump();
+mov (ecx, ptr[rbp*2+0]); dump();
+mov (ecx, ptr[rbp*2+1]); dump();
+mov (ecx, ptr[rbp*2+1000]); dump();
+mov (ecx, ptr[rbp*2-1]); dump();
+mov (ecx, ptr[rbp*2-1000]); dump();
+mov (ecx, ptr[rbp*4+0]); dump();
+mov (ecx, ptr[rbp*4+1]); dump();
+mov (ecx, ptr[rbp*4+1000]); dump();
+mov (ecx, ptr[rbp*4-1]); dump();
+mov (ecx, ptr[rbp*4-1000]); dump();
+mov (ecx, ptr[rbp*8+0]); dump();
+mov (ecx, ptr[rbp*8+1]); dump();
+mov (ecx, ptr[rbp*8+1000]); dump();
+mov (ecx, ptr[rbp*8-1]); dump();
+mov (ecx, ptr[rbp*8-1000]); dump();
+mov (ecx, ptr[rsi+0]); dump();
+mov (ecx, ptr[rsi+1]); dump();
+mov (ecx, ptr[rsi+1000]); dump();
+mov (ecx, ptr[rsi-1]); dump();
+mov (ecx, ptr[rsi-1000]); dump();
+mov (ecx, ptr[rsi*1+0]); dump();
+mov (ecx, ptr[rsi*1+1]); dump();
+mov (ecx, ptr[rsi*1+1000]); dump();
+mov (ecx, ptr[rsi*1-1]); dump();
+mov (ecx, ptr[rsi*1-1000]); dump();
+mov (ecx, ptr[rsi*2+0]); dump();
+mov (ecx, ptr[rsi*2+1]); dump();
+mov (ecx, ptr[rsi*2+1000]); dump();
+mov (ecx, ptr[rsi*2-1]); dump();
+mov (ecx, ptr[rsi*2-1000]); dump();
+mov (ecx, ptr[rsi*4+0]); dump();
+mov (ecx, ptr[rsi*4+1]); dump();
+mov (ecx, ptr[rsi*4+1000]); dump();
+mov (ecx, ptr[rsi*4-1]); dump();
+mov (ecx, ptr[rsi*4-1000]); dump();
+mov (ecx, ptr[rsi*8+0]); dump();
+mov (ecx, ptr[rsi*8+1]); dump();
+mov (ecx, ptr[rsi*8+1000]); dump();
+mov (ecx, ptr[rsi*8-1]); dump();
+mov (ecx, ptr[rsi*8-1000]); dump();
+mov (ecx, ptr[rdi+0]); dump();
+mov (ecx, ptr[rdi+1]); dump();
+mov (ecx, ptr[rdi+1000]); dump();
+mov (ecx, ptr[rdi-1]); dump();
+mov (ecx, ptr[rdi-1000]); dump();
+mov (ecx, ptr[rdi*1+0]); dump();
+mov (ecx, ptr[rdi*1+1]); dump();
+mov (ecx, ptr[rdi*1+1000]); dump();
+mov (ecx, ptr[rdi*1-1]); dump();
+mov (ecx, ptr[rdi*1-1000]); dump();
+mov (ecx, ptr[rdi*2+0]); dump();
+mov (ecx, ptr[rdi*2+1]); dump();
+mov (ecx, ptr[rdi*2+1000]); dump();
+mov (ecx, ptr[rdi*2-1]); dump();
+mov (ecx, ptr[rdi*2-1000]); dump();
+mov (ecx, ptr[rdi*4+0]); dump();
+mov (ecx, ptr[rdi*4+1]); dump();
+mov (ecx, ptr[rdi*4+1000]); dump();
+mov (ecx, ptr[rdi*4-1]); dump();
+mov (ecx, ptr[rdi*4-1000]); dump();
+mov (ecx, ptr[rdi*8+0]); dump();
+mov (ecx, ptr[rdi*8+1]); dump();
+mov (ecx, ptr[rdi*8+1000]); dump();
+mov (ecx, ptr[rdi*8-1]); dump();
+mov (ecx, ptr[rdi*8-1000]); dump();
+}
+    void gen58(){
+mov (ecx, ptr[r9+0]); dump();
+mov (ecx, ptr[r9+1]); dump();
+mov (ecx, ptr[r9+1000]); dump();
+mov (ecx, ptr[r9-1]); dump();
+mov (ecx, ptr[r9-1000]); dump();
+mov (ecx, ptr[r9*1+0]); dump();
+mov (ecx, ptr[r9*1+1]); dump();
+mov (ecx, ptr[r9*1+1000]); dump();
+mov (ecx, ptr[r9*1-1]); dump();
+mov (ecx, ptr[r9*1-1000]); dump();
+mov (ecx, ptr[r9*2+0]); dump();
+mov (ecx, ptr[r9*2+1]); dump();
+mov (ecx, ptr[r9*2+1000]); dump();
+mov (ecx, ptr[r9*2-1]); dump();
+mov (ecx, ptr[r9*2-1000]); dump();
+mov (ecx, ptr[r9*4+0]); dump();
+mov (ecx, ptr[r9*4+1]); dump();
+mov (ecx, ptr[r9*4+1000]); dump();
+mov (ecx, ptr[r9*4-1]); dump();
+mov (ecx, ptr[r9*4-1000]); dump();
+mov (ecx, ptr[r9*8+0]); dump();
+mov (ecx, ptr[r9*8+1]); dump();
+mov (ecx, ptr[r9*8+1000]); dump();
+mov (ecx, ptr[r9*8-1]); dump();
+mov (ecx, ptr[r9*8-1000]); dump();
+mov (ecx, ptr[r10+0]); dump();
+mov (ecx, ptr[r10+1]); dump();
+mov (ecx, ptr[r10+1000]); dump();
+mov (ecx, ptr[r10-1]); dump();
+mov (ecx, ptr[r10-1000]); dump();
+mov (ecx, ptr[r10*1+0]); dump();
+mov (ecx, ptr[r10*1+1]); dump();
+mov (ecx, ptr[r10*1+1000]); dump();
+mov (ecx, ptr[r10*1-1]); dump();
+mov (ecx, ptr[r10*1-1000]); dump();
+mov (ecx, ptr[r10*2+0]); dump();
+mov (ecx, ptr[r10*2+1]); dump();
+mov (ecx, ptr[r10*2+1000]); dump();
+mov (ecx, ptr[r10*2-1]); dump();
+mov (ecx, ptr[r10*2-1000]); dump();
+mov (ecx, ptr[r10*4+0]); dump();
+mov (ecx, ptr[r10*4+1]); dump();
+mov (ecx, ptr[r10*4+1000]); dump();
+mov (ecx, ptr[r10*4-1]); dump();
+mov (ecx, ptr[r10*4-1000]); dump();
+mov (ecx, ptr[r10*8+0]); dump();
+mov (ecx, ptr[r10*8+1]); dump();
+mov (ecx, ptr[r10*8+1000]); dump();
+mov (ecx, ptr[r10*8-1]); dump();
+mov (ecx, ptr[r10*8-1000]); dump();
+mov (ecx, ptr[r11+0]); dump();
+mov (ecx, ptr[r11+1]); dump();
+mov (ecx, ptr[r11+1000]); dump();
+mov (ecx, ptr[r11-1]); dump();
+mov (ecx, ptr[r11-1000]); dump();
+mov (ecx, ptr[r11*1+0]); dump();
+mov (ecx, ptr[r11*1+1]); dump();
+mov (ecx, ptr[r11*1+1000]); dump();
+mov (ecx, ptr[r11*1-1]); dump();
+mov (ecx, ptr[r11*1-1000]); dump();
+mov (ecx, ptr[r11*2+0]); dump();
+mov (ecx, ptr[r11*2+1]); dump();
+mov (ecx, ptr[r11*2+1000]); dump();
+mov (ecx, ptr[r11*2-1]); dump();
+mov (ecx, ptr[r11*2-1000]); dump();
+mov (ecx, ptr[r11*4+0]); dump();
+mov (ecx, ptr[r11*4+1]); dump();
+mov (ecx, ptr[r11*4+1000]); dump();
+mov (ecx, ptr[r11*4-1]); dump();
+mov (ecx, ptr[r11*4-1000]); dump();
+mov (ecx, ptr[r11*8+0]); dump();
+mov (ecx, ptr[r11*8+1]); dump();
+mov (ecx, ptr[r11*8+1000]); dump();
+mov (ecx, ptr[r11*8-1]); dump();
+mov (ecx, ptr[r11*8-1000]); dump();
+mov (ecx, ptr[r12+0]); dump();
+mov (ecx, ptr[r12+1]); dump();
+mov (ecx, ptr[r12+1000]); dump();
+mov (ecx, ptr[r12-1]); dump();
+mov (ecx, ptr[r12-1000]); dump();
+mov (ecx, ptr[r12*1+0]); dump();
+mov (ecx, ptr[r12*1+1]); dump();
+mov (ecx, ptr[r12*1+1000]); dump();
+mov (ecx, ptr[r12*1-1]); dump();
+mov (ecx, ptr[r12*1-1000]); dump();
+mov (ecx, ptr[r12*2+0]); dump();
+mov (ecx, ptr[r12*2+1]); dump();
+mov (ecx, ptr[r12*2+1000]); dump();
+mov (ecx, ptr[r12*2-1]); dump();
+mov (ecx, ptr[r12*2-1000]); dump();
+mov (ecx, ptr[r12*4+0]); dump();
+mov (ecx, ptr[r12*4+1]); dump();
+mov (ecx, ptr[r12*4+1000]); dump();
+mov (ecx, ptr[r12*4-1]); dump();
+mov (ecx, ptr[r12*4-1000]); dump();
+mov (ecx, ptr[r12*8+0]); dump();
+mov (ecx, ptr[r12*8+1]); dump();
+mov (ecx, ptr[r12*8+1000]); dump();
+mov (ecx, ptr[r12*8-1]); dump();
+mov (ecx, ptr[r12*8-1000]); dump();
+}
+    void gen59(){
+mov (ecx, ptr[r13+0]); dump();
+mov (ecx, ptr[r13+1]); dump();
+mov (ecx, ptr[r13+1000]); dump();
+mov (ecx, ptr[r13-1]); dump();
+mov (ecx, ptr[r13-1000]); dump();
+mov (ecx, ptr[r13*1+0]); dump();
+mov (ecx, ptr[r13*1+1]); dump();
+mov (ecx, ptr[r13*1+1000]); dump();
+mov (ecx, ptr[r13*1-1]); dump();
+mov (ecx, ptr[r13*1-1000]); dump();
+mov (ecx, ptr[r13*2+0]); dump();
+mov (ecx, ptr[r13*2+1]); dump();
+mov (ecx, ptr[r13*2+1000]); dump();
+mov (ecx, ptr[r13*2-1]); dump();
+mov (ecx, ptr[r13*2-1000]); dump();
+mov (ecx, ptr[r13*4+0]); dump();
+mov (ecx, ptr[r13*4+1]); dump();
+mov (ecx, ptr[r13*4+1000]); dump();
+mov (ecx, ptr[r13*4-1]); dump();
+mov (ecx, ptr[r13*4-1000]); dump();
+mov (ecx, ptr[r13*8+0]); dump();
+mov (ecx, ptr[r13*8+1]); dump();
+mov (ecx, ptr[r13*8+1000]); dump();
+mov (ecx, ptr[r13*8-1]); dump();
+mov (ecx, ptr[r13*8-1000]); dump();
+mov (ecx, ptr[r14+0]); dump();
+mov (ecx, ptr[r14+1]); dump();
+mov (ecx, ptr[r14+1000]); dump();
+mov (ecx, ptr[r14-1]); dump();
+mov (ecx, ptr[r14-1000]); dump();
+mov (ecx, ptr[r14*1+0]); dump();
+mov (ecx, ptr[r14*1+1]); dump();
+mov (ecx, ptr[r14*1+1000]); dump();
+mov (ecx, ptr[r14*1-1]); dump();
+mov (ecx, ptr[r14*1-1000]); dump();
+mov (ecx, ptr[r14*2+0]); dump();
+mov (ecx, ptr[r14*2+1]); dump();
+mov (ecx, ptr[r14*2+1000]); dump();
+mov (ecx, ptr[r14*2-1]); dump();
+mov (ecx, ptr[r14*2-1000]); dump();
+mov (ecx, ptr[r14*4+0]); dump();
+mov (ecx, ptr[r14*4+1]); dump();
+mov (ecx, ptr[r14*4+1000]); dump();
+mov (ecx, ptr[r14*4-1]); dump();
+mov (ecx, ptr[r14*4-1000]); dump();
+mov (ecx, ptr[r14*8+0]); dump();
+mov (ecx, ptr[r14*8+1]); dump();
+mov (ecx, ptr[r14*8+1000]); dump();
+mov (ecx, ptr[r14*8-1]); dump();
+mov (ecx, ptr[r14*8-1000]); dump();
+mov (ecx, ptr[r15+0]); dump();
+mov (ecx, ptr[r15+1]); dump();
+mov (ecx, ptr[r15+1000]); dump();
+mov (ecx, ptr[r15-1]); dump();
+mov (ecx, ptr[r15-1000]); dump();
+mov (ecx, ptr[r15*1+0]); dump();
+mov (ecx, ptr[r15*1+1]); dump();
+mov (ecx, ptr[r15*1+1000]); dump();
+mov (ecx, ptr[r15*1-1]); dump();
+mov (ecx, ptr[r15*1-1000]); dump();
+mov (ecx, ptr[r15*2+0]); dump();
+mov (ecx, ptr[r15*2+1]); dump();
+mov (ecx, ptr[r15*2+1000]); dump();
+mov (ecx, ptr[r15*2-1]); dump();
+mov (ecx, ptr[r15*2-1000]); dump();
+mov (ecx, ptr[r15*4+0]); dump();
+mov (ecx, ptr[r15*4+1]); dump();
+mov (ecx, ptr[r15*4+1000]); dump();
+mov (ecx, ptr[r15*4-1]); dump();
+mov (ecx, ptr[r15*4-1000]); dump();
+mov (ecx, ptr[r15*8+0]); dump();
+mov (ecx, ptr[r15*8+1]); dump();
+mov (ecx, ptr[r15*8+1000]); dump();
+mov (ecx, ptr[r15*8-1]); dump();
+mov (ecx, ptr[r15*8-1000]); dump();
+mov (ecx, ptr[(void*)0x00000000]); dump();
+mov (ecx, ptr[(void*)0x00000001]); dump();
+mov (ecx, ptr[(void*)0x000003E8]); dump();
+mov (ecx, ptr[(void*)0xFFFFFFFF]); dump();
+mov (ecx, ptr[(void*)0xFFFFFC18]); dump();
+mov (ecx, ptr[(void*)0x00000000]); dump();
+mov (ecx, ptr[(void*)0x00000001]); dump();
+mov (ecx, ptr[(void*)0x000003E8]); dump();
+mov (ecx, ptr[(void*)0xFFFFFFFF]); dump();
+mov (ecx, ptr[(void*)0xFFFFFC18]); dump();
+mov (ecx, ptr[(void*)0x00000000]); dump();
+mov (ecx, ptr[(void*)0x00000001]); dump();
+mov (ecx, ptr[(void*)0x000003E8]); dump();
+mov (ecx, ptr[(void*)0xFFFFFFFF]); dump();
+mov (ecx, ptr[(void*)0xFFFFFC18]); dump();
+mov (ecx, ptr[(void*)0x00000000]); dump();
+mov (ecx, ptr[(void*)0x00000001]); dump();
+mov (ecx, ptr[(void*)0x000003E8]); dump();
+mov (ecx, ptr[(void*)0xFFFFFFFF]); dump();
+mov (ecx, ptr[(void*)0xFFFFFC18]); dump();
+mov (ecx, ptr[(void*)0x00000000]); dump();
+mov (ecx, ptr[(void*)0x00000001]); dump();
+mov (ecx, ptr[(void*)0x000003E8]); dump();
+mov (ecx, ptr[(void*)0xFFFFFFFF]); dump();
+mov (ecx, ptr[(void*)0xFFFFFC18]); dump();
+}
+    void gen60(){
+}
+void gen(){
+   gen0();
+   gen1();
+   gen2();
+   gen3();
+   gen4();
+   gen5();
+   gen6();
+   gen7();
+   gen8();
+   gen9();
+   gen10();
+   gen11();
+   gen12();
+   gen13();
+   gen14();
+   gen15();
+   gen16();
+   gen17();
+   gen18();
+   gen19();
+   gen20();
+   gen21();
+   gen22();
+   gen23();
+   gen24();
+   gen25();
+   gen26();
+   gen27();
+   gen28();
+   gen29();
+   gen30();
+   gen31();
+   gen32();
+   gen33();
+   gen34();
+   gen35();
+   gen36();
+   gen37();
+   gen38();
+   gen39();
+   gen40();
+   gen41();
+   gen42();
+   gen43();
+   gen44();
+   gen45();
+   gen46();
+   gen47();
+   gen48();
+   gen49();
+   gen50();
+   gen51();
+   gen52();
+   gen53();
+   gen54();
+   gen55();
+   gen56();
+   gen57();
+   gen58();
+   gen59();
+   gen60();
+}
diff --git a/test/nm_frame.cpp b/test/nm_frame.cpp
index d63cab1..52fb352 100644
--- a/test/nm_frame.cpp
+++ b/test/nm_frame.cpp
@@ -6,21 +6,9 @@ using namespace Xbyak;
 class Sample : public CodeGenerator {
 	void operator=(const Sample&);
 public:
-	void gen()
-	{
-		try {
-
 #include "nm.cpp"
-
-		} catch (Xbyak::Error err) {
-			printf("ERR:%s(%d)\n", ConvertErrorToString(err), err);
-		} catch (...) {
-			printf("unkwon error\n");
-		}
-	}
 };
 
-
 #define _STR(x) #x
 #define TEST(syntax) err = true; try { syntax; err = false; } catch (Xbyak::Error) { } catch (...) { } if (!err) printf("should be err:%s;\n", _STR(syntax))
 
@@ -38,8 +26,14 @@ public:
 };
 int main()
 {
-	Sample s;
-	s.gen();
+	try {
+		Sample s;
+		s.gen();
+	} catch (Xbyak::Error err) {
+		printf("ERR:%s(%d)\n", Xbyak::ConvertErrorToString(err), err);
+	} catch (...) {
+		printf("unknown error\n");
+	}
 	ErrorSample es;
 	es.gen();
 }
diff --git a/test/test_address.bat b/test/test_address.bat
index 4ea44e2..36240dd 100644
--- a/test/test_address.bat
+++ b/test/test_address.bat
@@ -3,7 +3,7 @@ if /i "%1"=="64" (
 	set OPT2=-DXBYAK64
 	set OPT3=win64
 ) else (
-	set OPT2=
+	set OPT2=-DXBYAK32
 	set OPT3=win32
 )
 
@@ -20,12 +20,16 @@ if /i "%1"=="64" (
 goto end
 
 :sub
+echo cl address.cpp %OPT% %OPT2%
 cl address.cpp %OPT% %OPT2%
 address %1% > a.asm
+echo nasm -f %OPT3% -l a.lst a.asm
 nasm -f %OPT3% -l a.lst a.asm
 awk "{print $3}" < a.lst > ok.lst
+echo address %1% jit > nm.cpp
 address %1% jit > nm.cpp
-cl -I../ -DTEST_NM nm_frame.cpp %OPT% %OPT2%
+echo cl -I../ -DXBYAK_TEST nm_frame.cpp %OPT% %OPT2%
+cl -I../ -DXBYAK_TEST nm_frame.cpp %OPT% %OPT2%
 nm_frame > x.lst
 diff x.lst ok.lst
 wc x.lst
diff --git a/test/test_jmp.bat b/test/test_jmp.bat
index 13e3f9b..eb333d6 100644
--- a/test/test_jmp.bat
+++ b/test/test_jmp.bat
@@ -1,5 +1,5 @@
 pushd ..\gen
 call update
 popd
-cl -I../ -DTEST_NM jmp.cpp %OPT%
+cl -I../ -DXBYAK_TEST jmp.cpp %OPT%
 jmp
diff --git a/test/test_nm.bat b/test/test_nm.bat
index a3bf8cd..d351b40 100644
--- a/test/test_nm.bat
+++ b/test/test_nm.bat
@@ -18,8 +18,8 @@ if /i "%1"=="Y" (
 	set OPT3=win64
 	set FILTER=normalize_prefix
 ) else (
-	set EXE=nasm.exe -DXBYAK32
-	set OPT2=
+	set EXE=nasm.exe
+	set OPT2=-DXBYAK32
 	set OPT3=win32
 )
 pushd ..\gen
@@ -36,7 +36,7 @@ if /i "%Y%"=="1" (
 	awk "{if (index($3, ""-"")) { conti=substr($3, 0, length($3) - 1) } else { conti = conti $3; print conti; conti = """" }} " < a.lst |%FILTER% > ok.lst
 )
 make_nm jit > nm.cpp
-cl -I../ -DTEST_NM nm_frame.cpp %OPT% %OPT2%
+cl -I../ -DXBYAK_TEST nm_frame.cpp %OPT% %OPT2%
 nm_frame |%FILTER% > x.lst
 diff x.lst ok.lst
 wc x.lst
diff --git a/test/test_nm.sh b/test/test_nm.sh
index a461585..b3eca1e 100755
--- a/test/test_nm.sh
+++ b/test/test_nm.sh
@@ -36,7 +36,7 @@ awk '{if (index($3, "-")) { conti=substr($3, 0, length($3) - 1) } else { conti =
 echo "xbyak"
 ./make_nm jit > nm.cpp
 echo "compile nm_frame.cpp"
-g++ $CFLAGS -DTEST_NM nm_frame.cpp -o nm_frame
+g++ $CFLAGS -DXBYAK_TEST nm_frame.cpp -o nm_frame
 ./nm_frame | $FILTER > x.lst
 diff ok.lst x.lst && echo "ok"
 exit 0
diff --git a/xbyak/xbyak.h b/xbyak/xbyak.h
index 9673c3c..d4982dd 100644
--- a/xbyak/xbyak.h
+++ b/xbyak/xbyak.h
@@ -4,9 +4,9 @@
 	@file xbyak.h
 	@brief Xbyak ; JIT assembler for x86(IA32)/x64 by C++
 	@author herumi
-	@version $Revision: 1.188 $
+	@version $Revision: 1.191 $
 	@url http://homepage1.nifty.com/herumi/soft/xbyak.html
-	@date $Date: 2010/05/24 06:13:44 $
+	@date $Date: 2010/06/01 05:26:11 $
 	@note modified new BSD license
 	http://www.opensource.org/licenses/bsd-license.php
 */
@@ -55,7 +55,7 @@ namespace Xbyak {
 
 enum {
 	DEFAULT_MAX_CODE_SIZE = 2048,
-	VERSION = 0x2260, /* 0xABCD = A.BC(D) */
+	VERSION = 0x2270, /* 0xABCD = A.BC(D) */
 };
 
 #ifndef MIE_INTEGER_TYPE_DEFINED
@@ -144,7 +144,7 @@ namespace inner {
 
 enum { debug = 1 };
 
-static inline uint32 GetPtrDist(const void *p1, const void *p2 = 0)
+static inline uint32 GetPtrDist(const void *p1, const void *p2)
 {
 	uint64 diff = static_cast<const char *>(p1) - static_cast<const char *>(p2);
 #ifdef XBYAK64
@@ -154,6 +154,7 @@ static inline uint32 GetPtrDist(const void *p1, const void *p2 = 0)
 }
 
 static inline bool IsInDisp8(uint32 x) { return 0xFFFFFF80 <= x || x <= 0x7F; }
+static inline bool IsInInt32(uint64 x) { return 0xFFFFFFFF80000000ULL <= x || x <= 0x7FFFFFFFU; }
 
 }
 
@@ -555,7 +556,11 @@ public:
 	explicit AddressFrame(uint32 bit) : bit_(bit) { }
 	Address operator[](const void *disp) const
 	{
-		Reg32e r(Reg(), Reg(), 0, inner::GetPtrDist(disp));
+		size_t adr = reinterpret_cast<size_t>(disp);
+#ifdef XBYAK64
+		if (adr > 0xFFFFFFFFU) throw ERR_OFFSET_IS_TOO_BIG;
+#endif
+		Reg32e r(Reg(), Reg(), 0, adr);
 		return operator[](r);
 	}
 #ifdef XBYAK64
@@ -1216,13 +1221,32 @@ protected:
 			opRM_RM(reg1, reg2, B10001000);
 		}
 	}
-	void mov(const Operand& op, uint64 imm)
+	void mov(const Operand& op,
+#ifdef XBYAK64
+	uint64
+#else
+	uint32
+#endif
+	imm)
 	{
 		verifyMemHasSize(op);
 		if (op.isREG()) {
-			int w = op.isBit(8) ? 0 : 1;
-			rex(op); db(B10110000 | (w << 3) | (op.getIdx() & 7));
-			db(imm, op.getBit() / 8);
+			rex(op);
+			int code, size;
+#ifdef XBYAK64
+			if (op.isBit(64) && inner::IsInInt32(imm)) {
+				db(B11000111);
+				code = B11000000;
+				size = 4;
+			} else
+#endif
+			{
+				code = B10110000 | ((op.isBit(8) ? 0 : 1) << 3);
+				size = op.getBit() / 8;
+			}
+
+			db(code | (op.getIdx() & 7));
+			db(imm, size);
 		} else if (op.isMEM()) {
 			opModM(static_cast<const Address&>(op), Reg(0, Operand::REG, op.getBit()), B11000110);
 			int size = op.getBit() / 8; if (size > 4) size = 4;
@@ -1398,7 +1422,7 @@ public:
 //		if (hasUndefinedLabel()) throw ERR_LABEL_IS_NOT_FOUND;
 		return top_;
 	}
-#ifdef TEST_NM
+#ifdef XBYAK_TEST
 	void dump(bool doClear = true)
 	{
 		CodeArray::dump();
diff --git a/xbyak/xbyak_mnemonic.h b/xbyak/xbyak_mnemonic.h
index 0ab80ca..8c59c04 100644
--- a/xbyak/xbyak_mnemonic.h
+++ b/xbyak/xbyak_mnemonic.h
@@ -1,4 +1,4 @@
-const char *getVersionString() const { return "2.26"; }
+const char *getVersionString() const { return "2.27"; }
 void packssdw(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0x6B); }
 void packsswb(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0x63); }
 void packuswb(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0x67); }
diff --git a/xbyak/xbyak_util.h b/xbyak/xbyak_util.h
index 2da6551..535fcf3 100644
--- a/xbyak/xbyak_util.h
+++ b/xbyak/xbyak_util.h
@@ -95,25 +95,25 @@ public:
 		if (data[2] == get32bitAsBE(amd)) {
 			type_ |= tAMD;
 			getCpuid(0x80000001, data);
-			if (data[3] & (1 << 31)) type_ |= t3DN;
-			if (data[3] & (1 << 15)) type_ |= tCMOV;
-			if (data[3] & (1 << 30)) type_ |= tE3DN;
-			if (data[3] & (1 << 22)) type_ |= tMMX2;
+			if (data[3] & (1U << 31)) type_ |= t3DN;
+			if (data[3] & (1U << 15)) type_ |= tCMOV;
+			if (data[3] & (1U << 30)) type_ |= tE3DN;
+			if (data[3] & (1U << 22)) type_ |= tMMX2;
 		}
 		if (data[2] == get32bitAsBE(intel)) {
 			type_ |= tINTEL;
 		}
 		getCpuid(1, data);
-		if (data[2] & (1 << 0)) type_ |= tSSE3;
-		if (data[2] & (1 << 9)) type_ |= tSSSE3;
-		if (data[2] & (1 << 19)) type_ |= tSSE41;
-		if (data[2] & (1 << 20)) type_ |= tSSE42;
-		if (data[2] & (1 << 23)) type_ |= tPOPCNT;
+		if (data[2] & (1U << 0)) type_ |= tSSE3;
+		if (data[2] & (1U << 9)) type_ |= tSSSE3;
+		if (data[2] & (1U << 19)) type_ |= tSSE41;
+		if (data[2] & (1U << 20)) type_ |= tSSE42;
+		if (data[2] & (1U << 23)) type_ |= tPOPCNT;
 
-		if (data[3] & (1 << 15)) type_ |= tCMOV;
-		if (data[3] & (1 << 23)) type_ |= tMMX;
-		if (data[3] & (1 << 25)) type_ |= tMMX2 | tSSE;
-		if (data[3] & (1 << 26)) type_ |= tSSE2;
+		if (data[3] & (1U << 15)) type_ |= tCMOV;
+		if (data[3] & (1U << 23)) type_ |= tMMX;
+		if (data[3] & (1U << 25)) type_ |= tMMX2 | tSSE;
+		if (data[3] & (1U << 26)) type_ |= tSSE2;
 	}
 	bool has(Type type) const
 	{