From 5cd5e799a6f710cdcb7a3535c7731a9f701dde17 Mon Sep 17 00:00:00 2001
From: zeromus <zeromus@zeromus.org>
Date: Sun, 3 Apr 2011 05:24:31 +0000
Subject: [PATCH] add 5% of the world's slowest ARM cpu emulator

---
 BizHawk.Emulation/BizHawk.Emulation.csproj    |   16 +-
 BizHawk.Emulation/CPUs/ARM/ARM.CP.cs          |   60 +
 BizHawk.Emulation/CPUs/ARM/ARM.Disassembly.cs |  464 +
 BizHawk.Emulation/CPUs/ARM/ARM.Execute.cs     |  147 +
 .../CPUs/ARM/ARM.ExecuteArm.Unconditional.cs  |   61 +
 BizHawk.Emulation/CPUs/ARM/ARM.ExecuteArm.cs  |  785 ++
 BizHawk.Emulation/CPUs/ARM/ARM.ExecuteCore.cs |  998 ++
 .../CPUs/ARM/ARM.ExecuteThumb.cs              |  905 ++
 BizHawk.Emulation/CPUs/ARM/ARM.Pseudocode.cs  |  460 +
 BizHawk.Emulation/CPUs/ARM/ARM.cs             |  211 +
 BizHawk.Emulation/CPUs/ARM/_.cs               | 8270 +++++++++++++++++
 BizHawk.Emulation/CPUs/ARM/decoder/decoder.cs |  179 +
 .../CPUs/ARM/decoder/scripting.cs             |  136 +
 13 files changed, 12691 insertions(+), 1 deletion(-)
 create mode 100644 BizHawk.Emulation/CPUs/ARM/ARM.CP.cs
 create mode 100644 BizHawk.Emulation/CPUs/ARM/ARM.Disassembly.cs
 create mode 100644 BizHawk.Emulation/CPUs/ARM/ARM.Execute.cs
 create mode 100644 BizHawk.Emulation/CPUs/ARM/ARM.ExecuteArm.Unconditional.cs
 create mode 100644 BizHawk.Emulation/CPUs/ARM/ARM.ExecuteArm.cs
 create mode 100644 BizHawk.Emulation/CPUs/ARM/ARM.ExecuteCore.cs
 create mode 100644 BizHawk.Emulation/CPUs/ARM/ARM.ExecuteThumb.cs
 create mode 100644 BizHawk.Emulation/CPUs/ARM/ARM.Pseudocode.cs
 create mode 100644 BizHawk.Emulation/CPUs/ARM/ARM.cs
 create mode 100644 BizHawk.Emulation/CPUs/ARM/_.cs
 create mode 100644 BizHawk.Emulation/CPUs/ARM/decoder/decoder.cs
 create mode 100644 BizHawk.Emulation/CPUs/ARM/decoder/scripting.cs

diff --git a/BizHawk.Emulation/BizHawk.Emulation.csproj b/BizHawk.Emulation/BizHawk.Emulation.csproj
index ee086355b6..85f2dc41ef 100644
--- a/BizHawk.Emulation/BizHawk.Emulation.csproj
+++ b/BizHawk.Emulation/BizHawk.Emulation.csproj
@@ -3,7 +3,7 @@
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProductVersion>9.0.21022</ProductVersion>
+    <ProductVersion>9.0.30729</ProductVersion>
     <SchemaVersion>2.0</SchemaVersion>
     <ProjectGuid>{197D4314-8A9F-49BA-977D-54ACEFAEB6BA}</ProjectGuid>
     <OutputType>Library</OutputType>
@@ -40,6 +40,8 @@
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\BizHawk.MultiClient\LuaInterface.dll</HintPath>
     </Reference>
+    <Reference Include="Microsoft.JScript" />
+    <Reference Include="Microsoft.Vsa" />
     <Reference Include="System" />
     <Reference Include="System.Core">
       <RequiredTargetFramework>3.5</RequiredTargetFramework>
@@ -104,6 +106,18 @@
     <Compile Include="CPUs\68000\Memory.cs" />
     <Compile Include="CPUs\68000\OpcodeTable.cs" />
     <Compile Include="CPUs\68000\Tables.cs" />
+    <Compile Include="CPUs\ARM\ARM.CP.cs" />
+    <Compile Include="CPUs\ARM\ARM.cs" />
+    <Compile Include="CPUs\ARM\ARM.Disassembly.cs" />
+    <Compile Include="CPUs\ARM\ARM.Execute.cs" />
+    <Compile Include="CPUs\ARM\ARM.ExecuteArm.cs" />
+    <Compile Include="CPUs\ARM\ARM.ExecuteArm.Unconditional.cs" />
+    <Compile Include="CPUs\ARM\ARM.ExecuteCore.cs" />
+    <Compile Include="CPUs\ARM\ARM.ExecuteThumb.cs" />
+    <Compile Include="CPUs\ARM\ARM.Pseudocode.cs" />
+    <Compile Include="CPUs\ARM\decoder\decoder.cs" />
+    <Compile Include="CPUs\ARM\decoder\scripting.cs" />
+    <Compile Include="CPUs\ARM\_.cs" />
     <Compile Include="CPUs\HuC6280\Disassembler.cs" />
     <Compile Include="CPUs\HuC6280\Execute.cs" />
     <Compile Include="CPUs\HuC6280\HuC6280.cs" />
diff --git a/BizHawk.Emulation/CPUs/ARM/ARM.CP.cs b/BizHawk.Emulation/CPUs/ARM/ARM.CP.cs
new file mode 100644
index 0000000000..af027849f4
--- /dev/null
+++ b/BizHawk.Emulation/CPUs/ARM/ARM.CP.cs
@@ -0,0 +1,60 @@
+using System;
+
+namespace BizHawk.Emulation.CPUs.ARM
+{
+
+	partial class ARM
+	{
+		public ARM.CP15 cp15;
+
+		public uint cp15_MRC(uint opc1, uint t, uint crn, uint crm, uint opc2)
+		{
+			if (t == 15) unpredictable = true;
+			switch (crn)
+			{
+				case 13:
+					switch (opc2)
+					{
+						case 0: return cp15.FCSEIDR;
+						case 1: return cp15.CONTEXTIDR;
+						case 2: return cp15.TPIDRURW;
+						case 3: return cp15.TPIDRURO;
+						case 4: return cp15.TPIDRPRW;
+					}
+					break;
+			}
+
+			//unhandled...
+			unpredictable = true;
+			return 0;
+		}
+
+		public string cp15_Describe(uint opc1, uint t, uint crn, uint crm, uint opc2)
+		{
+			switch (crn)
+			{
+				case 13:
+					switch (opc2)
+					{
+						case 0: return "CP15.FCSEIDR: FCSE PID";
+						case 1: return "CP15.CONTEXTIDR: Context ID";
+						case 2: return "CP15.TPIDRURW: User RW Thread ID";
+						case 3: return "CP15.TPIDRURW: User RO Thread ID";
+						case 4: return "CP15.TPIDRURW: Priv. Only Thread ID";
+					}
+					break;
+			}
+
+			return "unknown";
+		}
+
+		public class CP15
+		{
+			//c13
+			public uint FCSEIDR;
+			public uint CONTEXTIDR;
+			public uint TPIDRURW, TPIDRURO, TPIDRPRW;
+		}
+	}
+
+}
\ No newline at end of file
diff --git a/BizHawk.Emulation/CPUs/ARM/ARM.Disassembly.cs b/BizHawk.Emulation/CPUs/ARM/ARM.Disassembly.cs
new file mode 100644
index 0000000000..3c05c84489
--- /dev/null
+++ b/BizHawk.Emulation/CPUs/ARM/ARM.Disassembly.cs
@@ -0,0 +1,464 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace BizHawk.Emulation.CPUs.ARM
+{
+	partial class ARM
+	{
+		public class DisassemblyOptions
+		{
+			//TODO - refactor these to NumberOptions or somesuch and have several of those
+			//0 = unpadded ; 1,2,4 = numbytes: -1 = no hex
+			public int SVC_hex;
+			public bool SVC_hexPrefix, SVC_literalPrefix, SVC_caps;
+			public bool SVC_showName = true;
+
+			public void SetNstyle()
+			{
+				SVC_hex = 0;
+				SVC_hexPrefix = false;
+				SVC_literalPrefix = false;
+				SVC_caps = true;
+				hideZeroOffset = true;
+				//showExplicitAccumulateRegisters = false;
+			}
+
+			public bool showoptadd = false;
+
+			//fixes retarded debugger label format by adding #0x in front of it
+			public bool fix_nstyle_label = true;
+
+			//TODO - subsume nstyle
+
+			//show all registers when accumulating values, i.e. add r0, r0, #4 (instead of add r0, #4)
+			//TODO - obseleted by rd~rx approach
+			public bool showExplicitAccumulateRegisters = true;
+
+			//hide offsets of #0 (set to true for more terseness with no real loss of information)
+			public bool hideZeroOffset = false;
+
+			//compute PC relative labels for certain operations (like LDR)
+			//public bool computePCLabel = true;
+
+			//consider:
+			//in RVCT many (all?) thumb instructions dont show {S} suffix in thumb mode, because it is sort of redundant (since they always apply in many thumb instructions)
+			//but this is gay. well, consider making it an option
+		}
+
+		public class ProcessorOptions
+		{
+			public void SetNStyle()
+			{
+				Thumb_LSL_immediate_T1_0_is_MOV_register_T2 = false;
+			}
+
+			public bool Thumb_LSL_immediate_T1_0_is_MOV_register_T2 = true;
+		}
+
+		public DisassemblyOptions disopt = new DisassemblyOptions();
+		public ProcessorOptions procopt = new ProcessorOptions();
+
+		bool DIS_Check(object[] args, int argnum, string str, string find)
+		{
+			if (args.Length <= argnum) return false;
+			int index = str.IndexOf(find);
+			if (index == -1) return false;
+			return true;
+		}
+		string disformat_num(object item, bool caps, bool literalprefix, bool hexprefix, int hex)
+		{
+			string hexformat;
+			switch (hex)
+			{
+				case -1: hexformat = "{0}"; break;
+				case 0: hexformat = "{0:x}"; break;
+				case 1: hexformat = "{0:x2}"; break;
+				case 2: hexformat = "{0:x4}"; break;
+				case 4: hexformat = "{0:x8}"; break;
+				default: throw new ArgumentException();
+			}
+			string value = string.Format(hexformat, item);
+			if (caps) value = value.ToUpper();
+			string ret = string.Format("{0}{1}{2}", literalprefix ? "#" : "", hexprefix ? "0x" : "", value);
+			return ret;
+		}
+		uint DIS(string opcode, string format, params object[] args)
+		{
+			//options: 
+			//capital reg names
+			//capital mnemonic
+			//tab between mnemonic and arguments (always? sometimes)
+			//0 front-pad hex arguments
+			const bool capMnemonic = true;
+
+			if (DIS_Check(args, 0, opcode, "/s0/")) opcode = opcode.Replace("/s0/", (bool)args[0] ? "s" : "");
+
+			if (_CurrentCond() == 14)
+				opcode = opcode.Replace("/c/", "");
+			else opcode = opcode.Replace("/c/", CC_strings[_CurrentCond()]);
+
+			if (capMnemonic) opcode = opcode.ToUpper();
+
+			string ret = string.Format(opcode + " " + format, args);
+
+			if (DIS_Check(args, 0, ret, "/a0/")) ret = ret.Replace("/a0/", string.Format("{0:x}", args[0])); //address format
+			if (DIS_Check(args, 1, ret, "/a1/")) ret = ret.Replace("/a1/", string.Format("{0:x}", args[1]));
+			if (DIS_Check(args, 0, ret, "/r0/")) ret = ret.Replace("/r0/", Reg_names[(uint)args[0]].ToLower());
+			if (DIS_Check(args, 1, ret, "/r1/")) ret = ret.Replace("/r1/", Reg_names[(uint)args[1]].ToLower());
+			if (DIS_Check(args, 2, ret, "/r2/")) ret = ret.Replace("/r2/", Reg_names[(uint)args[2]].ToLower());
+			if (DIS_Check(args, 0, ret, "/imm8_0/")) ret = ret.Replace("/imm8_0/", string.Format("#{0}", (uint)args[0]));
+			if (DIS_Check(args, 1, ret, "/imm8_1/")) ret = ret.Replace("/imm8_1/", string.Format("#{0}", (uint)args[1]));
+			if (DIS_Check(args, 1, ret, "/uimm32h_1/")) ret = ret.Replace("/uimm32h_1/", string.Format("#0x{0:x}", (uint)args[1]));
+			if (DIS_Check(args, 0, ret, "/label0/")) ret = ret.Replace("/label0/", string.Format("{0:x}", args[0]));
+			if (DIS_Check(args, 1, ret, "/label1/")) ret = ret.Replace("/label1/", string.Format("{0:x}", args[1]));
+			if (DIS_Check(args, 0, ret, "/svc0/")) ret = ret.Replace("/svc0/", disformat_num(args[0], disopt.SVC_caps, disopt.SVC_literalPrefix, disopt.SVC_hexPrefix, disopt.SVC_hex));
+			if (DIS_Check(args, 0, ret, "/const0/")) ret = ret.Replace("/const0/", "#0x" + string.Format("{0:x}", args[0]).ToUpper());
+			if (DIS_Check(args, 1, ret, "/const1/")) ret = ret.Replace("/const1/", "#0x" + string.Format("{0:x}", args[1]).ToUpper());
+			if (DIS_Check(args, 2, ret, "/const2/")) ret = ret.Replace("/const2/", "#0x" + string.Format("{0:x}", args[2]).ToUpper());
+			//TODO - run constN through the disformat scheme
+			ret = DIS_Reglist(ret, args);
+			disassembly = ret;
+			return 0;
+		}
+
+		string DISNEW_optaddsub(object value)
+		{
+			return (bool)value ? (disopt.showoptadd ? "+" : "") : "-";
+		}
+
+		uint DISNEW(string opcode, string format, params object[] args)
+		{
+			bool hasComment = false;
+
+			const bool capMnemonic = true;
+
+			int index = 0;
+			int tagindex = -1;
+			int argindex = 0;
+			uint regReport = 0;
+
+			//-----
+			//work on opcode
+			if (opcode.IndexOf("<s?>") != -1)
+			{
+				bool s = (bool)args[argindex++];
+				opcode = opcode.Replace("<s?>", s ? "s" : "");
+			}
+
+			//TODO - look for cmaybe and get rid of them.
+			//alternatively, do a good job placing them and just always choose to put them there.
+			//well, we can do that as a separate polish pass later
+			bool cmaybe = (opcode.IndexOf("<c?>") != -1);
+			bool usec = true;
+			if (cmaybe)
+				usec = (bool)args[argindex++];
+			string crepl = cmaybe ? "<c?>" : "<c>";
+
+			if (usec)
+			{
+				if (_CurrentCond() == 14)
+					opcode = opcode.Replace(crepl, "");
+				else opcode = opcode.Replace(crepl, CC_strings[_CurrentCond()]);
+			}
+			else opcode = opcode.Replace(crepl, "");
+			//---------
+
+			string cpcomment = null;
+			while (index < format.Length)
+			{
+				if (tagindex != -1)
+				{
+					if (format[index] == '>')
+					{
+						int len = index - tagindex - 1;
+						string item = format.Substring(tagindex + 1, len).ToLower();
+
+						switch (item)
+						{
+							case "rt":
+							case "rm":
+							case "rn":
+							case "rd":
+								{
+									item = Reg_names[(uint)args[argindex++]].ToLower();
+									break;
+								}
+
+							case "rt!":
+							case "rm!":
+							case "rn!":
+							case "rd!":
+							case "sp!":
+								{
+									uint reg;
+									if (item == "sp!") reg = 13;
+									else reg = (uint)args[argindex++];
+									item = Reg_names[reg].ToLower();
+									regReport |= (uint)(1 << (int)reg);
+									break;
+								}
+
+							case "{rd!~rm, }":
+							case "{rd!~rn, }":
+								{
+									uint rd = (uint)args[argindex++];
+									uint rx = (uint)args[argindex++];
+									if (disopt.showExplicitAccumulateRegisters || rd != rx)
+										item = string.Format("{0}, ", Reg_names[rd].ToLower());
+									else item = "";
+									break;
+								}
+
+							case "fpscr": item = nstyle ? "fpscr" : "FPSCR"; break;
+
+							case "const": item = string.Format("0x{0:x}", args[argindex++]); break;
+							case "imm": item = string.Format("0x{0:x}", args[argindex++]); break;
+							case "imm5": item = string.Format("0x{0:x}", args[argindex++]); break;
+
+							case "{ ,#imm}":
+								{
+									uint temp = (uint)args[argindex++];
+									if (temp == 0) item = "";
+									else item = string.Format(",#0x{0:x}", temp);
+									break;
+								}
+							case "{,+/-#imm}":
+								{
+									uint temp = (uint)args[argindex + 1];
+									if (temp == 0 && disopt.hideZeroOffset) item = "";
+									else item = string.Format(",#{0}0x{1:x}", DISNEW_optaddsub(args[argindex]), temp);
+									argindex++;
+									break;
+								}
+							//case "labelaccess":  //same as label but with [] around it 
+							case "label":
+								if (disopt.fix_nstyle_label)
+									item = string.Format("#0x{0:x}", args[argindex++]);
+								else
+									item = string.Format("{0:x}", args[argindex++]);
+								break;
+							case "%08x": item = string.Format("0x{0:x8}", args[argindex++]); break;
+							case "optaddsub":
+							case "+/-": item = DISNEW_optaddsub((bool)args[argindex++]); break;
+
+							case "{, shift}":
+								{
+									//TODO - consider whether it is necessary to pass in arguments (can they always be pulled from shift_n and shift_t? i think so
+									SRType sr = (SRType)args[argindex++];
+									int shift_n = (int)args[argindex++];
+									switch (sr)
+									{
+										case SRType.LSL:
+											if (shift_n == 0)
+											{
+												//special case for non-rotated things. theyre usually encoded this way
+												item = "";
+												break;
+											}
+											item = ", LSL " + shift_n.ToString(); break;
+										case SRType.LSR: item = ", LSR " + shift_n.ToString(); break;
+										case SRType.ASR: item = ", ASR " + shift_n.ToString(); break;
+										case SRType.ROR: item = ", ROR " + shift_n.ToString(); break;
+										case SRType.RRX: item = ", RRX"; break;
+									}
+									break;
+								}
+							case "{, rotation}":
+								{
+									uint rotation = (uint)args[argindex++] * 8;
+									if (rotation == 0) item = "";
+									else item = "ROR #" + rotation;
+									break;
+								}
+
+							case "registers":
+								item = DISNEW_Reglist((uint)args[argindex++]);
+								break;
+							case "svc":
+								{
+									uint svc = (uint)args[argindex++];
+									if (nstyle) opcode = opcode.Replace("XXX", "SWI");
+									else opcode = opcode.Replace("XXX", "SVC");
+									item = disformat_num(svc, disopt.SVC_caps, disopt.SVC_literalPrefix, disopt.SVC_hexPrefix, disopt.SVC_hex);
+									if (disopt.SVC_showName) { item += " ; " + sys.svc_name(svc); hasComment = true; }
+									break;
+								}
+							case "{wback!}":
+								if ((bool)args[argindex++])
+									item = "!";
+								else item = "";
+								break;
+
+							case "coproc":
+								item = "cp" + args[argindex++].ToString();
+								break;
+							case "opc1":
+							case "opc2":
+								item = "#" + args[argindex++].ToString();
+								break;
+							case "coproc_rt!":
+								{
+									uint reg = (uint)args[argindex++];
+									if (reg == 15)
+									{
+										item = "APSR_nzcv";
+									}
+									else
+										regReport |= (uint)(1 << (int)reg);
+									item = Reg_names[reg].ToLower();
+									break;
+								}
+							case "crn":
+							case "crm":
+								item = "c" + args[argindex++].ToString();
+								break;
+							case "{ ;cp_comment}":
+								{
+									item = "";
+									cpcomment = args[argindex++] as string;
+								}
+
+								break;
+
+							default: item = "<" + item + ">"; break;
+						}
+
+						format = format.Substring(0, tagindex) + item + format.Substring(tagindex + len + 2);
+						index = tagindex + item.Length - 1;
+						tagindex = -1;
+					}
+				}
+				else
+					if (format[index] == '<')
+						tagindex = index;
+				index++;
+			}
+
+			if (capMnemonic) opcode = opcode.ToUpper();
+
+			disassembly = opcode + " " + format;
+			if (unpredictable)
+			{
+				disassembly = disassembly + " ; UNPREDICTABLE";
+				hasComment = true;
+			}
+
+			//report any relevant registers
+			bool hasRegReport = false;
+			for (int i = 0; i < 16; i++)
+			{
+				uint doit = regReport & 1;
+				regReport >>= 1;
+				if (doit == 1)
+				{
+					if (!hasComment) disassembly += " ; ";
+					if (hasRegReport) disassembly += ", ";
+					hasComment = true;
+					hasRegReport = true;
+					disassembly += string.Format("{0}={1:x8}", Reg_names[i].ToLower(), r[i]);
+				}
+			}
+
+			if (!string.IsNullOrEmpty(cpcomment))
+			{
+				disassembly += " ;" + cpcomment;
+			}
+
+			return 0;
+		}
+
+		string DIS_Reglist(string str, object[] args)
+		{
+			int index = str.IndexOf("/reglist/");
+			if (index == -1) return str;
+			uint regs = (uint)args[0];
+			StringBuilder sb = new StringBuilder(32);
+			sb.Append("{");
+			//TODO - coalesce these to the range style!!
+			bool first = true;
+			for (int i = 0; i <= 15; i++)
+			{
+				if (_.BITN(i, regs) == 1)
+				{
+					if (!first) sb.Append(",");
+					sb.Append(Reg_names[i].ToLower());
+					first = false;
+				}
+			}
+			sb.Append("}");
+			return str.Replace("/reglist/", sb.ToString());
+		}
+
+		//TODO - unit test this
+		unsafe string DISNEW_Reglist(uint regs)
+		{
+			StringBuilder sb = new StringBuilder(32);
+			//TODO - coalesce these to the range style!!
+			const int firstname = 13;
+			bool first = true;
+			int range = -1;
+			int lastrange = -1;
+			int* ra = stackalloc int[8];
+			int* rb = stackalloc int[8];
+			for (int i = 0; i <= 15; i++)
+			{
+				bool bit = _.BITN(i, regs) != 0;
+				if (bit && i < firstname)
+				{
+					if (lastrange == -1)
+					{
+						lastrange = i;
+					}
+					else
+					{
+
+					}
+				}
+				if (!bit || i >= firstname)
+				{
+					if (bit && i >= firstname)
+					{
+						range++;
+						ra[range] = i;
+						rb[range] = i;
+					}
+					if (lastrange != -1)
+					{
+						range++;
+						ra[range] = lastrange;
+						rb[range] = i - 1;
+						lastrange = -1;
+					}
+				}
+			}
+
+			sb.Append("{");
+			for (int i = 0; i <= range; i++)
+			{
+				int a = ra[i];
+				int b = rb[i];
+				if (!first) sb.Append(",");
+				if (a == b) sb.Append(Reg_names[a].ToLower());
+				else sb.AppendFormat("{0}-{1}", Reg_names[a].ToLower(), Reg_names[b].ToLower());
+				first = false;
+			}
+			sb.Append("}");
+
+			//sb.Append("{");
+			//for (int i = 0; i <= 15; i++)
+			//{
+			//    if (_.BITN(i, regs) == 1)
+			//    {
+			//        if (!first) sb.Append(",");
+			//        sb.Append(Reg_names[i].ToLower());
+			//        first = false;
+			//    }
+			//}
+			//sb.Append("}");
+
+			return sb.ToString();
+		}
+
+	}
+}
\ No newline at end of file
diff --git a/BizHawk.Emulation/CPUs/ARM/ARM.Execute.cs b/BizHawk.Emulation/CPUs/ARM/ARM.Execute.cs
new file mode 100644
index 0000000000..4eb87c4c3e
--- /dev/null
+++ b/BizHawk.Emulation/CPUs/ARM/ARM.Execute.cs
@@ -0,0 +1,147 @@
+using System;
+using System.Text;
+using System.Runtime.InteropServices;
+
+namespace BizHawk.Emulation.CPUs.ARM
+{
+
+	partial class ARM
+	{
+		public uint Execute()
+		{
+			if (APSR.T == 1) return ExecuteThumb();
+			else return ExecuteArm();
+		}
+
+		enum CC
+		{
+			EQ = 0,
+			NE = 1,
+			CS = 2, HS = 2,
+			CC = 3, LO = 3,
+			MI = 4,
+			PL = 5,
+			VS = 6,
+			VC = 7,
+			HI = 8,
+			LS = 9,
+			GE = 10,
+			LT = 11,
+			GT = 12,
+			LE = 13,
+			AL = 14,
+		}
+		//return (CPSR.N?0x80000000:0)|(CPSR.Z?0x40000000:0)|(CPSR.C?0x20000000:0)|(CPSR.V?0x10000000:0);
+
+		readonly string[] CC_strings = { "EQ", "NE", "CS", "CC", "MI", "PL", "VS", "VC", "HI", "LS", "GE", "LT", "GT", "LE", "AL", "XX" };
+		readonly string[] Reg_names = { "R0", "R1", "R2", "R3", "R4", "R5", "R6", "R7", "R8", "R9", "R10", "R11", "R12", "SP", "LR", "PC" };
+
+		uint CONDITION(uint i) { return i >> 28; }
+		int SIGNEXTEND_24(uint x) { return (((int)x << 8) >> 8); }
+
+		//an instruction sets this flag when the results are unpredictable but will be executed anyway
+		public bool unpredictable;
+		public uint cycles;
+		uint _currentCondVal;
+		uint _CurrentCond()
+		{
+			//TODO - calculate CurrentCond from from A8.3.1
+			return _currentCondVal;
+		}
+		bool _ConditionPassed()
+		{
+			uint cond = _CurrentCond();
+			bool result = false;
+			switch (cond & _.b1110)
+			{
+				case _.b0000: result = APSR.Z == 1; break;
+				case _.b0010: result = APSR.C == 1; break;
+				case _.b0100: result = APSR.N == 1; break;
+				case _.b0110: result = APSR.V == 1; break;
+				case _.b1000: result = APSR.C == 1 && APSR.Z == 0; break;
+				case _.b1010: result = APSR.N == APSR.V; break;
+				case _.b1100: result = (APSR.N == APSR.V) && APSR.Z == 0; break;
+				case _.b1110: result = true; break;
+			}
+			if ((cond & 1) == 1 && cond != _.b1111)
+				result = !result;
+			return result;
+		}
+
+
+		bool CHK(uint value, int mask, int test)
+		{
+			return (value & mask) == test;
+		}
+
+		uint Reg8(uint pos)
+		{
+			return (uint)((instruction >> (int)pos) & 7);
+		}
+
+		uint Reg16(uint pos)
+		{
+			return (uint)((instruction >> (int)pos) & 0xF);
+		}
+
+		uint Execute_Undefined()
+		{
+			if (disassemble) disassembly = "undefined";
+			return 0;
+		}
+
+		uint Execute_Unhandled(string descr)
+		{
+			if (disassemble) disassembly = descr + " unhandled";
+			return 1;
+		}
+
+		uint Disassembly_Unhandled(string descr)
+		{
+			disassembly = "disasm unhandled: " + descr;
+			return 1;
+		}
+
+		uint Disassemble_LDR_STR_immediate(string opcode, uint t, uint imm32, uint n, bool index, bool add, bool wback)
+		{
+			bool offset = index == true && wback == false;
+			bool preindexed = index == true && wback == true;
+			bool postindex = index == false && wback == true;
+
+			string rt = "<rt!>";
+			opcode += "<c>";
+			//we may want conditional logic here to control whether various registers are displayed (we used to have it, but i changed my mind)
+			if (offset)
+				return DISNEW(opcode, rt + ", [<Rn!><{,+/-#imm}>]", t, n, add, imm32);
+			else if (preindexed)
+				return DISNEW(opcode, rt + ", [<Rn!>, <+/-><imm>]!", t, n, add, imm32);
+			else if (postindex)
+				return DISNEW(opcode, rt + ", [<Rn!>], <+/-><imm>", t, n, add, imm32);
+			else throw new InvalidOperationException();
+		}
+
+		uint Disassemble_LDR_STR_register(string opcode, uint t, uint n, uint m, SRType shift_t, int shift_n, bool index, bool add, bool wback)
+		{
+			bool offset = index == true && wback == false;
+			bool preindexed = index == true && wback == true;
+			bool postindex = index == false && wback == true;
+
+			string rt = "<rt!>";
+			opcode += "<c>";
+			//we may want conditional logic here to control whether various registers are displayed (we used to have it, but i changed my mind)
+			if (offset)
+				return DISNEW(opcode, rt + ", [<Rn!>, <+/-><rm!><{, shift}>]", t, n, add, m, shift_t, shift_n);
+			else if (preindexed)
+				return DISNEW(opcode, rt + ", [<Rn!>, <+/-><rm!><{, shift}>]!", t, n, add, m, shift_t, shift_n);
+			else if (postindex)
+				return DISNEW(opcode, rt + ", [<Rn!>], <+/-><rm!><{, shift}>", t, n, add, m, shift_t, shift_n);
+			else throw new InvalidOperationException();
+		}
+
+		void UnalignedAccess(uint addr)
+		{
+			Console.WriteLine("Warning! unaligned access at {0:x8}", addr);
+		}
+	}
+
+}
\ No newline at end of file
diff --git a/BizHawk.Emulation/CPUs/ARM/ARM.ExecuteArm.Unconditional.cs b/BizHawk.Emulation/CPUs/ARM/ARM.ExecuteArm.Unconditional.cs
new file mode 100644
index 0000000000..898f10112a
--- /dev/null
+++ b/BizHawk.Emulation/CPUs/ARM/ARM.ExecuteArm.Unconditional.cs
@@ -0,0 +1,61 @@
+namespace BizHawk.Emulation.CPUs.ARM
+{
+	partial class ARM
+	{
+		uint ExecuteArm_Unconditional()
+		{
+			//A5.7
+
+			uint op1 = (instruction & 0xFF00000) >> 20;
+			uint op = (instruction & 0x10) >> 4;
+
+			//todo: misc instructions, memory hints, and advanced SIMD instructions on page A5-31
+			if (CHK(op1, _.b10000000, _.b00000000)) return ExecuteArm_Unconditional_Misc();
+			if (CHK(op1, _.b11100101, _.b10000100)) return Execute_SRS_A1(); //v6
+			if (CHK(op1, _.b11100101, _.b10000001)) return Execute_RFE_A1(); //v6
+			if (CHK(op1, _.b11100000, _.b10100000)) return Execute_BL_BLX_immediate_A2(); //v5
+			if (CHK(op1, _.b11111011, _.b11000011)) return ExecuteArm_LDC_LDC2_immediate(); //v5
+			if (CHK(op1, _.b11111001, _.b11000011)) return ExecuteArm_LDC_LDC2_literal(1); //v5
+			if (CHK(op1, _.b11110001, _.b11010001)) return ExecuteArm_LDC_LDC2_literal(2); //v5
+			if (CHK(op1, _.b11111011, _.b11000010)) return ExecuteArm_STC_STC2(1); //v5
+			if (CHK(op1, _.b11111001, _.b11001000)) return ExecuteArm_STC_STC2(2); //v5
+			if (CHK(op1, _.b11110001, _.b11010000)) return ExecuteArm_STC_STC2(3); //v5
+			if (op1 == _.b11000100) return ExecuteArm_MCRR_MCRR2(); //v6
+			if (op1 == _.b11000101) return ExecuteArm_MRRC_MRRC2(); //v6
+			if (CHK(op1, _.b11110000, _.b11100000) && op == 0) return ExecuteArm_CDP_CDP2(); //v5
+			if (CHK(op1, _.b11110001, _.b11100000) && op == 1) return ExecuteArm_MCR_MCR2(); //v5
+			if (CHK(op1, _.b11110001, _.b11100001) && op == 1) return ExecuteArm_MRC_MRC2(); //v5
+
+			return Execute_Unhandled("ExecuteArm_Unconditional");
+		}
+
+		uint ExecuteArm_Unconditional_Misc() { return Execute_Unhandled("ExecuteArm_Unconditional_Misc"); }
+		uint Execute_SRS_A1() { return Execute_Unhandled("ExecuteArm_SRS_A1"); }
+		uint Execute_RFE_A1() { return Execute_Unhandled("ExecuteArm_RFE_A1"); }
+		uint Execute_BL_BLX_immediate_A2()
+		{
+			//A8.6.23
+			uint imm24 = instruction & 0xFFFFFF;
+			uint H = _.BIT24(instruction);
+			int imm32 = SIGNEXTEND_24((imm24 << 2) | (H << 1));
+			return ExecuteCore_BL_BLX_immediate(Encoding.A2, EInstrSet.THUMB, imm32, true);
+		}
+
+
+
+		uint ExecuteArm_LDC_LDC2_immediate()
+		{
+			uint Rn = instruction & 0xF0000;
+			if (Rn == 0xF) { } //special handling for 0xF vs not 0xF
+			return Execute_Unhandled("ExecuteArm_LDC_LDC2_immediate");
+		}
+		uint ExecuteArm_LDC_LDC2_literal(int form) { return Execute_Unhandled("ExecuteArm_LDC_LDC2_literal"); }
+		uint ExecuteArm_STC_STC2(int form) { return Execute_Unhandled("ExecuteArm_STC_STC2"); }
+		uint ExecuteArm_MCRR_MCRR2() { return Execute_Unhandled("ExecuteArm_MCRR_MCRR2"); }
+		uint ExecuteArm_MRRC_MRRC2() { return Execute_Unhandled("ExecuteArm_MRRC_MRRC2"); }
+		uint ExecuteArm_CDP_CDP2() { return Execute_Unhandled("ExecuteArm_CDP_CDP2"); }
+		uint ExecuteArm_MCR_MCR2() { return Execute_Unhandled("ExecuteArm_MCR_MCR2"); }
+		uint ExecuteArm_MRC_MRC2() { return Execute_Unhandled("ExecuteArm_MRC_MRC2"); }
+	}
+
+}
\ No newline at end of file
diff --git a/BizHawk.Emulation/CPUs/ARM/ARM.ExecuteArm.cs b/BizHawk.Emulation/CPUs/ARM/ARM.ExecuteArm.cs
new file mode 100644
index 0000000000..bd859b15d9
--- /dev/null
+++ b/BizHawk.Emulation/CPUs/ARM/ARM.ExecuteArm.cs
@@ -0,0 +1,785 @@
+using System;
+using System.Diagnostics;
+using System.Text;
+using System.Runtime.InteropServices;
+
+namespace BizHawk.Emulation.CPUs.ARM
+{
+
+	partial class ARM
+	{
+		uint ExecuteArm()
+		{
+			_currentCondVal = CONDITION(instruction);
+			if (_currentCondVal == 0xF) return ExecuteArm_Unconditional();
+			bool pass = _ConditionPassed() || disassemble;
+			if (pass)
+			{
+				uint op1 = (instruction & 0x0E000000) >> 25;
+				uint op = (instruction & 0x10) >> 4;
+				switch (op1)
+				{
+					case _.b000:
+					case _.b001:
+						return ExecuteArm_DataProcessing();
+					case _.b010:
+						return ExecuteArm_LoadStore();
+					case _.b011:
+						if (op == 0) return ExecuteArm_LoadStore();
+						else return ExecuteArm_Media();
+					case _.b100:
+					case _.b101:
+						return ExecuteArm_BranchAndTransfer();
+					case _.b110:
+					case _.b111:
+						return ExecuteArm_SVCAndCP();
+					default:
+						throw new InvalidOperationException();
+				}
+			}
+			else
+				return 1;
+		}
+
+
+		Decoder decoder_ExecuteArm_LoadStore = new Decoder();
+		uint ExecuteArm_LoadStore()
+		{
+			//A5.3
+			//A5-19
+
+			decoder_ExecuteArm_LoadStore.Ensure(() => decoder_ExecuteArm_LoadStore
+				.d("A", 1).d("op1", 5).d("B", 1).d("Rn", 4)
+				.r("A==0 && op1 == #xx0x0 && op1 != #0x010", () => Execute_STR_immediate_A1())
+				.r("A==1 && op1 == #xx0x0 && op1 != #0x010 && B==0", () => Execute_Unhandled("STR (register) on page A8-386"))
+				.r("A==0 && op1 == #0x010", () => Execute_Unhandled("STRT on page A8-416"))
+				.r("A==1 && op1 == #0x010 && B==0", () => Execute_Unhandled("STRT on page A8-416"))
+				.r("A==0 && op1 == #xx0x1 && op1 != #0x011 && Rn != #1111", () => Execute_LDR_immediate_arm_A1())
+				.r("A==0 && op1 == #xx0x1 && op1 != #0x011 && Rn == #1111", () => ExecuteArm_LDR_literal_A1())
+				.r("A==1 && op1 == #xx0x1 && A != #0x011 && B==0", () => Execute_Unhandled("LDR (register) on page A8-124"))
+				.r("A==0 && op1 == #0x011", () => Execute_Unhandled("LDRT on page A8-176"))
+				.r("A==1 && op1 == #0x011 && B==0", () => Execute_Unhandled("LDRT on page A8-176"))
+				.r("A==0 && op1 == #xx1x0 && op1 != #0x110", () => Execute_Unhandled("STRB (immediate, ARM) on page A8-390"))
+				.r("A==1 && op1 == #xx1x0 && op1 != #0x110 && B==0", () => Execute_Unhandled("STRB (register) on page A8-392"))
+				.r("A==0 && op1 == #0x110", () => Execute_Unhandled("STRBT on page A8-394"))
+				.r("A==1 && op1 == #0x110 && B==0", () => Execute_Unhandled("STRBT on page A8-394"))
+				.r("A==0 && op1 == #xx1x1 && op1 != #0x111 && Rn != #1111", () => Execute_Unhandled("LDRB (immediate, ARM) on page A8-128"))
+				.r("A==0 && op1 == #xx1x1 && op1 != #0x111 && Rn == #1111", () => Execute_Unhandled("LDRB (literal) on page A8-130"))
+				.r("A==1 && op1 == #xx1x1 && op1 != #0x111 && B==0", () => Execute_Unhandled("LDRB (register) on page A8-132"))
+				.r("A==0 && op1 == #0x111", () => Execute_Unhandled("LDRBT on page A8-134"))
+				.r("A==1 && op1 == #0x111 && B==0", () => Execute_Unhandled("LDRBT on page A8-134"))
+				);
+
+			uint A = _.BIT25(instruction);
+			uint op1 = (instruction >> 20) & 0x1F;
+			uint B = _.BIT4(instruction);
+			uint Rn = Reg16(16);
+			decoder_ExecuteArm_LoadStore.Evaluate(A, op1, B, Rn);
+
+			return cycles;
+		}
+
+		uint Execute_LDR_immediate_arm_A1()
+		{
+			//A8.6.58 LDR (immediate, ARM)
+			Bit P = _.BIT24(instruction);
+			Bit U = _.BIT23(instruction);
+			Bit W = _.BIT21(instruction);
+			uint n = Reg16(16);
+			uint t = Reg16(12);
+			uint imm12 = instruction & 0xFFF;
+			if (n == _.b1111) throw new NotImplementedException("see LDR (literal");
+			if (P == 0 && W == 1) throw new NotImplementedException("see LDRT");
+			if (n == _.b1101 && P == 0 && U == 1 && W == 0 && imm12 == _.b000000000100)
+				return Execute_POP_A2();
+			uint imm32 = _ZeroExtend_32(imm12);
+			bool index = (P == 1);
+			bool add = (U == 1);
+			bool wback = (P == 0) || (W == 1);
+			if (wback && n == t) unpredictable = true;
+
+			return ExecuteCore_LDR_immediate_arm(Encoding.A1, t, imm32, n, index, add, wback);
+		}
+
+		uint Execute_POP_A2()
+		{
+			//A8.6.122 POP
+			uint t = Reg16(12);
+			uint regs = (uint)(1 << (int)t);
+			if (t == 13) unpredictable = true;
+			const bool UnalignedAllowed = true;
+			return ExecuteCore_POP(Encoding.A2, regs, UnalignedAllowed);
+		}
+
+		uint Execute_STR_immediate_A1()
+		{
+			//A8.6.194
+			Bit P = _.BIT24(instruction);
+			Bit U = _.BIT23(instruction);
+			Bit W = _.BIT21(instruction);
+			uint n = Reg16(16);
+			uint t = Reg16(12);
+			uint imm32 = instruction & 0xFFF;
+			if (P == 0 && W == 1) throw new NotImplementedException("see STRT");
+			if (n == _.b1101 && P == 1 && U == 0 && W == 1 && imm32 == _.b000000000100)
+				return Execute_PUSH_A2();
+			bool index = (P == 1);
+			bool add = (U == 1);
+			bool wback = (P == 0) || (W == 1);
+			if (wback && n == 16 || n == t) unpredictable = true;
+
+			return ExecuteCore_STR_immediate_arm(Encoding.A1, P, U, W, n, t, imm32, index, add, wback);
+		}
+
+		uint Execute_PUSH_A2()
+		{
+			//A8.6.123
+			uint t = Reg8(12);
+			bool UnalignedAllowed = true;
+			uint registers = (uint)(1 << (int)t);
+			if (t == 13) _FlagUnpredictable();
+			return ExecuteCore_PUSH(Encoding.A2, registers, UnalignedAllowed);
+		}
+
+		uint ExecuteArm_LDR_literal_A1()
+		{
+			//A8.6.59
+			//A8-122
+			uint t = Reg16(12);
+			uint imm32 = instruction & 0xFFF;
+			uint U = _.BIT23(instruction);
+			bool add = (U == 1);
+
+			return ExecuteCore_LDR_literal(Encoding.A1, t, imm32, add);
+		}
+
+
+		uint ExecuteArm_DataProcessing()
+		{
+			uint op = _.BIT25(instruction);
+			uint op1 = (instruction >> 20) & 0x1F;
+			uint op2 = (instruction >> 4) & 0xF;
+			switch (op)
+			{
+				case 0:
+					if (!CHK(op1, _.b11001, _.b10000))
+						if (CHK(op2, _.b0001, _.b0000)) return ExecuteArm_DataProcessing_Register();
+						else if (CHK(op2, _.b1001, _.b0001)) return Execute_Unhandled("data-processing (register-shifted register) on page A5-7");
+					if (CHK(op1, _.b11001, _.b10000))
+						if (CHK(op2, _.b1000, _.b0000)) return ExecuteArm_DataProcessing_Misc();
+						else if (CHK(op2, _.b1001, _.b1000)) return Execute_Unhandled("halfword multiply and multiply-accumulate on page A5-13");
+					if (CHK(op1, _.b10000, _.b00000) && op2 == _.b1001) return Execute_Unhandled("multiply and multiply-accumulate on page A5-12");
+					if (CHK(op1, _.b10000, _.b10000) && op2 == _.b1001) return ExecuteArm_SynchronizationPrimitives();
+					if (!CHK(op1, _.b10010, _.b00010))
+						if (op2 == _.b1011) return Execute_Unhandled("extra load/store instructions on page A5-14");
+						else if (CHK(op2, _.b1011, _.b1101)) return Execute_Unhandled("extra load/store instructions on page A5-14");
+					if (CHK(op1, _.b10010, _.b00010))
+						if (op2 == _.b1011) return Execute_Unhandled("extra load/store instructions (unprivileged) on page A5-15");
+						else if (CHK(op2, _.b1011, _.b1101)) return Execute_Unhandled("extra load/store instructions (unprivileged) on page A5-15");
+					throw new InvalidOperationException("unexpected decoder fail");
+				case 1:
+					if (!CHK(op1, _.b11001, _.b10000))
+						return ExecuteArm_DataProcessing_Immediate();
+					if (op1 == _.b10000) return Execute_Unhandled("16-bit immediate load (MOV (immediate on page A8-193) //v6T2");
+					if (op1 == _.b10100) return Execute_Unhandled("high halfword 16-bit immediate load (MOVT on page A8-200) //v6T2");
+					if (CHK(op1, _.b11011, _.b10010)) return Execute_Unhandled("MSR (immediate), and hints on page A5-17");
+					throw new InvalidOperationException("unexpected decoder fail");
+
+				default:
+					throw new InvalidOperationException("totally impossible decoder fail");
+			}
+		}
+
+		uint ExecuteArm_SynchronizationPrimitives()
+		{
+			uint op = (instruction >> 20) & 0xF;
+			switch (op)
+			{
+				case _.b0000:
+				case _.b0100: return Execute_Unhandled("ExecuteArm_SWP_SWPB();");
+				case _.b1000: return Execute_STREX_A1();
+				case _.b1001: return Execute_LDREX_A1();
+				case _.b1010: return Execute_Unhandled("ExecuteArm_STREXD();");
+				case _.b1011: return Execute_Unhandled("ExecuteArm_LDREXD();");
+				case _.b1100: return Execute_Unhandled("ExecuteArm_STREXB();");
+				case _.b1101: return Execute_Unhandled("ExecuteArm_LDREXB();");
+				case _.b1110: return Execute_Unhandled("ExecuteArm_STREXH();");
+				case _.b1111: return Execute_Unhandled("ExecuteArm_LDREXH();");
+				default: throw new InvalidOperationException("decoder fail");
+			}
+		}
+
+		uint Execute_STREX_A1()
+		{
+			//A8.6.202 STREX
+			uint n = Reg16(16);
+			uint d = Reg16(12);
+			uint t = Reg16(0);
+			const uint imm32 = 0;
+			if (d == 15 || t == 15 || n == 15) unpredictable = true;
+			if (d == n || d == t) unpredictable = true;
+			return ExecuteCore_STREX(Encoding.A1, d, n, t, imm32);
+		}
+
+		uint Execute_LDREX_A1()
+		{
+			//A8.6.69 LDREX
+			uint n = Reg16(16);
+			uint t = Reg16(12);
+			uint imm32 = 0;
+			if (t == 15 || n == 15) unpredictable = true;
+			return ExecuteCore_LDREX(Encoding.A1, n, t, imm32);
+		}
+
+		uint ExecuteArm_DataProcessing_Register()
+		{
+			//A5.2.1
+			uint op1 = (instruction >> 20) & 0x1F;
+			uint op2 = (instruction >> 7) & 0x1F;
+			uint op3 = (instruction >> 5) & 3;
+
+			switch (op1)
+			{
+				case _.b00000:
+				case _.b00001: return Execute_Unhandled("arm and reg");
+				case _.b00010:
+				case _.b00011: return Execute_Unhandled("arm eor reg");
+				case _.b00100:
+				case _.b00101: return Execute_Unhandled("arm sub reg");
+				case _.b00110:
+				case _.b00111: return Execute_Unhandled("arm rsb reg");
+				case _.b01000:
+				case _.b01001: return Execute_ADD_register_A1();
+				case _.b01010:
+				case _.b01011: return Execute_Unhandled("arm adc reg");
+				case _.b01100:
+				case _.b01101: return Execute_Unhandled("arm sbc reg");
+				case _.b01110:
+				case _.b01111: return Execute_Unhandled("arm rsc reg");
+				case _.b10001: return Execute_Unhandled("arm tst reg");
+				case _.b10011: return Execute_Unhandled("arm teq reg");
+				case _.b10101: return Execute_CMP_register_A1();
+				case _.b10111: return Execute_Unhandled("arm cmn reg");
+				case _.b11000:
+				case _.b11001: return Execute_Unhandled("arm orr reg");
+				case _.b11010:
+				case _.b11011:
+					if (op2 == _.b00000 && op3 == _.b00) return Execute_MOV_register_A1();
+					if (op2 != _.b00000 && op3 == _.b00) return Execute_LSL_immediate_A1();
+					if (op3 == _.b01) return Execute_LSR_immediate_A1();
+					if (op3 == _.b10) return Execute_Unhandled("arm asr imm");
+					if (op2 == _.b00000 && op3 == _.b11) return Execute_Unhandled("arm rrx");
+					if (op2 != _.b00000 && op3 == _.b11) return Execute_Unhandled("arm ror imm");
+					throw new InvalidOperationException("decode fail");
+				case _.b11100:
+				case _.b11101: return Execute_Unhandled("arm bic reg");
+				case _.b11110:
+				case _.b11111: return Execute_Unhandled("arm mvn reg");
+				default:
+					throw new InvalidOperationException("decode fail");
+			}
+		}
+
+		uint Execute_LSR_immediate_A1()
+		{
+			//A8.6.90
+			uint d = Reg16(12);
+			uint m = Reg16(0);
+			Bit S = _.BIT20(instruction);
+			bool setflags = (S == 1);
+			uint imm5 = (instruction >> 7) & 0x1F;
+			_DecodeImmShift(_.b01, imm5);
+			return ExecuteCore_LSR_immediate(Encoding.A1, d, m, setflags, shift_n);
+		}
+
+		uint Execute_LSL_immediate_A1()
+		{
+			//A8.6.87
+			Bit S = _.BIT20(instruction);
+			uint d = Reg16(12);
+			uint imm5 = (instruction >> 7) & 0x1F;
+			uint m = Reg16(0);
+			Debug.Assert(imm5 != _.b00000); //should have been prevented by decoder
+			bool setflags = (S == 1);
+			_DecodeImmShift(_.b00, imm5);
+			return ExecuteCore_LSL_immediate(Encoding.A1, d, m, setflags, shift_n);
+		}
+
+		uint Execute_MOV_register_A1()
+		{
+			//A8.6.97
+			Bit S = _.BIT20(instruction);
+			uint d = Reg16(12);
+			uint m = Reg16(0);
+
+			if (d == _.b1111 && S == 1) throw new NotSupportedException("SEE SUBS PC, LR and related instructions");
+			bool setflags = (S == 1);
+			return ExecuteCore_MOV_register(Encoding.A1, d, m, setflags);
+		}
+
+		uint Execute_ADD_register_A1()
+		{
+			//A8.6.6 ADD (register)
+			uint m = Reg16(0);
+			uint type = (instruction >> 4) & 3;
+			uint imm5 = (instruction >> 7) & 0x1F;
+			uint d = Reg16(12);
+			uint n = Reg16(16);
+			Bit s = _.BIT20(instruction);
+			bool setflags = (s == 1);
+			if (d == _.b1111 && s == 1) { throw new InvalidOperationException("see SUBS PC, LR and related instructions;"); }
+			if (n == _.b1101) { throw new InvalidOperationException("see ADD (SP plus register);"); }
+			_DecodeImmShift(type, imm5);
+
+			return ExecuteCore_ADD_register(Encoding.A1, m, d, n, setflags, shift_t, shift_n);
+		}
+
+		uint Execute_CMP_register_A1()
+		{
+			//A8.6.36
+			//A8-82
+			uint n = Reg16(16);
+			uint imm5 = (instruction >> 7) & 0x1F;
+			uint m = Reg16(0);
+			uint type = (instruction >> 5) & 3;
+			_DecodeImmShift(type, imm5);
+
+			if (disassemble)
+				return DISNEW("CMP<c>", "<Rn!>,<Rm!><,shift>", n, m, shift_t, shift_n);
+
+			uint shifted = _Shift(r[m], shift_t, shift_n, APSR.C);
+			_AddWithCarry32(r[n], ~shifted, 1);
+			APSR.N = _.BIT31(alu_result_32);
+			APSR.Z = alu_result_32 == 0;
+			APSR.C = alu_carry_out;
+			APSR.V = alu_overflow;
+
+			return 0;
+		}
+
+		uint ExecuteArm_DataProcessing_Immediate()
+		{
+			//A5.2.3
+			uint op = (instruction >> 20) & 0x1F;
+			uint Rn = Reg16(16);
+			switch (op)
+			{
+				case _.b00000:
+				case _.b00001: return Execute_Unhandled("arm and imm");
+				case _.b00010:
+				case _.b00011: return Execute_Unhandled("arm eor imm");
+				case _.b00100:
+				case _.b00101:
+					if (Rn != _.b1111) return Execute_SUB_immediate_arm_A1();
+					else return Execute_Unhandled("arm adr");
+				case _.b00110:
+				case _.b00111: return Execute_Unhandled("arm rsb imm");
+				case _.b01000:
+				case _.b01001:
+					if (Rn != _.b1111) return Execute_ADD_immedate_arm_A1();
+					else return Execute_Unhandled("arm adr");
+				case _.b01010:
+				case _.b01011: return Execute_Unhandled("arm adc imm");
+				case _.b01100:
+				case _.b01101: return Execute_Unhandled("arm sbc imm");
+				case _.b01110:
+				case _.b01111: return Execute_Unhandled("arm rsc imm");
+				case _.b10000:
+				case _.b10010:
+				case _.b10100:
+				case _.b10110: return ExecuteArm_DataProcessing_Misc_Imm();
+				case _.b10001: return Execute_Unhandled("arm tst imm");
+				case _.b10011: return Execute_Unhandled("arm teq imm");
+				case _.b10101: return Execute_CMP_immediate_A1();
+				case _.b10111: return Execute_Unhandled("arm cmn imm");
+				case _.b11000:
+				case _.b11001: return Execute_ORR_immediate_A1();
+				case _.b11010:
+				case _.b11011: return Execute_MOV_immediate_A1();
+				case _.b11100:
+				case _.b11101: return Execute_Unhandled("arm bic imm");
+				case _.b11110:
+				case _.b11111: return Execute_Unhandled("arm mvn imm");
+				default: throw new InvalidOperationException("decoder fail");
+			}
+		}
+
+		uint Execute_SUB_immediate_arm_A1()
+		{
+			//A8.6.212
+			Bit S = _.BIT20(instruction);
+			uint n = Reg16(16);
+			uint d = Reg16(12);
+			uint imm12 = instruction & 0xFFF;
+
+			if (n == _.b1111 && S == 0) throw new NotImplementedException("SEE ADR");
+			if (n == _.b1101) throw new NotImplementedException("SEE SUB (SP minus immediate");
+			if (n == _.b1111 && S == 1) throw new NotImplementedException("SEE SUBS PC, LR and related instructions");
+			bool setflags = (S == 1);
+			uint imm32 = _ARMExpandImm(imm12);
+			return ExecuteCore_SUB_immediate_arm(Encoding.A1, setflags, n, d, imm32);
+		}
+
+		uint Execute_ADD_immedate_arm_A1()
+		{
+			Bit S = _.BIT20(instruction);
+			uint n = Reg16(16);
+			uint d = Reg16(12);
+			uint imm12 = instruction & 0xFFF;
+
+			if (n == _.b1111 && S == 0) { throw new NotImplementedException("SEE ADR"); }
+			if (n == _.b1101) return Execute_ADD_SP_plus_immediate_A1();
+			if (d == _.b1111 && S == 1) throw new NotImplementedException("SEE SUBS PC, LR and related instructions");
+			bool setflags = (S == 1);
+			uint imm32 = _ARMExpandImm(imm12);
+
+			return ExecuteCore_ADD_immediate_arm(Encoding.A1, setflags, n, d, imm32);
+		}
+
+		uint Execute_ADD_SP_plus_immediate_A1()
+		{
+			uint d = Reg16(12);
+			Bit S = _.BIT20(instruction);
+			uint imm12 = instruction & 0xFFF;
+			if (d == _.b1111 && S == 1) throw new NotImplementedException("SEE SUBS PC, LR and related instructions");
+			bool setflags = (S == 1);
+			uint imm32 = _ARMExpandImm(imm12);
+
+			return ExecuteCore_ADD_SP_plus_immedate(Encoding.A1, d, setflags, imm32);
+		}
+
+		uint Execute_CMP_immediate_A1()
+		{
+			//A8.6.35
+			uint Rn = Reg16(16);
+			uint imm12 = instruction & 0xFFF;
+			uint imm32 = _ARMExpandImm(imm12);
+			return ExecuteCore_CMP_immediate(Encoding.A1, Rn, imm32);
+		}
+
+		uint Execute_ORR_immediate_A1()
+		{
+			//A8.6.113
+			Bit S = _.BIT20(instruction);
+			uint n = Reg16(16);
+			uint d = Reg16(12);
+			uint imm12 = instruction & 0xFFF;
+			Debug.Assert(!(d == _.b1111 && S == 1), "SEE SUBS PC, LR and related instructions");
+			bool setflags = (S == 1);
+			uint imm32;
+			Bit carry;
+			_ARMExpandImm_C(imm12, APSR.C, out imm32, out carry);
+			return ExecuteCore_ORR_immediate(Encoding.A1, n, d, setflags, imm32, carry);
+		}
+
+		uint Execute_MOV_immediate_A1()
+		{
+			//A8.6.96
+			uint Rd = Reg16(12);
+			uint S = _.BIT20(instruction);
+			uint imm12 = instruction & 0xFFF;
+			if (Rd == _.b1111 && S == 1)
+				throw new InvalidOperationException("see subs pc, lr and related instructions");
+			bool setflags = (S == 1);
+			uint imm32;
+			Bit carry;
+			_ARMExpandImm_C(imm12, APSR.C, out imm32, out carry);
+			return ExecuteCore_MOV_immediate(Encoding.A1, Rd, setflags, imm32, carry);
+		}
+
+		uint ExecuteArm_DataProcessing_Misc_Imm()
+		{
+			//A5-4
+			//TODO
+			return Execute_Unhandled("ExecuteArm_DataProcessing_Misc_Imm");
+		}
+
+		uint ExecuteArm_DataProcessing_Misc()
+		{
+			//A5.2.12
+			uint op = (instruction >> 21) & 0x3;
+			uint op1 = (instruction >> 16) & 0xF;
+			uint op2 = (instruction >> 4) & 0x7;
+
+			switch (op2)
+			{
+				case _.b000:
+					switch (op)
+					{
+						case _.b00:
+						case _.b10:
+							return Execute_Unhandled("MRS");
+						case _.b01:
+							switch (op1)
+							{
+								case _.b0000:
+								case _.b0100:
+								case _.b1000:
+								case _.b1100: return Execute_Unhandled("MSR (register) application level");
+								case _.b0001:
+								case _.b0101:
+								case _.b1001:
+								case _.b1101:
+								case _.b0010:
+								case _.b0011:
+								case _.b0110:
+								case _.b0111:
+								case _.b1010:
+								case _.b1011:
+								case _.b1110:
+								case _.b1111:
+									return Execute_Unhandled("MSR (register) system level");
+								default:
+									throw new InvalidOperationException("decoder fail");
+							}
+						case _.b11:
+							return Execute_Unhandled("MSR (register) system level");
+						default:
+							throw new InvalidOperationException("decoder fail");
+					}
+				case _.b001:
+					switch (op)
+					{
+						case _.b01: return ExecuteArm_BX_A1();
+						case _.b11: return Execute_Unhandled("ExecuteArm_CLZ");
+						default:
+							return Execute_Undefined();
+					}
+				case _.b010:
+					if (op == _.b01) return Execute_Unhandled("BXJ");
+					else return Execute_Undefined();
+				case _.b011:
+					if (op == _.b01) return Execute_Unhandled("BLX (register) on page A8-60");
+					else return Execute_Undefined();
+				case _.b100: return Execute_Undefined();
+				case _.b101: return Execute_Unhandled("saturating addition and subtraction on page A5-13");
+				case _.b110: return Execute_Undefined();
+				case _.b111:
+					switch (op)
+					{
+						case _.b01: return Execute_Unhandled("BKPT on page A8-56");
+						case _.b11: return Execute_Unhandled("SMC/SMI on page B6-18 //sec.ext");
+						default: return Execute_Undefined();
+					}
+				default:
+					throw new InvalidOperationException("decoder fail");
+			} //switch(op2)
+		}
+
+		uint ExecuteArm_BX_A1()
+		{
+			//A8-62
+			//A8.6.25
+			uint Rm = Reg16(0);
+			if (disassemble)
+				return DIS("BX/c/", "/r0/", Rm);
+			uint m = r[Rm];
+			_BXWritePC(m);
+			return 1;
+		}
+
+		uint ExecuteArm_Media() { return Execute_Unhandled("ExecuteArm_Media"); }
+
+		Decoder decoder_ExecuteArm_BranchAndTransfer = new Decoder();
+		uint ExecuteArm_BranchAndTransfer()
+		{
+			decoder_ExecuteArm_BranchAndTransfer.Ensure(() => decoder_ExecuteArm_BranchAndTransfer
+				.d("op", 6).d("R", 1).d("Rn", 4)
+				.r("op == #0000x0", () => Execute_Unhandled("STMDA/STMED on page A8-376"))
+				.r("op == #0000x1", () => Execute_Unhandled("LDMDA/LDMFA on page A8-112"))
+				.r("op == #0010x0", () => Execute_STM_STMIA_STMEA_A1())
+				.r("op == #001001", () => Execute_Unhandled("LDM/LDMIA/LDMFD on page A8-110"))
+				.r("op == #001011 && Rn != #1101", () => Execute_Unhandled("LDM/LDMIA/LDMFD on page A8-110"))
+				.r("op == #001011 && Rn == #1101", () => Execute_POP_A1())
+				.r("op == #010000", () => Execute_Unhandled("STMDB/STMFD on page A8-378"))
+				.r("op == #010010 && Rn != #1101", () => Execute_Unhandled("STMDB/STMFD on page A8-378"))
+				.r("op == #010010 && Rn == #1101", () => Execute_PUSH_A1())
+				.r("op == #0100x1", () => Execute_Unhandled("LDMDB/LDMEA on page A8-114"))
+				.r("op == #0110x0", () => Execute_Unhandled("STMIB/STMFA on page A8-380"))
+				.r("op == #0110x1", () => Execute_Unhandled("LDMIB/LDMED on page A8-116"))
+				.r("op == #0xx1x0", () => Execute_Unhandled("STM (user registers) on page B6-22"))
+				.r("op == #0xx1x1 && R==0", () => Execute_Unhandled("LDM (user registers on page B6-5"))
+				.r("op == #0xx1x1 && R==1", () => Execute_Unhandled("LDM (exception return) on page B6-5"))
+				.r("op == #10xxxx", () => Execute_B_A1())
+				.r("op == #11xxxx", () => Execute_BL_A1())
+				);
+
+			uint op = (instruction >> 20) & 0x3F;
+			uint Rn = Reg16(16);
+			uint R = _.BIT15(instruction);
+
+			decoder_ExecuteArm_BranchAndTransfer.Evaluate(op, R, Rn);
+
+			return 1;
+		}
+
+
+		uint Execute_POP_A1()
+		{
+			uint register_list = instruction & 0xFFFF;
+			if (_.BitCount(register_list) < 2) return Execute_LDM_LDMIA_LDMFD_A1();
+			bool UnalignedAllowed = false;
+			return ExecuteCore_POP(Encoding.A1, register_list, UnalignedAllowed);
+		}
+
+		uint Execute_PUSH_A1()
+		{
+			uint register_list = instruction & 0xFFFF;
+			if (_.BitCount(register_list) < 2) return Execute_STMDB_STMFD_A1();
+			bool UnalignedAllowed = false;
+			return ExecuteCore_PUSH(Encoding.A1, register_list, UnalignedAllowed);
+		}
+
+		uint Execute_LDM_LDMIA_LDMFD_A1()
+		{
+			//A8.6.53 LDM/LDMIA/LDMFD
+			Bit W = _.BIT21(instruction);
+			uint n = Reg16(16);
+			uint register_list = instruction & 0xFFFF;
+			bool wback = (W == 1);
+			if (n == 15 || _.BitCount(register_list) < 1) unpredictable = true;
+			if (wback && _.BITN((int)n, register_list) == 1 && _ArchVersion() >= 7) unpredictable = true;
+			return ExecuteCore_LDM_LDMIA_LDMFD(Encoding.A1, wback, n, register_list);
+		}
+
+
+		uint Execute_STM_STMIA_STMEA_A1()
+		{
+			//A8.6.189 STM/STMIA/STMEA
+			Bit W = _.BIT21(instruction);
+			uint n = Reg16(16);
+			uint register_list = instruction & 0xFFFF;
+			bool wback = W == 1;
+			if (n == 15 || _.BitCount(register_list) < 1) unpredictable = true;
+			return ExecuteCore_STM_STMIA_STMEA(Encoding.A1, wback, n, register_list);
+		}
+
+		uint Execute_STMDB_STMFD_A1()
+		{
+			//A8.6.191 STMDB/STMFD
+			Bit W = _.BIT21(instruction);
+			uint n = Reg16(16);
+			uint register_list = instruction & 0xFFFF;
+			if (W == 1 && n == _.b1101 && _.BitCount(register_list) >= 2) return Execute_PUSH_A1();
+			bool wback = W == 1;
+			if (n == 15 || _.BitCount(register_list) < 1) unpredictable = true;
+			return ExecuteCore_STMDB_STMFD(Encoding.A1, wback, n, register_list);
+		}
+
+		uint Execute_BL_A1()
+		{
+			//A8.6.23
+			//A8-58
+			uint imm24 = instruction & 0xFFFFFF;
+			int imm32 = _SignExtend_32(26, imm24 << 2);
+			return ExecuteCore_BL_BLX_immediate(Encoding.A1, EInstrSet.ARM, imm32, false);
+		}
+
+		uint Execute_B_A1()
+		{
+			uint imm24 = instruction & 0xFFFFFF;
+			int imm32 = _SignExtend_32(26, imm24 << 2);
+
+			return ExecuteCore_B(Encoding.A1, imm32);
+		}
+
+		Decoder Decoder_ExecuteArm_SVCAndCP = new Decoder();
+		uint ExecuteArm_SVCAndCP()
+		{
+			//A5.6 Supervisor Call, and coprocessor instructions
+
+			Decoder_ExecuteArm_SVCAndCP.Ensure(() => Decoder_ExecuteArm_SVCAndCP
+				.d("op1", 6).d("op", 1).d("coproc_special", 1).d("rn_is_15", 1)
+				.r("op1==#0xxxxx && op1!=#000x0x && coproc_special==#1", () => Execute_Unhandled("ExecuteArm_SIMD_VFP_LoadStore"))
+				.r("op1==#0xxxx0 && op1!=#000x0x && coproc_special==#0", () => Execute_Unhandled("STC,STC2"))
+				.r("op1==#0xxxx1 && op1!=#000x0x && coproc_special==#0 && rn_is_15==#0", () => Execute_Unhandled("LDC,LDC2(immediate)"))
+				.r("op1==#0xxxx1 && op1!=#000x0x && coproc_special==#0 && rn_is_15==#1", () => Execute_Unhandled("LDC,LDC2(literal)"))
+				.r("op1==#00000x", () => Execute_Undefined())
+				.r("op1==#00010x && coproc_special==#1", () => Execute_Unhandled("ExecuteArm_SIMD_VFP_64bit_xfer"))
+				.r("op1==#000100 && coproc_special==#0", () => Execute_Unhandled("MCRR,MCRR2"))
+				.r("op1==#000101 && coproc_special==#0", () => Execute_Unhandled("MRRC,MRRC2"))
+				.r("op1==#10xxxx && op==0 && coproc_special==#1", () => Execute_Unhandled("VFP data-processing on page A7-24"))
+				.r("op1==#10xxxx && op==0 && coproc_special==#0", () => Execute_Unhandled("CDP,CDP2 on page A8-68"))
+				.r("op1==#10xxxx && op==1 && coproc_special==#1", () => ExecuteArm_ShortVFPTransfer())
+				.r("op1==#10xxx0 && op==1 && coproc_special==#0", () => Execute_Unhandled("MCR,MCR2 on pageA8-186"))
+				.r("op1==#10xxx1 && op==1 && coproc_special==#0", () => Execute_MRC_MRC2_A1())
+				.r("op1==#110000", () => Execute_SVC_A1())
+				);
+
+			uint op1 = (instruction >> 20) & 0x3F;
+			uint Rn = Reg16(16);
+			uint coproc = (instruction >> 8) & 0xF;
+			uint op = _.BIT4(instruction);
+			uint coproc_special = (coproc == _.b1010 || coproc == _.b1011) ? 1U : 0U;
+			uint rn_is_15 = (Rn == 15) ? 1U : 0U;
+
+			Decoder_ExecuteArm_SVCAndCP.Evaluate(op1, op, coproc_special, rn_is_15);
+			return 1;
+		}
+
+		uint Execute_MRC_MRC2_A1()
+		{
+			//ignoring admonition to see "advanced SIMD and VFP" which has been handled by decode earlier
+			uint t = Reg16(12);
+			uint cp = Reg16(8);
+			uint opc1 = Reg8(21);
+			uint crn = Reg16(16);
+			uint opc2 = Reg8(5);
+			uint crm = Reg16(0);
+			if (t == 13 && _CurrentInstrSet() != EInstrSet.ARM) unpredictable = true;
+			return ExecuteCore_MRC_MRC2(Encoding.A1, cp, opc1, t, crn, crm, opc2);
+		}
+
+		Decoder Decoder_ExecuteArm_ShortVFPTransfer = new Decoder();
+		uint ExecuteArm_ShortVFPTransfer()
+		{
+			//A7.8
+			//A7-31
+
+			Decoder_ExecuteArm_ShortVFPTransfer.Ensure(() => Decoder_ExecuteArm_ShortVFPTransfer
+				.d("A", 3).d("L", 1).d("C", 1).d("B", 2)
+				.r("L==0 && C==0 && A==#000", () => Execute_Unhandled("VMOV (between ARM core register and single-precision register) on page A8-648"))
+				.r("L==0 && C==0 && A==#111", () => ExecuteArm_VMSR_A1())
+				.r("L==0 && C==1 && A==#0xx", () => Execute_Unhandled("VMOV (ARM core register to scalar) on page A8-644"))
+				.r("L==0 && C==1 && A==#1xx && B==#0x", () => Execute_Unhandled("VDUP (ARM core register) on page A8-594"))
+				.r("L==1 && C==0 && A==#000", () => Execute_Unhandled("VMOV (between ARM core register and single-precision register) on page A8-648"))
+				.r("L==1 && C==0 && A==#111", () => Execute_Unhandled("VMRS on page A8-658 or page B6-27"))
+				.r("L==1 && C==1", () => Execute_Unhandled("VMOV (scalar to ARM core register) on page A8-646"))
+				);
+
+			uint A = (instruction >> 21) & _.b111;
+			uint L = _.BIT20(instruction);
+			uint C = _.BIT8(instruction);
+			uint B = (instruction >> 5) & _.b11;
+
+			Decoder_ExecuteArm_ShortVFPTransfer.Evaluate(A, L, C, B);
+			return 1;
+		}
+
+		uint ExecuteArm_VMSR_A1()
+		{
+			uint t = Reg16(12);
+			if (t == 15 || (t == 13 && _CurrentInstrSet() != EInstrSet.ARM)) return _UNPREDICTABLE();
+
+			if (disassemble)
+				if (nstyle)
+					return DISNEW("FMXR<c>", "<fpscr>,<Rt>", t);
+				else
+					return DISNEW("VMSR<c>", "<fpscr>, <Rt>", t);
+
+			return ExecuteCore_VMSR(t);
+		}
+
+		uint Execute_SVC_A1()
+		{
+			//A8.6.218
+			//A8-430
+			uint imm24 = instruction & 0xFFFFFF;
+			uint imm32 = imm24;
+
+			return ExecuteCore_SVC(Encoding.A1, imm32);
+		}
+
+
+	} //class ARM11
+}
\ No newline at end of file
diff --git a/BizHawk.Emulation/CPUs/ARM/ARM.ExecuteCore.cs b/BizHawk.Emulation/CPUs/ARM/ARM.ExecuteCore.cs
new file mode 100644
index 0000000000..c921f4c8f6
--- /dev/null
+++ b/BizHawk.Emulation/CPUs/ARM/ARM.ExecuteCore.cs
@@ -0,0 +1,998 @@
+using System;
+using System.Diagnostics;
+
+namespace BizHawk.Emulation.CPUs.ARM
+{
+
+	partial class ARM
+	{
+		//A8.6.4 ADD
+		uint ExecuteCore_ADD_immediate_thumb(Encoding encoding, uint n, uint d, bool setflags, uint imm32)
+		{
+			if (disassemble)
+				if (disopt.showExplicitAccumulateRegisters || n != d)
+					return DISNEW("ADD<s?><c?>", "<Rd!>, <Rn!>, #<const>", setflags, false, d, n, imm32);
+				else
+					return DISNEW("ADD<s?><c?>", "<Rd!>, #<const>", setflags, false, d, imm32);
+
+			_AddWithCarry32(r[n], imm32, 0);
+			r[d] = alu_result_32;
+			if (setflags)
+			{
+				APSR.N = _.BIT31(alu_result_32);
+				APSR.Z = _IsZeroBit(alu_result_32);
+				APSR.C = alu_carry_out;
+				APSR.V = alu_overflow;
+			}
+
+			return 1;
+		}
+
+		//A8.6.5 ADD (immediate, ARM)
+		uint ExecuteCore_ADD_immediate_arm(Encoding encoding, bool setflags, uint n, uint d, uint imm32)
+		{
+			if (disassemble)
+				if (disopt.showExplicitAccumulateRegisters || n != d)
+					return DISNEW("ADD<s?><c>", "<rd!>, <rn!>, #<const>", setflags, d, n, imm32);
+				else
+					return DISNEW("ADD<s?><c>", "<rd!>, #<const>", setflags, d, imm32);
+
+			_AddWithCarry32(r[n], imm32, 0);
+			if (d == 15)
+				_ALUWritePC(alu_result_32); //"setflags is always FALSE here"
+			else
+			{
+				r[d] = alu_result_32;
+				if (setflags)
+				{
+					APSR.N = _.BIT31(alu_result_32);
+					APSR.Z = _IsZeroBit(alu_result_32);
+					APSR.C = alu_carry_out;
+					APSR.V = alu_overflow;
+				}
+			}
+
+			return 1;
+		}
+
+		//A8.6.6 ADD (register)
+		uint ExecuteCore_ADD_register(Encoding encoding, uint m, uint d, uint n, bool setflags, SRType shift_t, int shift_n)
+		{
+			if (disassemble)
+				return DISNEW("ADD<s?><c>", "<Rd!>, <Rn!>, <Rm!><{, shift}>", setflags, d, n, m, shift_t, shift_n);
+
+			uint shifted = _Shift(r[m], shift_t, shift_n, APSR.C);
+			_AddWithCarry32(r[n], shifted, 0);
+			if (d == 15) _ALUWritePC(alu_result_32);
+			else
+			{
+				r[d] = alu_result_32;
+				if (setflags)
+				{
+					APSR.N = _.BIT31(alu_result_32);
+					APSR.Z = _IsZeroBit(alu_result_32);
+					APSR.C = alu_carry_out;
+					APSR.V = alu_overflow;
+				}
+			}
+			return 0;
+		}
+
+		//A8.6.8 ADD (SP plus immediate)
+		uint ExecuteCore_ADD_SP_plus_immedate(Encoding encoding, uint d, bool setflags, uint imm32)
+		{
+			if (disassemble)
+				return DISNEW("ADD<s?><c>", "<rd!>, <sp!>, #<const>", setflags, d, imm32);
+
+			if (setflags && d == 15) throw new NotImplementedException("see SUBS PC, LR and related instruction on page B6-25");
+			//addendum about !s && d==PC is correctly handled already by writing pseudocode
+			_AddWithCarry32(SP, imm32, 0);
+			if (d == 15)
+			{
+				Debug.Assert(!setflags);
+				_ALUWritePC(alu_result_32); //"can only occur for ARM encoding. setflags is always FALSE here"
+			}
+			else
+			{
+				r[d] = alu_result_32;
+				if (setflags)
+				{
+					APSR.N = _.BIT31(alu_result_32);
+					APSR.Z = _IsZeroBit(alu_result_32);
+					APSR.C = alu_carry_out;
+					APSR.V = alu_overflow;
+				}
+			}
+
+			return 1;
+		}
+
+		//A8.6.10 ADR
+		uint ExecuteCore_ADR(Encoding encoding, uint d, uint imm32, bool add)
+		{
+			uint result;
+			if (add)
+				result = _Align(PC, 4) + imm32;
+			else result = _Align(PC, 4) - imm32;
+
+			if (disassemble)
+				if (nstyle)
+					return DIS("ADD", "/r0/,pc,/imm8_1/ ; maybe MOV rX,pc", d, imm32);
+				else return DIS("ADR", "/r0/, /label1/ ; maybe MOV rX,pc", d, result);
+
+			if (d == 15)
+				_ALUWritePC(result);
+			else r[d] = result;
+			return 1;
+		}
+
+		//A8.6.14 ASR (immediate)
+		uint ExecuteCore_ASR_immediate(Encoding encoding, uint d, uint m, bool setflags, int shift_n)
+		{
+			if (disassemble)
+				return DISNEW("ASR<s?><c>", "<{rd!~rm, }><rm!>, #<imm>", setflags, d, m, m, shift_n);
+
+			uint result;
+			Bit carry;
+			_Shift_C(r[m], SRType.ASR, shift_n, APSR.C, out result, out carry);
+			if (d == 15)
+				_ALUWritePC(result);
+			else
+			{
+				r[d] = result;
+				if (setflags)
+				{
+					APSR.N = _.BIT31(result);
+					APSR.Z = _IsZeroBit(result);
+					APSR.C = carry;
+					//APSR.V unchanged
+				}
+			}
+
+			return 0;
+		}
+
+		//A8.6.16 B
+		uint ExecuteCore_B(Encoding encoding, int imm32)
+		{
+			uint label = (uint)((int)PC + imm32);
+
+			if (disassemble)
+				return DISNEW("B<c>", "<label>", label);
+
+			//make sure to check conditions here since this can get called from thumb
+			if (_ConditionPassed())
+				_BranchWritePC(label);
+
+			return 1;
+		}
+
+		//A8.6.23 BL, BLX (immediate)
+		uint ExecuteCore_BL_BLX_immediate(Encoding encoding, EInstrSet targetInstrSet, int imm32, bool blx)
+		{
+			uint targetAddress;
+			if (targetInstrSet == EInstrSet.ARM)
+				targetAddress = (uint)((int)_Align(PC, 4) + imm32);
+			else
+				targetAddress = (uint)((int)PC + imm32);
+
+			if (disassemble)
+				return DISNEW(blx ? "blx<c?>" : "bl<c?>", "<label>", (encoding == Encoding.A1), targetAddress);
+
+			if (_CurrentInstrSet() == EInstrSet.ARM)
+				LR = PC - 4;
+			else LR = (uint)((PC & ~1) | 1);
+
+			_SelectInstrSet(targetInstrSet);
+			_BranchWritePC(targetAddress);
+			return 1;
+		}
+
+		//A8.6.24 BLX (register)
+		uint ExecuteCore_BLX_register(Encoding encoding, uint m)
+		{
+			if (disassemble)
+				return DISNEW("BLX<c>", "<rm!>", m);
+
+			//NEXT_INSTR_ADDR not to be confused with other variables in our core emulator
+			uint target = r[m];
+			if (_CurrentInstrSet() == EInstrSet.ARM)
+			{
+				uint NEXT_INSTR_ADDR = PC - 4;
+				LR = NEXT_INSTR_ADDR;
+			}
+			else
+			{
+				uint NEXT_INSTR_ADDR = PC - 2;
+				LR = (NEXT_INSTR_ADDR & 0xFFFFFFFE) | 1;
+			}
+			_BXWritePC(target);
+
+			return 1;
+		}
+
+		//A8.6.35 CMP (immediate)
+		uint ExecuteCore_CMP_immediate(Encoding encoding, uint n, uint imm32)
+		{
+			if (disassemble)
+				return DISNEW("CMP<c>", "<Rn!>, #<const>", n, imm32);
+
+			_AddWithCarry32(r[n], ~imm32, 1);
+			APSR.N = _.BIT31(alu_result_32);
+			APSR.Z = _IsZeroBit(alu_result_32);
+			APSR.C = alu_carry_out;
+			APSR.V = alu_overflow;
+
+			return 0;
+		}
+
+		//A8.6.36 CMP (register)
+		uint ExecuteCore_CMP_register(Encoding encoding, uint n, uint m, SRType shift_t, int shift_n)
+		{
+			Debug.Assert(!(EncodingT(encoding) && n == 15)); //?? not in pseudocode but sort of suggested by addenda
+
+			if (disassemble)
+				return DISNEW("CMP<c>", "<rn!>, <rm!><{, shift}>", n, m, shift_t, shift_n);
+
+			uint shifted = _Shift(r[m], shift_t, shift_n, APSR.C);
+			_AddWithCarry32(r[n], ~shifted, 1);
+			APSR.N = _.BIT31(alu_result_32);
+			APSR.Z = _IsZeroBit(alu_result_32);
+			APSR.C = alu_carry_out;
+			APSR.V = alu_overflow;
+
+			return 1;
+		}
+
+		//A8.6.39 CPY
+		uint ExecuteCore_CPY()
+		{
+			//(this space intentionally blank. instruction is obsoleted)
+			return 0;
+		}
+
+		//A8.6.45 EOR (register)
+		uint ExecuteCore_EOR_register(Encoding encoding, uint m, uint d, uint n, bool setflags, SRType shift_t, int shift_n)
+		{
+			if (disassemble)
+				return DISNEW("EOR<s?><c>", "<{rd!~rn, }><rn!>, <rm!><{, shift}>", setflags, d, n, n, m, shift_t, shift_n);
+
+			uint shifted;
+			Bit carry;
+			_Shift_C(r[m], shift_t, shift_n, APSR.C, out shifted, out carry);
+			uint result = r[n] ^ shifted;
+			if (d == 15)
+				_ALUWritePC(result);
+			else
+			{
+				r[d] = result;
+				if (setflags)
+				{
+					APSR.N = _.BIT31(result);
+					APSR.Z = _IsZeroBit(result);
+					APSR.C = carry;
+					//APSR.V unchanged
+				}
+			}
+
+			return 1;
+		}
+
+		//A8.6.53 LDM/LDMIA/LDMFD
+		uint ExecuteCore_LDM_LDMIA_LDMFD(Encoding encoding, bool wback, uint n, uint registers)
+		{
+			//many ways to write this...
+			//I chose LDMIA to match rvct
+			if (disassemble)
+				return DISNEW("LDMIA<c>", "<Rn!><{wback!}>, <registers>", n, wback, registers);
+
+			_NullCheckIfThumbEE(n);
+			uint bitcount = _.BitCount(registers);
+			uint address = r[n];
+			for (int i = 0; i <= 14; i++)
+				if (_.BITN(i, registers) == 1)
+				{
+					r[i] = MemA_Read32(address);
+					address += 4;
+				}
+			if (_.BIT15(registers) == 1)
+				_LoadWritePC(MemA_Read32(address));
+			if (wback && _.BITN((int)n, registers) == 0) r[n] = r[n] + 4 * bitcount;
+			if (wback && _.BITN((int)n, registers) == 1) r[n] = (uint)_UNKNOWN(32, r[n] + 4 * bitcount);
+
+			return 0;
+		}
+
+		//A8.6.57 LDR (immediate, thumb)
+		uint ExecuteCore_LDR_immediate_thumb(Encoding encoding, uint t, uint imm32, uint n, bool index, bool add, bool wback)
+		{
+			if (disassemble)
+				return Disassemble_LDR_STR_immediate("LDR", t, imm32, n, index, add, wback);
+
+			_NullCheckIfThumbEE(n);
+			uint offset_addr, address;
+			if (add) offset_addr = r[n] + imm32; else offset_addr = r[n] - imm32;
+			if (index) address = offset_addr; else address = r[n];
+			uint data = MemU_Read32(address);
+			if (wback) r[n] = offset_addr;
+			if (t == 15)
+			{
+				if ((address & 3) == 0) _LoadWritePC(data); else _UNPREDICTABLE();
+			}
+			else if (_UnalignedSupport() || (address & 3) == 0)
+				r[t] = data;
+			else r[t] = (uint)_UNKNOWN(32, data);
+
+			return 0;
+		}
+
+		//A8.6.58 LDR (immediate, arm)
+		uint ExecuteCore_LDR_immediate_arm(Encoding encoding, uint t, uint imm32, uint n, bool index, bool add, bool wback)
+		{
+			if (disassemble)
+				return Disassemble_LDR_STR_immediate("LDR", t, imm32, n, index, add, wback);
+
+			uint offset_addr, address;
+			if (add) offset_addr = r[n] + imm32;
+			else offset_addr = r[n] - imm32;
+			if (index) address = offset_addr;
+			else address = r[n];
+			uint data = MemU_Read32(address);
+			if (wback) r[n] = offset_addr;
+			if (t == 15)
+			{
+				if ((address & 3) == _.b00) _LoadWritePC(data); else unpredictable = true;
+			}
+			else if (_UnalignedSupport() || ((address & 3) == _.b00))
+				r[t] = data;
+			else //can only apply before ARMv7
+				r[t] = _ROR(data, 8 * ((int)address & 3));
+
+			return 0;
+		}
+
+		//A8.6.59 LDR (literal)
+		uint ExecuteCore_LDR_literal(Encoding encoding, uint t, uint imm32, bool add)
+		{
+			uint @base = _Align(PC, 4);
+			uint address = add ? (@base + imm32) : (@base - imm32);
+
+			if (disassemble)
+				return DISNEW("LDR<c>", "<Rt>,[PC,#<optaddsub><imm>] ; @<label>=<%08X>", t, add, imm32, address, bus.Read32(AT.PEEK, address));
+
+			uint data = _MemU(address, 4);
+
+			if (t == 15)
+				if ((address & 3) == 0) _LoadWritePC(data); else _UNPREDICTABLE();
+			else if (_UnalignedSupport() || ((address & 3) == 0))
+				r[t] = data;
+			else
+				//can only apply before armv7
+				if (_CurrentInstrSet() == EInstrSet.ARM)
+					r[t] = _ROR(data, (int)(address & 3));
+				else
+				{ r[t] = (uint)_UNKNOWN(32, data); }
+
+			return 1;
+		}
+
+		//A8.6.61 LDRB (immediate, thumb)
+		uint ExecuteCore_LDRB_immediate_thumb(Encoding encoding, uint t, uint n, uint imm32, bool index, bool add, bool wback)
+		{
+			if (disassemble)
+				return Disassemble_LDR_STR_immediate("LDRB<c>", t, imm32, n, index, add, wback);
+
+			uint offset_addr = add ? (r[n] + imm32) : (r[n] - imm32);
+			uint address = index ? offset_addr : r[n];
+			r[t] = _ZeroExtend_32(MemU_Read08(address));
+			if (wback) r[n] = offset_addr;
+
+			return 1;
+		}
+
+		//A8.6.64 LDRB (register)
+		uint ExecuteCore_LDRB_register(Encoding encoding, uint t, uint n, uint m, SRType shift_t, int shift_n, bool index, bool add, bool wback)
+		{
+			if (disassemble)
+				return Disassemble_LDR_STR_register("LDRB<c>", t, n, m, shift_t, shift_n, index, add, wback);
+
+			uint offset = _Shift(r[m], shift_t, shift_n, APSR.C);
+			uint offset_addr = add ? (r[n] + offset) : (r[n] - offset);
+			uint address = index ? offset_addr : r[n];
+			r[t] = _ZeroExtend_32(_MemU(address, 1));
+			if (wback) r[n] = offset_addr;
+
+			return 1;
+		}
+
+		//A8.6.69 LDREX
+		uint ExecuteCore_LDREX(Encoding encoding, uint n, uint t, uint imm32)
+		{
+			if (disassemble)
+				return DISNEW("LDREX<c>", "<rt!>, [<rn!><{ ,#imm}>]", t, n, imm32);
+			_NullCheckIfThumbEE(n);
+			uint address = r[n] + imm32;
+			_SetExclusiveMonitors(address, 4);
+			r[t] = MemA_Read32(address);
+
+			return 1;
+		}
+
+		//A8.6.73 LDRH (immediate, thumb)
+		uint ExecuteCore_LDRH_immediate_thumb(Encoding encoding, uint t, uint n, uint imm32, bool index, bool add, bool wback)
+		{
+			if (disassemble)
+				return Disassemble_LDR_STR_immediate("LDRH", t, imm32, n, index, add, wback);
+			_NullCheckIfThumbEE(n);
+			uint offset_addr = add ? (r[n] + imm32) : (r[n] - imm32);
+			uint address = index ? offset_addr : r[n];
+			ushort data = MemU_Read16(address);
+			if (wback) r[n] = offset_addr;
+			if (_UnalignedSupport() || _.BIT0(address) == 0)
+				r[t] = _ZeroExtend_32((uint)data);
+			else r[t] = (uint)_UNKNOWN(32, (ulong)_ZeroExtend_32((uint)data));
+
+			return 1;
+		}
+
+		//A8.6.88 LSL (immediate)
+		uint ExecuteCore_LSL_immediate(Encoding encoding, uint d, uint m, bool setflags, int shift_n)
+		{
+			//sometimes (in arm) this shows up as MOV. i sort of like that syntax better...
+			if (disassemble)
+				return DISNEW("LSL<s?><c>", "<{rd!~rm, }><rm!>, #<imm5>", setflags, d, m, m, shift_n);
+
+			uint result;
+			Bit carry;
+			_Shift_C(r[m], SRType.LSL, shift_n, APSR.C, out result, out carry);
+			if (d == 15)
+				_ALUWritePC(result);
+			else
+			{
+				r[d] = result;
+				if (setflags)
+				{
+					APSR.N = _.BIT31(result);
+					APSR.Z = _IsZeroBit(result);
+					APSR.C = carry;
+					//APSR.V unchanged
+				}
+			}
+
+			return 0;
+		}
+
+		//A8.6.90 LSR (immediate)
+		uint ExecuteCore_LSR_immediate(Encoding encoding, uint d, uint m, bool setflags, int shift_n)
+		{
+			if (disassemble)
+				return DISNEW("LSR<s?><c>", "<{rd!~rm, }><rm!>, #<imm5>", setflags, d, m, m, shift_n);
+
+			uint result;
+			Bit carry;
+			_Shift_C(r[m], SRType.LSR, shift_n, APSR.C, out result, out carry);
+			if (d == 15)
+				_ALUWritePC(result);
+			else
+			{
+				r[d] = result;
+				if (setflags)
+				{
+					APSR.N = _.BIT31(result);
+					APSR.Z = _IsZeroBit(result);
+					APSR.C = carry;
+					//APSR.V unchanged
+				}
+			}
+
+			return 1;
+		}
+
+		//A8.6.97 MOV (register)
+		uint ExecuteCore_MOV_register(Encoding encoding, uint d, uint m, bool setflags)
+		{
+			//there are many caveats and addenda in the manual. check it carefully.
+
+			if (disassemble)
+				return DISNEW("MOV<s?><c?>", "<Rd!>,<Rm!>", setflags, EncodingA(encoding), d, m);
+
+			uint result = r[m];
+			if (d == 15)
+				_ALUWritePC(result);
+			else
+			{
+				r[d] = result;
+				if (setflags)
+				{
+					APSR.N = _.BIT31(result);
+					APSR.Z = _IsZeroBit(result);
+					//C and V are unchanged
+				}
+			}
+
+			return 1;
+		}
+
+		//A8.6.96 MOV (immedate)
+		uint ExecuteCore_MOV_immediate(Encoding encoding, uint d, bool setflags, uint imm32, uint carry)
+		{
+			if (disassemble)
+				return DIS("MOV/s0//c/", "/r1/,/const2/", setflags, d, imm32);
+			uint result = imm32;
+			if (d == 15)
+				_ALUWritePC(result);
+			else
+			{
+				r[d] = result;
+				if (setflags)
+				{
+					APSR.N = _.BIT31(result);
+					APSR.Z = (result == 0) ? 1U : 0U;
+					APSR.C = carry;
+				}
+			}
+			return 1;
+		}
+
+		//A8.6.100 MRC, MRC2
+		uint ExecuteCore_MRC_MRC2(Encoding encoding, uint cp, uint opc1, uint t, uint crn, uint crm, uint opc2)
+		{
+			if (disassemble)
+				return DISNEW("MRC<c>" + ((encoding == Encoding.A2 || encoding == Encoding.T2) ? "2" : ""), "<coproc>, <opc1>, <coproc_rt!>, <crn>, <crm>, <opc2><{ ;cp_comment}>", cp, opc1, t, crn, crm, opc2, "TBD");
+
+			uint value = sys.coprocessors.MRC(cp, opc1, t, crn, crm, opc2);
+			if (t != 15)
+				r[t] = value;
+			else
+			{
+				APSR.N = _.BIT31(value);
+				APSR.Z = _.BIT30(value);
+				APSR.C = _.BIT29(value);
+				APSR.V = _.BIT28(value);
+			}
+			return 1;
+		}
+
+		//A8.6.109 NEG [BLANK]
+		uint ExecuteCore_NEG()
+		{
+			//(this space intentionally blank. NEG was removed from the spec and replaced with RSB (immediate)
+			return 0;
+		}
+
+		//A8.6.113 ORR (immediate)
+		uint ExecuteCore_ORR_immediate(Encoding encoding, uint n, uint d, bool setflags, uint imm32, Bit carry)
+		{
+			if (disassemble)
+				return DISNEW("ORR<s?><c>", "<{rd!~rn, }><rn!>, #<const>", setflags, d, n, n, imm32);
+
+			uint result = r[n] | imm32;
+			if (d == 15)
+				_ALUWritePC(result);
+			else
+			{
+				r[d] = result;
+				if (setflags)
+				{
+					APSR.N = result;
+					APSR.Z = _IsZeroBit(result);
+					APSR.C = carry;
+					//APSR.V unchanged
+				}
+			}
+
+			return 1;
+		}
+
+		//A8.6.114 ORR (reg)
+		uint ExecuteCore_ORR_register(Encoding encoding, uint m, uint d, uint n, bool setflags, SRType shift_t, int shift_n)
+		{
+			if (disassemble)
+				return DISNEW("ORR<s?><c>", "<Rd!>, <Rn!>, <Rm!><{, shift}>", setflags, d, n, m, shift_t, shift_n);
+
+			uint shifted;
+			Bit carry;
+			_Shift_C(r[m], shift_t, shift_n, APSR.C, out shifted, out carry);
+			uint result = r[n] | shifted;
+			if (d == 15)
+				_ALUWritePC(result);
+			else
+			{
+				r[d] = result;
+				if (setflags)
+				{
+					APSR.N = _.BIT31(result);
+					APSR.Z = _IsZeroBit(result);
+					APSR.C = carry;
+					//APSR.V unchanged
+				}
+			}
+
+			return 1;
+		}
+
+		//A8.6.122 POP
+		uint ExecuteCore_POP(Encoding encoding, uint registers, bool UnalignedAllowed)
+		{
+			if (disassemble)
+				return DISNEW("pop<c>", "<registers> ; maybe LDMIA sp!,{..}", registers);
+
+			//in armv7, if SP is in the list then the instruction is UNKNOWN
+			uint address = SP;
+
+			uint bitcount = 0;
+			for (int i = 0; i <= 14; i++)
+			{
+				if (_.BITN(i, registers) == 1)
+				{
+					bitcount++;
+					r[i] = UnalignedAllowed ? _MemU(address, 4) : _MemA(address, 4);
+					address = address + 4;
+				}
+			}
+			if (_.BIT15(registers) == 1)
+			{
+				bitcount++;
+				if (UnalignedAllowed)
+					_LoadWritePC(_MemU(address, 4));
+				else
+					_LoadWritePC(_MemA(address, 4));
+			}
+			if (_.BIT13(registers) == 0) SP = SP + 4 * bitcount;
+			else SP = (uint)_UNKNOWN(32, SP + 4 * bitcount);
+
+			return 1;
+		}
+
+		//A8.6.123 PUSH
+		uint ExecuteCore_PUSH(Encoding encoding, uint registers, bool UnalignedAllowed)
+		{
+			uint bitcount = _.BitCount(registers);
+
+			if (disassemble)
+				if (bitcount == 1)
+					return DISNEW("push<c>", "<registers> ; maybe STR rx,[SP,#-0x4]", registers);
+				else
+					return DISNEW("push<c>", "<registers> ; maybe STMDB sp!,{..}", registers);
+
+			_NullCheckIfThumbEE(13);
+			uint address = SP - 4 * bitcount;
+			for (int i = 0; i <= 14; i++)
+			{
+				if (_.BITN(i, registers) == 1)
+				{
+					//TODO - work on this
+					if (i == 13 && i != _LowestSetBit(registers, 16))
+						MemA_Write32(address, (uint)_UNKNOWN(32, r[i]));
+					else if (UnalignedAllowed)
+						MemU_Write32(address, r[i]);
+					else
+						MemA_Write32(address, r[i]);
+					address += 4;
+				}
+			}
+			if (_.BIT15(registers) == 1)
+			{
+				if (UnalignedAllowed)
+					MemU_Write32(address, _PCStoreValue());
+				else
+					MemA_Write32(address, _PCStoreValue());
+			}
+
+			SP = SP - 4 * bitcount;
+
+			return 1;
+		}
+
+		//A8.6.142 RSB (immediate)
+		uint ExecuteCore_RSB_immediate(Encoding encoding, uint d, uint n, bool setflags, uint imm32)
+		{
+			if (disassemble)
+				return DISNEW("RSB<s?><c>", "<{rd!~rn, }><rn!>, #<const>" + (imm32 == 0 ? " ;maybe NEG" : ""), setflags, d, n, n, imm32);
+			_AddWithCarry32(~r[n], imm32, 1);
+			if (d == 15)
+				_ALUWritePC(alu_result_32);
+			else
+			{
+				r[d] = alu_result_32;
+				APSR.N = _.BIT31(alu_result_32);
+				APSR.Z = _IsZeroBit(alu_result_32);
+				APSR.C = alu_carry_out;
+				APSR.V = alu_overflow;
+			}
+			return 1;
+		}
+
+		//A8.6.189 STM/STMIA/STMEA
+		uint ExecuteCore_STM_STMIA_STMEA(Encoding encoding, bool wback, uint n, uint registers)
+		{
+			//we could write this as STM<c>, STM<c>IA or STMIA<c> or STMEA<c> or STM<c>EA but how to choose?? who cares. christ.
+			//I chose STMIA to match rvct
+			if (disassemble)
+				return DISNEW("STMIA<c>", "<Rn!><{wback!}>, <registers>", n, wback, registers);
+
+			uint bitcount = _.BitCount(registers);
+			uint address = r[n];
+			for (int i = 0; i <= 14; i++)
+			{
+				if (_.BITN(i, registers) == 1)
+				{
+					if (i == n && wback && i != _LowestSetBit(registers, 16))
+						MemA_Write32(address, (uint)_UNKNOWN(32, r[i])); //"only possible for encodings T1 and A1"
+					else MemA_Write32(address, r[i]);
+					address += 4;
+				}
+			}
+
+			if (_.BIT15(registers) == 1) //"only possible for encoding A1"
+				MemA_Write32(address, _PCStoreValue());
+			if (wback) r[n] = r[n] + 4 * bitcount;
+
+			return 1;
+		}
+
+		//A8.6.191 STMDB/STMFD
+		uint ExecuteCore_STMDB_STMFD(Encoding encoding, bool wback, uint n, uint registers)
+		{
+			if (disassemble)
+				return DISNEW("STMDB<c>", "<Rn!><{wback!}>, <registers>", n, wback, registers);
+
+			uint bitcount = _.BitCount(registers);
+			uint address = r[n] - 4 * bitcount;
+			for (int i = 0; i <= 14; i++)
+			{
+				if (_.BITN(i, registers) == 1)
+				{
+					if (i == n && wback && i != _LowestSetBit(registers, 16))
+						MemA_Write32(address, (uint)_UNKNOWN(32, r[i])); //"only possible for encoding A1"
+					else
+						MemA_Write32(address, r[i]);
+					address += 4;
+				}
+			}
+
+			if (_.BIT15(registers) == 1) //"only possible for encoding A1"
+				MemA_Write32(address, _PCStoreValue());
+
+			if (wback) r[n] = r[n] - 4 * bitcount;
+
+			return 0;
+		}
+
+		//A8.6.193 STR (immediate, thumb)
+		uint ExecuteCore_STR_immediate_thumb(Encoding encoding, uint t, uint imm32, uint n, bool index, bool add, bool wback)
+		{
+			if (disassemble)
+				return Disassemble_LDR_STR_immediate("STR", t, imm32, n, index, add, wback);
+
+			uint offset_addr;
+			if (add) offset_addr = r[n] + imm32; else offset_addr = r[n] - imm32;
+			uint address;
+			if (index) address = offset_addr; else address = r[n];
+			if (_UnalignedSupport() || ((address & 3) == 0))
+				MemU_Write32(address, r[t]);
+			else
+				UnalignedAccess(address);
+			if (wback) r[n] = offset_addr;
+			return 1;
+		}
+
+		//A8.6.194 STR (immediate, arm)
+		uint ExecuteCore_STR_immediate_arm(Encoding encoding, bool P, bool U, bool W, uint n, uint t, uint imm32, bool index, bool add, bool wback)
+		{
+			if (disassemble)
+				return Disassemble_LDR_STR_immediate("STR", t, imm32, n, index, add, wback);
+
+			uint offset_addr = add ? (r[n] + imm32) : (r[n] - imm32);
+			uint address = index ? offset_addr : r[n];
+			MemU_Write32(address, t == 15 ? _PCStoreValue() : r[t]);
+			if (wback) r[n] = offset_addr;
+
+			return 1;
+		}
+
+		//A8.6.196 STRB (immediate, thumb)
+		uint ExecuteCore_STRB_immediate_thumb(Encoding encoding, uint t, uint n, uint imm32, bool index, bool add, bool wback)
+		{
+			if (disassemble)
+				return Disassemble_LDR_STR_immediate("STRB", t, imm32, n, index, add, wback);
+
+			uint offset_addr = add ? (r[n] + imm32) : (r[n] - imm32);
+			uint address = index ? offset_addr : r[n];
+			MemU_Write08(address, r[t] & 0xFF);
+			if (wback) r[n] = offset_addr;
+
+			return 1;
+		}
+
+		//A8.6.198 STRB (register)
+		uint ExecuteCore_STRB_register(Encoding encoding, uint t, uint n, uint m, SRType shift_t, int shift_n, bool index, bool add, bool wback)
+		{
+			if (disassemble)
+				return Disassemble_LDR_STR_register("STRB<c>", t, n, m, shift_t, shift_n, index, add, wback);
+
+			uint offset = _Shift(r[m], shift_t, shift_n, APSR.C);
+			uint offset_addr = add ? (r[n] + offset) : (r[n] - offset);
+			uint address = index ? offset_addr : r[n];
+			MemU_Write08(address, r[t] & 0xFF);
+			if (wback) r[n] = offset_addr;
+			return 1;
+		}
+
+		//A8.6.202 STREX
+		uint ExecuteCore_STREX(Encoding encoding, uint d, uint n, uint t, uint imm32)
+		{
+			if (disassemble)
+				return DISNEW("STREX<c>", "<rd!>, <rt!>, [<rn!><{ ,#imm}>]", d, t, n, imm32);
+			_NullCheckIfThumbEE(n);
+			uint address = r[n] + imm32;
+			if (_ExclusiveMonitorsPass(address, 4))
+			{
+				MemA_Write32(address, r[t]);
+				r[d] = 0;
+			}
+			else r[d] = 1;
+			return 1;
+		}
+
+		//A8.6.206 STRH (immediate, thumb)
+		uint ExecuteCore_STRH_immediate_thumb(Encoding encoding, uint t, uint n, uint imm32, bool index, bool add, bool wback)
+		{
+			if (disassemble)
+				return Disassemble_LDR_STR_immediate("STRH", t, imm32, n, index, add, wback);
+			_NullCheckIfThumbEE(n);
+			uint offset_addr = add ? (r[n] + imm32) : (r[n] - imm32);
+			uint address = index ? offset_addr : r[n];
+			if (_UnalignedSupport() || _.BIT0(address) == 0)
+				MemU_Write16(address, r[t] & 0xFFFF);
+			else
+				MemU_Write16(address, (uint)_UNKNOWN(16, r[t] & 0xFFFF));
+			if (wback) r[n] = offset_addr;
+
+			return 1;
+		}
+
+		//A8.6.211 SUB (immediate, thumb)
+		uint ExecuteCore_SUB_immediate_thumb(Encoding encoding, uint n, uint d, bool setflags, uint imm32)
+		{
+			if (disassemble)
+				return DISNEW("SUB<s?><c>", "<{rd!~rn, }><rn!>, #<const>", setflags, d, n, n, imm32);
+
+			_AddWithCarry32(r[n], ~imm32, 1);
+			r[d] = alu_result_32;
+			if (setflags)
+			{
+				APSR.N = _.BIT31(alu_result_32);
+				APSR.Z = _IsZeroBit(alu_result_32);
+				APSR.C = alu_carry_out;
+				APSR.V = alu_overflow;
+			}
+
+			return 1;
+		}
+
+		//A8.6.212 SUB (immediate, arm)
+		uint ExecuteCore_SUB_immediate_arm(Encoding encoding, bool setflags, uint n, uint d, uint imm32)
+		{
+			if (disassemble)
+				return DISNEW("SUB<s?><c>", "<{rd!~rn, }><rn!>, #<const>", setflags, d, n, n, imm32);
+
+			_AddWithCarry32(r[n], ~imm32, 1);
+			if (d == 15)
+				_ALUWritePC(alu_result_32); //setflags is always FALSE here
+			else
+			{
+				r[d] = alu_result_32;
+				if (setflags)
+				{
+					APSR.N = _.BIT31(alu_result_32);
+					APSR.Z = _IsZeroBit(alu_result_32);
+					APSR.C = alu_carry_out;
+					APSR.V = alu_overflow;
+				}
+			}
+
+			return 1;
+		}
+
+		//A8.6.213 SUB (register)
+		uint ExecuteCore_SUB_register(Encoding encoding, bool setflags, uint m, uint n, uint d, SRType shift_t, int shift_n)
+		{
+			if (disassemble)
+				return DISNEW("SUB<s?><c>", "<{rd!~rn, }><rn!>, <rm!><{, shift}>", setflags, d, n, n, m, shift_t, shift_n);
+
+			uint shifted = _Shift(r[m], shift_t, shift_n, APSR.C);
+			_AddWithCarry32(r[n], ~shifted, 1);
+			if (d == 15)
+				_ALUWritePC(alu_result_32);
+			else
+			{
+				r[d] = alu_result_32;
+				if (setflags)
+				{
+					APSR.N = _.BIT31(alu_result_32);
+					APSR.Z = _IsZeroBit(alu_result_32);
+					APSR.C = alu_carry_out;
+					APSR.V = alu_overflow;
+				}
+			}
+
+			return 1;
+		}
+
+		//A8.6.215 SUB (SP minus immediate)
+		uint ExecuteCore_SUB_SP_minus_immediate(Encoding encoding, uint d, bool setflags, uint imm32)
+		{
+			uint n = 13;
+			if (disassemble)
+				return DISNEW("SUB<s?><c>", "<{rd!~rn, }><rn!>, #<const>", setflags, d, n, n, imm32);
+
+			_AddWithCarry32(SP, ~imm32, 1);
+			if (d == 15)
+				_ALUWritePC(alu_result_32);
+			else
+			{
+				r[d] = alu_result_32;
+				if (setflags)
+				{
+					APSR.N = _.BIT31(alu_result_32);
+					APSR.Z = _IsZeroBit(alu_result_32);
+					APSR.C = alu_carry_out;
+					APSR.V = alu_overflow;
+				}
+			}
+
+			return 1;
+		}
+
+		//A8.6.218 SVC (previously SWI)
+		uint ExecuteCore_SVC(Encoding encoding, uint imm32)
+		{
+			if (disassemble)
+				return DISNEW("XXX", "<svc>", imm32);
+			return sys.svc(imm32);
+		}
+
+		//A8.6.263 UXTB
+		uint ExecuteCore_UXTB(Encoding encoding, uint d, uint m, uint rotation)
+		{
+			if (disassemble)
+				return DISNEW("UXTB<c>", "<rd!>, <rm!><{, rotation}>", d, m, rotation);
+
+			rotation *= 8;
+			uint rotated = _ROR(r[m], (int)rotation);
+			r[d] = _ZeroExtend_32(rotated & 0xFF);
+
+			return 1;
+		}
+
+		//A8.6.265 UXTH
+		uint ExecuteCore_UXTH(Encoding encoding, uint d, uint m, uint rotation)
+		{
+			if (disassemble)
+				return DISNEW("UXTH<c>", "<rd!>, <rm!><{, rotation}>", d, m, rotation);
+
+			rotation *= 8;
+			uint rotated = _ROR(r[m], (int)rotation);
+			r[d] = _ZeroExtend_32(rotated & 0xFFFF);
+
+			return 1;
+		}
+
+		//A8.6.336 VMSR
+		uint ExecuteCore_VMSR(uint t)
+		{
+			_CheckVFPEnabled(true);
+			_SerializeVFP();
+			_VFPExcBarrier();
+			FPSCR = r[t];
+			return 1;
+		}
+
+	}
+
+	//unnecessary opcodes: BKPT, BXJ, CBNZ, CHKA, NOP, CPY, DBG, ENTERX, HB, IT, LDRBT, LDRHT, LDRSBT, LDRSHT, LEAVEX, RBIT, SBFX, SDIV, TBB
+	//likely unnecessary: CDP, SETEND, SEV
+	//etc..
+
+}
\ No newline at end of file
diff --git a/BizHawk.Emulation/CPUs/ARM/ARM.ExecuteThumb.cs b/BizHawk.Emulation/CPUs/ARM/ARM.ExecuteThumb.cs
new file mode 100644
index 0000000000..50eb17a608
--- /dev/null
+++ b/BizHawk.Emulation/CPUs/ARM/ARM.ExecuteThumb.cs
@@ -0,0 +1,905 @@
+using System;
+using System.Diagnostics;
+
+namespace BizHawk.Emulation.CPUs.ARM
+{
+
+	partial class ARM
+	{
+
+		uint ExecuteThumb()
+		{
+			uint opcode = instruction >> 10;
+			_currentCondVal = 14;
+
+			//TODO - this one could really be turned into a table
+
+			switch (opcode)
+			{
+				case _.b000000:
+				case _.b000001:
+				case _.b000010:
+				case _.b000011:
+				case _.b000100:
+				case _.b000101:
+				case _.b000110:
+				case _.b000111:
+				case _.b001000:
+				case _.b001001:
+				case _.b001010:
+				case _.b001011:
+				case _.b001100:
+				case _.b001101:
+				case _.b001110:
+				case _.b001111:
+					return ExecuteThumb_AluMisc();
+
+				case _.b010000: return ExecuteThumb_DataProcessing();
+				case _.b010001: return ExecuteThumb_SpecialBX();
+
+				case _.b010010:
+				case _.b010011:
+					return ExecuteThumb_LdrLiteral_T1();
+
+				case _.b010100:
+				case _.b010101:
+				case _.b010110:
+				case _.b010111:
+				case _.b011000:
+				case _.b011001:
+				case _.b011010:
+				case _.b011011:
+				case _.b011100:
+				case _.b011101:
+				case _.b011110:
+				case _.b011111:
+				case _.b100000:
+				case _.b100001:
+				case _.b100010:
+				case _.b100011:
+				case _.b100100:
+				case _.b100101:
+				case _.b100110:
+				case _.b100111:
+					return ExecuteThumb_LoadStore();
+
+				case _.b101000:
+				case _.b101001: return ExecuteThumb_ADR_T1();
+				case _.b101010:
+				case _.b101011: return Execute_ADD_SP_plus_immediate_T1();
+
+				case _.b101100:
+				case _.b101101:
+				case _.b101110:
+				case _.b101111:
+					return ExecuteThumb_Misc16();
+
+				case _.b110000:
+				case _.b110001: return Execute_STM_STMIA_STMEA_T1();
+				case _.b110010:
+				case _.b110011: return Execute_LDM_LDMIA_LDMFD_T1();
+
+				case _.b110100:
+				case _.b110101:
+				case _.b110110:
+				case _.b110111:
+					return ExecuteThumb_CondBr_And_SVC();
+
+				case _.b111000:
+				case _.b111001: return Execute_B_T2();
+
+				case _.b111010:
+				case _.b111011:
+				case _.b111100:
+				case _.b111101:
+				case _.b111110:
+				case _.b111111:
+					return ExecuteThumb_32();
+
+				default:
+					throw new InvalidOperationException("unhandled case in ExecuteThumb");
+			}
+		}
+
+		uint ExecuteThumb_LdrLiteral_T1()
+		{
+			//A8.6.59
+			//A8-122
+			uint t = Reg8(8);
+			uint imm8 = instruction & 0xFF;
+			uint imm32 = imm8 << 2;
+			bool add = true;
+
+			return ExecuteCore_LDR_literal(Encoding.T1, t, imm32, add);
+		}
+
+		uint ExecuteThumb_LoadStore()
+		{
+			//A6.2.4
+			uint opA = (instruction >> 12) & 0xF;
+			uint opB = (instruction >> 9) & 0x7;
+			switch (opA)
+			{
+				case _.b0101:
+					switch (opB)
+					{
+						case _.b000: return Execute_Unhandled("STR (register) on page A8-386");
+						case _.b001: return Execute_Unhandled("STRH (register) on page A8-412");
+						case _.b010: return Execute_STRB_register_T1();
+						case _.b011: return Execute_Unhandled("LDRSB (register) on page A8-164");
+						case _.b100: return Execute_Unhandled("LDR (register) on page A8-124");
+						case _.b101: return Execute_Unhandled("LDRH (register)");
+						case _.b110: return Execute_LDRB_register_T1();
+						case _.b111: return Execute_Unhandled("LDRSH (register) on page A8-172");
+						default: throw new InvalidOperationException("decoder fail");
+					}
+				case _.b0110:
+					switch (opB)
+					{
+						case _.b000:
+						case _.b001:
+						case _.b010:
+						case _.b011: return Execute_STR_immediate_thumb_T1();
+						case _.b100:
+						case _.b101:
+						case _.b110:
+						case _.b111: return Execute_LDR_immediate_thumb_T1();
+						default: throw new InvalidOperationException("decoder fail");
+					}
+				case _.b0111:
+					switch (opB)
+					{
+						case _.b000:
+						case _.b001:
+						case _.b010:
+						case _.b011: return Execute_STRB_immediate_thumb_T1();
+						case _.b100:
+						case _.b101:
+						case _.b110:
+						case _.b111: return Execute_LDRB_immediate_thumb_T1();
+						default: throw new InvalidOperationException("decoder fail");
+					}
+				case _.b1000:
+					switch (opB)
+					{
+						case _.b000:
+						case _.b001:
+						case _.b010:
+						case _.b011: return Execute_STRH_immediate_thumb_T1();
+						case _.b100:
+						case _.b101:
+						case _.b110:
+						case _.b111: return Execute_LDRH_immediate_thumb_T1();
+						default: throw new InvalidOperationException("decoder fail");
+					}
+				case _.b1001:
+					switch (opB)
+					{
+						case _.b000:
+						case _.b001:
+						case _.b010:
+						case _.b011: return Execute_STR_immediate_thumb_T2();
+						case _.b100:
+						case _.b101:
+						case _.b110:
+						case _.b111: return Execute_LDR_immediate_thumb_T2();
+						default: throw new InvalidOperationException("decoder fail");
+					}
+				default: throw new InvalidOperationException("decoder fail");
+			} //switch(opA)
+		}
+
+		uint Execute_STRB_register_T1()
+		{
+			//A8.6.198
+			uint t = Reg8(0);
+			uint n = Reg8(3);
+			uint m = Reg8(6);
+			const bool index = true; const bool add = true; const bool wback = false;
+			const SRType shift_t = SRType.LSL;
+			const int shift_n = 0;
+			return ExecuteCore_STRB_register(Encoding.T1, t, n, m, shift_t, shift_n, index, add, wback);
+		}
+
+		uint Execute_LDRB_register_T1()
+		{
+			//A8.6.64
+			uint t = Reg8(0);
+			uint n = Reg8(3);
+			uint m = Reg8(6);
+			const bool index = true; const bool add = true; const bool wback = false;
+			const SRType shift_t = SRType.LSL;
+			const int shift_n = 0;
+			return ExecuteCore_LDRB_register(Encoding.T1, t, n, m, shift_t, shift_n, index, add, wback);
+		}
+
+		uint Execute_LDRB_immediate_thumb_T1()
+		{
+			//A8.6.61
+			uint t = Reg8(0);
+			uint n = Reg8(3);
+			uint imm5 = (instruction >> 6) & 0x1F;
+			uint imm32 = _ZeroExtend_32(imm5);
+			const bool index = true; const bool add = true; const bool wback = false;
+			return ExecuteCore_LDRB_immediate_thumb(Encoding.T1, t, n, imm32, index, add, wback);
+		}
+
+		uint Execute_STRB_immediate_thumb_T1()
+		{
+			//A8.6.196
+			uint t = Reg8(0);
+			uint n = Reg8(3);
+			uint imm5 = (instruction >> 6) & 0x1F;
+			uint imm32 = _ZeroExtend_32(imm5);
+			const bool index = true; const bool add = true; const bool wback = false;
+			return ExecuteCore_STRB_immediate_thumb(Encoding.T1, t, n, imm32, index, add, wback);
+		}
+
+		uint Execute_LDRH_immediate_thumb_T1()
+		{
+			//A8.6.73
+			uint t = Reg8(0);
+			uint n = Reg8(3);
+			uint imm5 = (instruction >> 6) & 0x1F;
+			uint imm32 = _ZeroExtend_32(imm5 << 1);
+			const bool index = true; const bool add = true; const bool wback = false;
+			return ExecuteCore_LDRH_immediate_thumb(Encoding.T1, t, n, imm32, index, add, wback);
+		}
+
+		uint Execute_STRH_immediate_thumb_T1()
+		{
+			//A8.6.206 STRH
+			uint t = Reg8(0);
+			uint n = Reg8(3);
+			uint imm5 = (instruction >> 6) & 0x1F;
+			uint imm32 = _ZeroExtend_32(imm5 << 1);
+			const bool index = true; const bool add = true; const bool wback = false;
+			return ExecuteCore_STRH_immediate_thumb(Encoding.T1, t, n, imm32, index, add, wback);
+		}
+
+		uint Execute_LDR_immediate_thumb_T1()
+		{
+			//A8.6.57 LDR (immediate,thumb)
+			uint t = Reg8(0);
+			uint n = Reg8(3);
+			uint imm5 = (instruction >> 6) & 0x1F;
+			uint imm32 = _ZeroExtend_32(imm5 << 2);
+			bool index = true; bool add = true; bool wback = false;
+			return ExecuteCore_LDR_immediate_thumb(Encoding.T1, t, imm32, n, index, add, wback);
+		}
+
+		uint Execute_STR_immediate_thumb_T1()
+		{
+			//A8.6.193 STR (immediate,thumb)
+			uint t = Reg8(0);
+			uint n = Reg8(3);
+			uint imm5 = (instruction >> 6) & 0x1F;
+			uint imm32 = _ZeroExtend_32(imm5 << 2);
+			bool index = true; bool add = true; bool wback = false;
+			return ExecuteCore_STR_immediate_thumb(Encoding.T1, t, imm32, n, index, add, wback);
+		}
+
+		uint Execute_LDR_immediate_thumb_T2()
+		{
+			//A8.6.57 LDR (immediate, thumb)
+			uint t = Reg8(8);
+			uint imm8 = instruction & 0xFF;
+			const uint n = 13;
+			uint imm32 = _ZeroExtend_32(imm8 << 2);
+			const bool index = true; const bool add = true; const bool wback = false;
+			return ExecuteCore_LDR_immediate_thumb(Encoding.T2, t, imm32, n, index, add, wback);
+		}
+
+		uint Execute_STR_immediate_thumb_T2()
+		{
+			//A8.6.193 STR (immediate,thumb)
+			uint Rt = Reg8(8);
+			uint imm8 = instruction & 0xFF;
+			const uint n = 13;
+			uint imm32 = _ZeroExtend_32(imm8 << 2);
+			const bool index = true; const bool add = true; const bool wback = false;
+			return ExecuteCore_STR_immediate_thumb(Encoding.T2, Rt, imm32, n, index, add, wback);
+		}
+
+		uint ExecuteThumb_32()
+		{
+			uint op1 = (instruction >> 11) & 3;
+			uint op2 = (instruction >> 4) & 0x7F;
+			ThumbFetchExtra();
+			uint op = _.BIT15(thumb_32bit_extra);
+			switch (op1)
+			{
+				case _.b00: throw new InvalidOperationException("decode error");
+				case _.b01: return Execute_Unhandled("thumb-32bit");
+				case _.b10:
+					if (op == 0) return Execute_Unhandled("thumb-32bit");
+					else return ExecuteThumb_32_BranchAndMiscControl(op2);
+				case _.b11:
+					return Execute_Unhandled("thumb-32bit");
+				default: throw new InvalidOperationException();
+			}
+		}
+
+		uint ExecuteThumb_32_BranchAndMiscControl(uint op)
+		{
+			uint op1 = (thumb_32bit_extra >> 12) & 7;
+			switch (op1)
+			{
+				case _.b000:
+				case _.b010:
+					return Execute_Unhandled("thumb-32bit");
+				case _.b001:
+				case _.b011: return Execute_Unhandled("thumb-32bit 6T2 branch");
+				case _.b100:
+				case _.b110: return ExecuteThumb_BL_BLX_immediate_T2();
+				case _.b101:
+				case _.b111: return ExecuteThumb_BL_BLX_immediate_T1();
+				default: throw new InvalidOperationException();
+			}
+		}
+
+		uint ExecuteThumb_BL_BLX_immediate_T1()
+		{
+			//A8.6.23
+			//A8-58
+			//(BL)
+			uint S = _.BIT10(instruction);
+			uint J1 = _.BIT13(thumb_32bit_extra);
+			uint J2 = _.BIT11(thumb_32bit_extra);
+			uint imm11 = thumb_32bit_extra & _.b11111111111;
+			uint imm10 = instruction & _.b1111111111;
+			uint I1 = (~(J1 ^ S)) & 1;
+			uint I2 = (~(J2 ^ S)) & 1;
+			int imm32 = _SignExtend_32(25, (imm11 << 1) | (imm10 << 12) | (I2 << 22) | (I1 << 23) | (S << 24));
+			if (_InITBlock() && !_LastInITBlock()) _UNPREDICTABLE();
+			return ExecuteCore_BL_BLX_immediate(Encoding.T1, _CurrentInstrSet(), imm32, false);
+		}
+
+		uint ExecuteThumb_BL_BLX_immediate_T2()
+		{
+			//A8.6.23
+			//A8-58
+			//(BLX)
+			uint S = _.BIT10(instruction);
+			uint J1 = _.BIT13(thumb_32bit_extra);
+			uint J2 = _.BIT11(thumb_32bit_extra);
+			uint H = _.BIT0(thumb_32bit_extra);
+			uint imm10L = (thumb_32bit_extra >> 1) & 0x3FF;
+			uint imm10H = instruction & 0x3FF;
+			uint I1 = (~(J1 ^ S)) & 1;
+			uint I2 = (~(J2 ^ S)) & 1;
+			int imm32 = _SignExtend_32(25, (imm10L << 2) | (imm10H << 12) | (I2 << 22) | (I1 << 23) | (S << 24));
+			return ExecuteCore_BL_BLX_immediate(Encoding.T2, EInstrSet.ARM, imm32, true);
+		}
+
+		uint ExecuteThumb_AluMisc()
+		{
+			//A6.2.1
+			uint opcode = (instruction >> 9) & 0x1F;
+			switch (opcode)
+			{
+				case _.b00000:
+				case _.b00001:
+				case _.b00010:
+				case _.b00011:
+					return Execute_LSL_immediate_T1();
+				case _.b00100:
+				case _.b00101:
+				case _.b00110:
+				case _.b00111:
+					return Execute_LSR_immediate_T1();
+				case _.b01000:
+				case _.b01001:
+				case _.b01010:
+				case _.b01011:
+					return Execute_ASR_immediate_T1();
+				case _.b01100: return Execute_ADD_Register_T1();
+				case _.b01101: return Execute_SUB_Register_T1();
+				case _.b01110: return Execute_ADD_immediate_thumb_T1();
+				case _.b01111: return Execute_SUB_immediate_thumb_T1();
+				case _.b10000:
+				case _.b10001:
+				case _.b10010:
+				case _.b10011:
+					return Execute_MOV_immediate_T1();
+				case _.b10100:
+				case _.b10101:
+				case _.b10110:
+				case _.b10111:
+					return Execute_CMP_immediate_T1();
+				case _.b11000:
+				case _.b11001:
+				case _.b11010:
+				case _.b11011:
+					return Execute_ADD_immediate_thumb_T2();
+				case _.b11100:
+				case _.b11101:
+				case _.b11110:
+				case _.b11111:
+					return Execute_SUB_immediate_thumb_T2();
+			}
+			return Execute_Unhandled("ExecuteThumb_AluMisc");
+		}
+
+		uint Execute_CMP_immediate_T1()
+		{
+			//A8.6.35 CMP immediate
+			//A8-80
+			uint n = Reg8(8);
+			uint imm8 = instruction & 0xFF;
+			uint imm32 = _ZeroExtend_32(imm8);
+			return ExecuteCore_CMP_immediate(Encoding.T1, n, imm32);
+		}
+
+		uint Execute_MOV_immediate_T1()
+		{
+			//A8.6.96 MOV immediate
+			uint d = Reg8(8);
+			uint imm8 = instruction & 0xFF;
+			bool setflags = !_InITBlock();
+			uint imm32 = _ZeroExtend_32(imm8);
+			Bit carry = APSR.C;
+			return ExecuteCore_MOV_immediate(Encoding.T1, d, setflags, imm32, carry);
+		}
+
+		uint Execute_SUB_Register_T1()
+		{
+			//A8.6.213 SUB (register)
+			uint d = Reg8(0);
+			uint n = Reg8(3);
+			uint m = Reg8(6);
+			bool setflags = !_InITBlock();
+			const SRType shift_t = SRType.LSL;
+			const int shift_n = 0;
+			return ExecuteCore_SUB_register(Encoding.T1, setflags, m, n, d, shift_t, shift_n);
+		}
+
+		uint Execute_ADD_Register_T1()
+		{
+			//A8.6.6 ADD (register)
+			uint d = Reg8(0);
+			uint n = Reg8(3);
+			uint m = Reg8(6);
+			bool setflags = !_InITBlock();
+			const SRType shift_t = SRType.LSL;
+			const int shift_n = 0;
+			return ExecuteCore_ADD_register(Encoding.T1, m, d, n, setflags, shift_t, shift_n);
+		}
+
+		uint Execute_ADD_register_T2()
+		{
+			//A8.6.6 ADD (register)
+			Bit DN = _.BIT7(instruction);
+			uint rdn = Reg8(0);
+			uint m = Reg16(3);
+			Debug.Assert(!(DN == 1 && rdn == _.b101 || m == _.b1101), "see ADD (SP plus register)");
+			uint d = rdn;
+			uint n = rdn;
+			bool setflags = false;
+			const SRType shift_t = SRType.LSL;
+			const int shift_n = 0;
+			if (n == 15 && m == 15) _FlagUnpredictable();
+			if (d == 15 && _InITBlock() && !_LastInITBlock()) _FlagUnpredictable();
+			return ExecuteCore_ADD_register(Encoding.T2, m, d, n, setflags, shift_t, shift_n);
+		}
+
+		uint Execute_SUB_immediate_thumb_T1()
+		{
+			//A7.6.211
+			uint d = Reg8(0);
+			uint n = Reg8(3);
+			uint imm3 = (instruction >> 6) & 7;
+			bool setflags = !_InITBlock();
+			uint imm32 = _ZeroExtend_32(imm3);
+			return ExecuteCore_SUB_immediate_thumb(Encoding.T1, n, d, setflags, imm32);
+		}
+
+		uint Execute_ADD_immediate_thumb_T1()
+		{
+			uint d = Reg8(0);
+			uint n = Reg8(3);
+			uint imm3 = (instruction >> 6) & 7;
+			bool setflags = !_InITBlock();
+			uint imm32 = _ZeroExtend_32(imm3);
+			return ExecuteCore_ADD_immediate_thumb(Encoding.T1, n, d, setflags, imm32);
+		}
+
+		uint Execute_SUB_immediate_thumb_T2()
+		{
+			//A8.6.211
+			uint d = Reg8(8);
+			uint n = d;
+			bool setflags = !_InITBlock();
+			uint imm8 = (instruction & 0xFF);
+			uint imm32 = _ZeroExtend_32(imm8);
+			return ExecuteCore_SUB_immediate_thumb(Encoding.T2, n, d, setflags, imm32);
+		}
+
+		uint Execute_ADD_immediate_thumb_T2()
+		{
+			uint Rdn = Reg8(8);
+			uint imm8 = instruction & _.b11111111;
+			uint d = Rdn;
+			uint n = Rdn;
+			bool setflags = !_InITBlock();
+			uint imm32 = imm8;
+			return ExecuteCore_ADD_immediate_thumb(Encoding.T2, n, d, setflags, imm32);
+		}
+
+		uint Execute_LSL_immediate_T1()
+		{
+			//A8.6.14
+			uint imm5 = (instruction >> 6) & 0x1F;
+			if (imm5 == 0 && procopt.Thumb_LSL_immediate_T1_0_is_MOV_register_T2) return Execute_MOV_register_T2();
+
+			uint d = Reg8(0);
+			uint m = Reg8(3);
+			bool setflags = !_InITBlock();
+			_DecodeImmShift(0, imm5);
+
+			return ExecuteCore_LSL_immediate(Encoding.T1, d, m, setflags, shift_n);
+		}
+
+		uint Execute_ASR_immediate_T1()
+		{
+			//A8.6.14 ASR (immediate)
+			uint d = Reg8(0);
+			uint m = Reg8(3);
+			uint imm5 = (instruction >> 6) & 0x1F;
+			bool setflags = !_InITBlock();
+			_DecodeImmShift(_.b10, imm5);
+
+			return ExecuteCore_ASR_immediate(Encoding.T1, d, m, setflags, shift_n);
+		}
+
+		uint Execute_LSR_immediate_T1()
+		{
+			uint imm5 = (instruction >> 6) & 0x1F;
+			uint m = Reg8(3);
+			uint d = Reg8(0);
+			bool setflags = !_InITBlock();
+			_DecodeImmShift(_.b01, imm5);
+			return ExecuteCore_LSR_immediate(Encoding.T1, d, m, setflags, shift_n);
+		}
+
+		uint Execute_MOV_register_T1()
+		{
+			//A8.6.97 MOV (register)
+			uint D = _.BIT7(instruction);
+			uint d = Reg8(0) + 8 * D;
+			uint m = Reg16(3);
+			bool setflags = false;
+			if (d == 15 && _InITBlock() && !_LastInITBlock()) unpredictable = true;
+
+			//my own sanity check:
+			if (m >= 8 && _ArchVersion() < 6) throw new InvalidOperationException("thumb mov register invalid for your architecture version. need to think about this.");
+
+			return ExecuteCore_MOV_register(Encoding.T1, d, m, setflags);
+		}
+
+		uint Execute_MOV_register_T2()
+		{
+			uint D = _.BIT7(instruction);
+			uint d = Reg8(0);
+			uint m = Reg8(3);
+			bool setflags = true;
+
+			if (_InITBlock()) unpredictable = true;
+
+			return ExecuteCore_MOV_register(Encoding.T2, d, m, setflags);
+		}
+
+		uint ExecuteThumb_DataProcessing()
+		{
+			//A6.2.2
+			uint opcode = (instruction >> 6) & 0xF;
+			switch (opcode)
+			{
+				case _.b0000: return Execute_Unhandled("thumb AND reg");
+				case _.b0001: return Execute_EOR_register_T1();
+				case _.b0010: return Execute_Unhandled("thumb LSL reg");
+				case _.b0011: return Execute_Unhandled("thumb LSR reg");
+				case _.b0100: return Execute_Unhandled("thumb ASR reg");
+				case _.b0101: return Execute_Unhandled("thumb ADC reg");
+				case _.b0110: return Execute_Unhandled("thumb SBC reg");
+				case _.b0111: return Execute_Unhandled("thumb ROR reg");
+				case _.b1000: return Execute_Unhandled("thumb TST reg");
+				case _.b1001: return Execute_RSB_immediate_T1();
+				case _.b1010: return Execute_CMP_register_T1();
+				case _.b1011: return Execute_Unhandled("thumb CMN reg");
+				case _.b1100: return Execute_ORR_register_T1();
+				case _.b1101: return Execute_Unhandled("thumb MUL");
+				case _.b1110: return Execute_Unhandled("thumb BIC reg");
+				case _.b1111: return Execute_Unhandled("thumb MVN reg");
+				default: throw new InvalidOperationException();
+			}
+		}
+
+		uint Execute_RSB_immediate_T1()
+		{
+			//A8.6.142
+			uint d = Reg8(0);
+			uint n = Reg8(3);
+			bool setflags = !_InITBlock();
+			uint imm32 = 0;
+			return ExecuteCore_RSB_immediate(Encoding.T1, d, n, setflags, imm32);
+		}
+
+		uint Execute_EOR_register_T1()
+		{
+			//A8.6.45
+			uint d = Reg8(0);
+			uint n = d;
+			uint m = Reg8(3);
+			bool setflags = !_InITBlock();
+			const SRType shift_t = SRType.LSL;
+			const int shift_n = 0;
+			return ExecuteCore_EOR_register(Encoding.T1, m, d, n, setflags, shift_t, shift_n);
+		}
+
+		uint Execute_ORR_register_T1()
+		{
+			//A7.6.114
+			uint d = Reg8(0);
+			uint n = d;
+			uint m = Reg8(3);
+			bool setflags = !_InITBlock();
+			const SRType shift_t = SRType.LSL;
+			const int shift_n = 0;
+			return ExecuteCore_ORR_register(Encoding.T1, m, d, n, setflags, shift_t, shift_n);
+		}
+
+		uint Execute_CMP_register_T1()
+		{
+			//A8.6.36
+			uint n = Reg8(0);
+			uint m = Reg8(3);
+			SRType shift_t = SRType.LSL;
+			int shift_n = 0;
+			return ExecuteCore_CMP_register(Encoding.T1, n, m, shift_t, shift_n);
+		}
+
+		uint ExecuteThumb_SpecialBX()
+		{
+			uint opcode = (instruction >> 6) & _.b1111;
+			switch (opcode)
+			{
+				case _.b0000:
+					return Execute_Unhandled("ADD (low register) on page A8-24 [v6T2*] *unpredictable in earlier variants");
+				case _.b0001:
+				case _.b0010:
+				case _.b0011:
+					return Execute_ADD_register_T2();
+				case _.b0100:
+					return _UNPREDICTABLE();
+				case _.b0101:
+				case _.b0110:
+				case _.b0111:
+					return Execute_Unhandled("CMP (high register) on page A8-82 [v4t]");
+				case _.b1000:
+					return Execute_MOV_register_T1();
+				case _.b1001:
+				case _.b1010:
+				case _.b1011:
+					return Execute_MOV_register_T1();
+				case _.b1100:
+				case _.b1101:
+					return Execute_BX_T1();
+				case _.b1110:
+				case _.b1111:
+					return Execute_BLX_register_T1();
+				default: throw new InvalidOperationException("decode fail");
+
+			}
+		}
+
+		uint Execute_BLX_register_T1()
+		{
+			//A8.6.24
+			uint m = Reg16(3);
+			if (m == 15) _FlagUnpredictable();
+			if (_InITBlock() && !_LastInITBlock()) _FlagUnpredictable();
+			return ExecuteCore_BLX_register(Encoding.T1, m);
+		}
+
+		uint Execute_BX_T1()
+		{
+			//A8.6.25
+			uint m = Reg16(3);
+			if (_InITBlock() && !_LastInITBlock()) return _UNPREDICTABLE();
+			if (disassemble)
+				return DISNEW("BX", "<Rm!>", m);
+			_BXWritePC(r[m]);
+			return 1;
+		}
+
+		uint ExecuteThumb_ADR_T1()
+		{
+			//A8.6.10 ADR
+			uint d = Reg8(8);
+			uint imm8 = instruction & 0xFF;
+			uint imm32 = _ZeroExtend_32(imm8 << 2);
+			const bool add = true;
+			return ExecuteCore_ADR(Encoding.T1, d, imm32, add);
+		}
+
+		uint Execute_ADD_SP_plus_immediate_T2()
+		{
+			//A8.6.8 ADD SP plus immediate
+			uint d = 13;
+			uint imm7 = (instruction & 0xFF);
+			bool setflags = false;
+			uint imm32 = _ZeroExtend_32(imm7 << 2);
+			return ExecuteCore_ADD_SP_plus_immedate(Encoding.T2, d, setflags, imm32);
+		}
+
+		uint Execute_ADD_SP_plus_immediate_T1()
+		{
+			//A8.6.8 ADD SP plus immediate
+			//A8-28
+			uint d = Reg8(8);
+			uint imm8 = (instruction & 0xFF);
+			bool setflags = false;
+			uint imm32 = _ZeroExtend_32(imm8 << 2);
+			return ExecuteCore_ADD_SP_plus_immedate(Encoding.T1, d, setflags, imm32);
+		}
+
+		Decoder decoder_ExecuteThumb_Misc16 = new Decoder();
+		uint ExecuteThumb_Misc16()
+		{
+			decoder_ExecuteThumb_Misc16.Ensure(() => decoder_ExecuteThumb_Misc16
+				.d("opcode", 7)
+				.r("opcode == #0110010", () => Execute_Unhandled("SETEND on page A8-314"))
+				.r("opcode == #0110011", () => Execute_Unhandled("CPS on page B6-3"))
+				.r("opcode == #00000xx", () => Execute_ADD_SP_plus_immediate_T2())
+				.r("opcode == #00001xx", () => Execute_SUB_SP_minus_immediate_T1())
+				.r("opcode == #0001xxx", () => Execute_Unhandled("CBNZ,CBZ on page A8-66 [v6T2]"))
+				.r("opcode == #001000x", () => Execute_Unhandled("SXTH on page A8-444"))
+				.r("opcode == #001001x", () => Execute_Unhandled("SXTB on page A8-440"))
+				.r("opcode == #001010x", () => Execute_UXTH_T1())
+				.r("opcode == #001011x", () => Execute_UXTB_T1())
+				.r("opcode == #0011xxx", () => Execute_Unhandled("CBNZ,CBZ on page A8-66 [v6T2]"))
+				.r("opcode == #010xxxx", () => Execute_PUSH_T1())
+				.r("opcode == #1001xxx", () => Execute_Unhandled("CBNZ,CBZ on page A8-66 [v6T2]"))
+				.r("opcode == #101000x", () => Execute_Unhandled("REV on page A8-272"))
+				.r("opcode == #101001x", () => Execute_Unhandled("REV16 on page A8-274"))
+				.r("opcode == #101011x", () => Execute_Unhandled("REVSH on page A8-276"))
+				.r("opcode == #110xxxx", () => Execute_POP_T1())
+				.r("opcode == #1110xxx", () => Execute_Unhandled("BKPT on page A8-56"))
+				.r("opcode == #1111xxx", () => Execute_Unhandled("If-Then and hints on page A6-12"))
+				);
+
+			uint opcode = (instruction >> 5) & 0x7F;
+			decoder_ExecuteThumb_Misc16.Evaluate(opcode);
+			return 1;
+		}
+
+		uint Execute_POP_T1()
+		{
+			//A8.6.122
+			uint P = _.BIT8(instruction);
+			uint registers = (P << 15) | (instruction & 0xFF);
+			bool UnalignedAllowed = false;
+			if (registers == 0) { _UNPREDICTABLE(); return 1; }
+			if (P == 1 && _InITBlock() && !_LastInITBlock()) { _UNPREDICTABLE(); return 1; }
+			if (disassemble)
+				return DISNEW("pop<c>", "<registers>", registers);
+			return ExecuteCore_POP(Encoding.T1, registers, UnalignedAllowed);
+		}
+
+		uint Execute_SUB_SP_minus_immediate_T1()
+		{
+			//A8.6.215 SUB (SP minus immediate)
+			const uint d = 13;
+			uint imm7 = instruction & 0x7F;
+			bool setflags = false;
+			uint imm32 = _ZeroExtend_32(imm7 << 2);
+			return ExecuteCore_SUB_SP_minus_immediate(Encoding.T1, d, setflags, imm32);
+		}
+
+		uint Execute_UXTH_T1()
+		{
+			//A8.6.265
+			uint d = Reg8(0);
+			uint m = Reg8(3);
+			const uint rotation = 0;
+			return ExecuteCore_UXTH(Encoding.T1, d, m, rotation);
+		}
+
+		uint Execute_UXTB_T1()
+		{
+			//A8.6.263
+			uint d = Reg8(0);
+			uint m = Reg8(3);
+			const uint rotation = 0;
+			return ExecuteCore_UXTB(Encoding.T1, d, m, rotation);
+		}
+
+		uint Execute_PUSH_T1()
+		{
+			//A8.6.123
+			uint M = _.BIT8(instruction);
+			uint regs = (M << 14) | (instruction & 0xFF);
+			if (_.BitCount(regs) < 1) unpredictable = true;
+
+			return ExecuteCore_PUSH(Encoding.T1, regs, false);
+		}
+
+		uint Execute_LDM_LDMIA_LDMFD_T1()
+		{
+			//A8.6.53 LDM/LDMIA/LDMFD
+			if (_CurrentInstrSet() == EInstrSet.THUMBEE) throw new NotImplementedException();
+			uint n = Reg8(8);
+			uint registers = instruction & 0xFF;
+			bool wback = (_.BITN((int)n, registers) == 0);
+			if (registers == 0) _FlagUnpredictable();
+			return ExecuteCore_LDM_LDMIA_LDMFD(Encoding.T1, wback, n, registers);
+		}
+
+		uint Execute_STM_STMIA_STMEA_T1()
+		{
+			//A8.6.189 STM/STMIA/STMEA
+			if (_CurrentInstrSet() == EInstrSet.THUMBEE) throw new NotImplementedException();
+			uint n = Reg8(8);
+			uint registers = instruction & 0xFF;
+			bool wback = true;
+			if (registers == 0) unpredictable = true;
+			return ExecuteCore_STM_STMIA_STMEA(Encoding.T1, wback, n, registers);
+		}
+
+		uint ExecuteThumb_LDM() { return Execute_Unhandled("ExecuteThumb_LDM"); }
+		uint ExecuteThumb_CondBr_And_SVC()
+		{
+			uint opcode = (instruction >> 8) & 0xF;
+			switch (opcode)
+			{
+				case _.b0000:
+				case _.b0001:
+				case _.b0010:
+				case _.b0011:
+				case _.b0100:
+				case _.b0101:
+				case _.b0110:
+				case _.b0111:
+				case _.b1000:
+				case _.b1001:
+				case _.b1010:
+				case _.b1011:
+				case _.b1100:
+				case _.b1101:
+					return Execute_B_T1();
+
+				case _.b1110: return _PERMANENTLY_UNDEFINED();
+				case _.b1111: return Execute_SVC_T1();
+
+				default: throw new InvalidOperationException("decode fail");
+			}
+		}
+		uint ExecuteThumb_UnCondBr() { return Execute_Unhandled("ExecuteThumb_UnCondBr"); }
+
+		uint Execute_B_T2()
+		{
+			//A8.6.16 B
+			uint imm11 = instruction & 0x7FF;
+			int imm32 = _SignExtend_32(11, imm11 << 1);
+			if (_InITBlock() && !_LastInITBlock()) unpredictable = true;
+			return ExecuteCore_B(Encoding.T2, imm32);
+		}
+
+		uint Execute_B_T1()
+		{
+			//A8.6.16 B
+			uint imm8 = (instruction & 0xFF);
+			int imm32 = _SignExtend_32(9, imm8 << 1);
+			_currentCondVal = (instruction >> 8) & 0xF;
+			if (_InITBlock()) return _UNPREDICTABLE();
+			return ExecuteCore_B(Encoding.T1, imm32);
+		}
+
+		uint Execute_SVC_T1()
+		{
+			return Execute_Unhandled("Execute_SVC_T1");
+		}
+
+	}
+}
\ No newline at end of file
diff --git a/BizHawk.Emulation/CPUs/ARM/ARM.Pseudocode.cs b/BizHawk.Emulation/CPUs/ARM/ARM.Pseudocode.cs
new file mode 100644
index 0000000000..646ee1066f
--- /dev/null
+++ b/BizHawk.Emulation/CPUs/ARM/ARM.Pseudocode.cs
@@ -0,0 +1,460 @@
+using System;
+using System.Text;
+using System.Runtime.InteropServices;
+
+namespace BizHawk.Emulation.CPUs.ARM
+{
+
+	/// <summary>
+	/// this file contains functions transcribed as closely as possible from arm's docs. theyre all _Prefixed
+	/// </summary>
+	partial class ARM
+	{
+		uint _ArchVersion() { return 6; }
+
+		enum EInstrSet
+		{
+			ARM, THUMB, THUMBEE
+		}
+		EInstrSet _CurrentInstrSet() { return APSR.T == 1 ? EInstrSet.THUMB : EInstrSet.ARM; }
+		void _SelectInstrSet(EInstrSet newset)
+		{
+			//TODO - copy from manual
+			APSR.T = (newset == EInstrSet.THUMB) ? 1U : 0U;
+		}
+
+		uint _Align(uint value, int level)
+		{
+			return (uint)(value & ~(level - 1));
+		}
+
+		bool _InITBlock() { return false; }
+		bool _LastInITBlock()
+		{
+			//how the hell are we going to implement this?
+			return false;
+		}
+
+		int _LowestSetBit(uint val, int size)
+		{
+			for (int i = 0; i < size; i++)
+				if (_.BITN(i, val) == 1) return i;
+			return size;
+		}
+
+		void _FlagUnpredictable()
+		{
+			unpredictable = true;
+		}
+
+		uint _UNPREDICTABLE()
+		{
+			_FlagUnpredictable();
+			Console.WriteLine("UNPREDICTABLE!");
+			return 1;
+		}
+
+		bool _CheckVFPEnabled(bool arg)
+		{
+			return true;
+		}
+
+		void _SerializeVFP() { }
+		void _VFPExcBarrier() { }
+
+		uint _PERMANENTLY_UNDEFINED()
+		{
+			Console.WriteLine("PERMANENTLY UNDEFINED! this space will not be allocated in future. (why not?)");
+			return 0;
+		}
+
+		ulong _UNKNOWN(int bits, ulong data)
+		{
+			Console.WriteLine("UNKNOWN {0} BITS! (using {0:x16} anyway)", bits, data);
+			return data;
+		}
+
+		uint _PCStoreValue()
+		{
+			// This function returns the PC value. On architecture versions before ARMv7, it
+			// is permitted to instead return PC+4, provided it does so consistently. It is
+			// used only to describe ARM instructions, so it returns the address of the current
+			// instruction plus 8 (normally) or 12 (when the alternative is permitted).
+			return PC;
+		}
+
+		uint MemA_Read32(uint addr)
+		{
+			addr = _Align(addr, 4);
+			return bus.Read32(AT.READ, addr);
+		}
+
+		void _SetExclusiveMonitors(uint address, int size)
+		{
+			//TODO!!! boring!!
+
+		}
+
+		bool _ExclusiveMonitorsPass(uint address, int size)
+		{
+			//TODO!!! boring!!
+			return true;
+		}
+
+		void MemA_Write32(uint addr, uint val)
+		{
+			addr = _Align(addr, 4);
+			bus.Write32(AT.WRITE, addr, val);
+		}
+
+		void MemU_Write08(uint addr, uint val)
+		{
+			bus.Write08(AT.WRITE, addr, (byte)val);
+		}
+
+		byte MemU_Read08(uint addr)
+		{
+			return bus.Read08(AT.READ, addr);
+		}
+
+		ushort MemU_Read16(uint addr)
+		{
+			return bus.Read08(AT.READ, addr);
+		}
+
+		void MemU_Write16(uint addr, uint val)
+		{
+			bus.Write16(AT.WRITE, addr, (ushort)val);
+		}
+
+		void MemU_Write32(uint addr, uint val)
+		{
+			bus.Write32(AT.WRITE, addr, val);
+		}
+
+		uint MemU_Read32(uint addr)
+		{
+			return bus.Read32(AT.READ, addr);
+		}
+
+		uint _MemU(uint addr, uint size)
+		{
+			//TODO - differentiate from MemA
+			switch (size)
+			{
+				case 4: return bus.Read32(AT.READ, addr);
+				case 2: return bus.Read16(AT.READ, addr);
+				case 1: return bus.Read08(AT.READ, addr);
+				default: throw new ArgumentException();
+			}
+		}
+
+		uint _MemA(uint addr, uint size)
+		{
+			//TODO - differentiate from MemU
+			switch (size)
+			{
+				case 4: return bus.Read32(AT.READ, addr);
+				case 2: return bus.Read16(AT.READ, addr);
+				case 1: return bus.Read08(AT.READ, addr);
+				default: throw new ArgumentException();
+			}
+		}
+
+
+		void _ALUWritePC(uint address)
+		{
+			if (_ArchVersion() >= 7 && _CurrentInstrSet() == EInstrSet.ARM)
+				_BXWritePC(address);
+			else
+				_BranchWritePC(address);
+		}
+
+		void _BranchWritePC(uint address)
+		{
+			if (_CurrentInstrSet() == EInstrSet.ARM)
+			{
+				if (_ArchVersion() < 6 && ((address & 0x3) != 0)) { _UNPREDICTABLE(); }
+				_BranchTo((uint)(address & ~3));
+			}
+			else
+				_BranchTo((uint)(address & ~1));
+		}
+
+		void _BranchTo(uint address)
+		{
+			_R[15] = address;
+			next_instruct_adr = address;
+		}
+
+		uint _LoadWritePC(uint address)
+		{
+			if (_ArchVersion() >= 5)
+				_BXWritePC(address);
+			else
+				_BranchWritePC(address);
+			return 1;
+		}
+
+		void _BXWritePC(uint address)
+		{
+			if (_CurrentInstrSet() == EInstrSet.THUMBEE)
+			{
+				throw new InvalidOperationException();
+			}
+			else
+			{
+				if (_.BIT0(address) == 1)
+				{
+					_SelectInstrSet(EInstrSet.THUMB);
+					_BranchTo((uint)(address & ~1));
+				}
+				else if (_.BIT1(address) == 0)
+				{
+					_SelectInstrSet(EInstrSet.ARM);
+					_BranchTo(address);
+				}
+				else
+				{
+					_UNPREDICTABLE();
+				}
+			}
+		}
+
+		enum SRType
+		{
+			LSL = 0, LSR = 1, ASR = 2, ROR = 3, RRX = 4
+		}
+
+		uint _ZeroExtend_32(uint val)
+		{
+			//TODO - any tricky behaviour from doc?
+			return val;
+		}
+
+		int _SignExtend_32(int bits_present, uint val)
+		{
+			int temp = (int)val;
+			int shift = 32 - bits_present;
+			temp <<= (shift);
+			return temp >> shift;
+		}
+
+		SRType shift_t;
+		int shift_n;
+		/// <summary>
+		/// decodes shifter arguments to shift_t and shift_n
+		/// </summary>
+		void _DecodeImmShift(uint arg, uint imm5)
+		{
+			switch (arg)
+			{
+				case _.b00:
+					shift_t = SRType.LSL;
+					shift_n = (int)imm5;
+					break;
+				case _.b01:
+					shift_t = SRType.LSR;
+					if (imm5 == 0) shift_n = 32;
+					else shift_n = (int)imm5;
+					break;
+				case _.b10:
+					shift_t = SRType.LSR;
+					if (imm5 == 0) shift_n = 32;
+					else shift_n = (int)imm5;
+					break;
+				case _.b11:
+					if (imm5 == 0)
+					{
+						shift_t = SRType.RRX;
+						shift_n = 1;
+					}
+					else
+					{
+						shift_t = SRType.ROR;
+						shift_n = (int)imm5;
+					}
+					break;
+			}
+		}
+
+		bool _UnalignedSupport() { return false; /*TODO*/ }
+
+
+
+		bool _NullCheckIfThumbEE(uint num) { return false; }
+
+		bool _IsZeroBit(uint value) { return value == 0; }
+
+		uint _Shift(uint value, SRType type, int amount, Bit carry_in)
+		{
+			uint result; Bit carry_out;
+			_Shift_C(value, type, amount, carry_in, out result, out carry_out);
+			return result;
+		}
+
+		void _Shift_C(uint value, SRType type, int amount, Bit carry_in, out uint result, out Bit carry_out)
+		{
+			if (type == SRType.RRX && amount == 1) throw new InvalidOperationException("bogus shift");
+			if (amount == 0)
+			{
+				result = value;
+				carry_out = carry_in;
+			}
+			else
+			{
+				switch (type)
+				{
+					case SRType.LSL: _LSL_C(value, amount, out result, out carry_out); break;
+					case SRType.LSR: _LSR_C(value, amount, out result, out carry_out); break;
+					case SRType.ASR: _ASR_C(value, amount, out result, out carry_out); break;
+					case SRType.ROR: _ROR_C(value, amount, out result, out carry_out); break;
+					case SRType.RRX: _RRX_C(value, carry_in, out result, out carry_out); break;
+					default: throw new ArgumentException();
+				}
+			}
+		}
+
+		void _Assert(bool condition)
+		{
+#if DEBUG
+			System.Diagnostics.Debug.Assert(condition);
+#endif
+		}
+
+		void _LSL_C(uint x, int shift, out uint result, out Bit carry_out)
+		{
+			//A2-5
+			_Assert(shift > 0);
+			ulong extended_x = (ulong)x << shift;
+			result = (uint)extended_x;
+			carry_out = _.BIT32(extended_x);
+		}
+
+		uint _LSL(uint x, int shift)
+		{
+			//A2-5
+			_Assert(shift >= 0);
+			if (shift == 0) return x;
+			else
+			{
+				uint result;
+				Bit carry_out;
+				_LSL_C(x, shift, out result, out carry_out);
+				return result;
+			}
+		}
+
+		void _LSR_C(uint x, int shift, out uint result, out Bit carry_out)
+		{
+			//A2-6 but coded my own way
+			_Assert(shift > 0);
+			result = x >> shift;
+			carry_out = ((x >> (shift - 1)) & 1);
+		}
+
+		uint _LSR(uint x, int shift)
+		{
+			//A2-6
+			_Assert(shift >= 0);
+			if (shift == 0) return x;
+			else
+			{
+				uint result;
+				Bit carry_out;
+				_LSR_C(x, shift, out result, out carry_out);
+				return result;
+			}
+		}
+
+		void _ASR_C(uint x, int shift, out uint result, out Bit carry_out)
+		{
+			//A2-6 but coded my own way
+			_Assert(shift > 0);
+			int temp = (int)x;
+			temp >>= shift;
+			result = (uint)temp;
+			carry_out = ((x >> (shift - 1)) & 1);
+		}
+
+		uint _ASR(uint x, int shift)
+		{
+			//A2-6
+			_Assert(shift >= 0);
+			if (shift == 0) return x;
+			else
+			{
+				uint result;
+				Bit carry_out;
+				_ASR_C(x, shift, out result, out carry_out);
+				return result;
+			}
+		}
+
+		void _ROR_C(uint x, int shift, out uint result, out Bit carry_out)
+		{
+			//A2-6 
+			_Assert(shift != 0);
+			int m = shift & 31;
+			result = _LSR(x, m) | _LSL(x, 32 - m);
+			carry_out = _.BIT31(result);
+		}
+
+		uint _ROR(uint x, int shift)
+		{
+			//A5-7 //TODO - there is an error in this pseudocode. report it to ARM! (if(n==0) should be if(shift==0)
+			if (shift == 0) return x;
+			else
+			{
+				uint result;
+				Bit carry_out;
+				_ROR_C(x, shift, out result, out carry_out);
+				return result;
+			}
+		}
+
+		void _RRX_C(uint x, Bit carry_in, out uint result, out Bit carry_out)
+		{
+			//A2-7
+			result = ((carry_in) ? (uint)0x80000000 : (uint)0) | (x >> 1);
+			carry_out = _.BIT0(x);
+		}
+
+		uint _RRX(uint x, Bit carry_in)
+		{
+			uint result;
+			Bit carry_out;
+			_RRX_C(x, carry_in, out result, out carry_out);
+			return result;
+		}
+
+		uint _ARMExpandImm(uint imm12)
+		{
+			//A5-10
+			uint imm32;
+			Bit trash;
+			_ARMExpandImm_C(imm12, 0, out imm32, out trash); //DEVIATION: docs say to pass in APSR.C even though it doesnt matter.
+			return imm32;
+		}
+
+		void _ARMExpandImm_C(uint imm12, Bit carry_in, out uint imm32, out Bit carry_out)
+		{
+			//A5-10
+			uint unrotated_value = imm12 & 0xFF;
+			_Shift_C(unrotated_value, SRType.ROR, 2 * (int)((imm12 >> 8) & 0xF), carry_in, out imm32, out carry_out);
+		}
+
+		uint alu_result_32;
+		Bit alu_carry_out;
+		Bit alu_overflow;
+		void _AddWithCarry32(uint x, uint y, Bit carry_in)
+		{
+			ulong unsigned_sum = (ulong)x + (ulong)y + (uint)carry_in;
+			long signed_sum = (long)(int)x + (long)(int)y + (uint)carry_in;
+			alu_result_32 = (uint)(unsigned_sum & 0xFFFFFFFF);
+			alu_carry_out = (alu_result_32 == unsigned_sum) ? 0 : 1;
+			alu_overflow = ((long)(int)alu_result_32 == signed_sum) ? 0 : 1;
+		}
+	}
+
+}
\ No newline at end of file
diff --git a/BizHawk.Emulation/CPUs/ARM/ARM.cs b/BizHawk.Emulation/CPUs/ARM/ARM.cs
new file mode 100644
index 0000000000..a4e5c34c0d
--- /dev/null
+++ b/BizHawk.Emulation/CPUs/ARM/ARM.cs
@@ -0,0 +1,211 @@
+using System;
+using System.Diagnostics;
+using System.Text;
+using System.Runtime.InteropServices;
+
+namespace BizHawk.Emulation.CPUs.ARM
+{
+	//reference: ARM manual DDI0406B
+
+	public enum AT
+	{
+		PEEK, POKE, READ, WRITE, FETCH
+	}
+
+	//this may need to be rearchitectured to pass the entire instruction, as specified in the docs...
+	public interface ICoprocessorSet
+	{
+		//read
+		uint MRC(uint cp, uint opc1, uint t, uint crn, uint crm, uint opc2);
+		string Describe(uint cp, uint opc1, uint t, uint crn, uint crm, uint opc2);
+	}
+
+	public interface ARM_SYS
+	{
+		uint svc(uint num);
+		string svc_name(uint num);
+		ICoprocessorSet coprocessors { get; }
+	}
+
+	public interface ARM_BUS
+	{
+		byte Read08(AT at, uint addr);
+		ushort Read16(AT at, uint addr);
+		uint Read32(AT at, uint addr);
+		void Write08(AT at, uint addr, byte val);
+		void Write16(AT at, uint addr, ushort val);
+		void Write32(AT at, uint addr, uint val);
+		void Write64(AT at, uint addr, ulong val);
+	}
+
+	public unsafe partial class ARM
+	{
+		public ARM_SYS sys;
+		public ARM_BUS bus;
+
+		public enum Mode
+		{
+			USR = 0x10,
+			FIQ = 0x11,
+			IRQ = 0x12,
+			SVC = 0x13,
+			ABT = 0x17,
+			UND = 0x1B,
+			SYS = 0x1F
+		}
+
+		public struct Status_Reg
+		{
+			//public uint val;
+			//public uint mode { get { return val & 0x1F; } set { val = (uint)((val & ~0x1F) | (value & 0x1F)); } }
+			//public uint T { get { return val & 0x20; } set { val = (uint)((val & ~0x20) | (value & 0x20)); } }
+			//public uint F { get { return val & 0x40; } set { val = (uint)((val & ~0x40) | (value & 0x40)); } }
+			//public uint I { get { return val & 0x80; } set { val = (uint)((val & ~0x80) | (value & 0x80)); } }
+			//public uint N { get { return val & 0x80000000; } set { val = (uint)((val & ~0x80000000) | (value & 0x80000000)); } }
+
+			public Mode mode;
+			public Bit T, F, I, Q, V, C, Z, N;
+			//todo - consider combining the condition flags together for various speedups
+		}
+
+		public uint next_instruct_adr;
+		public uint instruct_adr;
+		public uint instruction;
+		uint thumb_32bit_extra;
+		bool thumb_32bit;
+
+		public class Registers
+		{
+			ARM cpu;
+			public Registers(ARM cpu) { this.cpu = cpu; }
+			public uint this[int n] { get { return this[(uint)n]; } set { this[(uint)n] = value; } }
+			public uint this[uint n]
+			{
+				//this is a bit different than the docs, in the interest of performance
+				get
+				{
+					if (n == 15)
+					{
+						uint offset = (cpu._CurrentInstrSet() == EInstrSet.ARM ? 8U : 4U);
+						return cpu._R[15] + offset;
+					}
+					else
+					{
+						//TODO - junk about security and monitor mode and FIQ and whatnot
+						return cpu._R[n];
+					}
+				}
+				set
+				{
+					Debug.Assert(n >= 0 && n <= 14);
+					//TODO - junk about security and monitor mode and FIQ and whatnot
+					if (n == 13 && (value & 3) != 0 && cpu._CurrentInstrSet() != EInstrSet.ARM) cpu._FlagUnpredictable();
+					cpu._R[n] = value;
+				}
+			}
+		}
+
+		//todo: make R[] indexer which is defined as in manual with an assert when R[15] is written to
+		public Registers r;
+		uint[] _R = new uint[16];
+		public Status_Reg APSR;
+		public Status_Reg SPSR;
+
+		public uint SP { get { return r[13]; } set { r[13] = value; } }
+		public uint LR { get { return r[14]; } set { r[14] = value; } }
+		public uint PC { get { return r[15]; } set { r[15] = value; } }
+		
+		uint R13_usr, R14_usr;
+		uint R13_svc, R14_svc;
+		uint R13_abt, R14_abt;
+		uint R13_und, R14_und;
+		uint R13_irq, R14_irq;
+		uint R8_fiq, R9_fiq, R10_fiq, R11_fiq, R12_fiq, R13_fiq, R14_fiq;
+		Status_Reg SPSR_svc, SPSR_abt, SPSR_und, SPSR_irq, SPSR_fiq;
+
+
+		uint FPSCR;
+
+		public ARM(ARM_SYS sys, ARM_BUS bus)
+		{
+			this.sys = sys;
+			this.bus = bus;
+			r = new Registers(this);
+		}
+
+		//disassembly state
+		public bool disassemble;
+		public bool nstyle;
+		public string disassembly;
+
+		enum Encoding
+		{
+			T1, T2, T3, T4,
+			A1, A2, A3, A4
+		}
+		bool EncodingT(Encoding e)
+		{
+			return e == Encoding.T1 || e == Encoding.T2 || e == Encoding.T3 || e == Encoding.T4;
+		}
+		bool EncodingA(Encoding e)
+		{
+			return e == Encoding.A1 || e == Encoding.A2 || e == Encoding.A3 || e == Encoding.A4;
+		}
+
+		public enum TraceType
+		{
+			Full, Short
+		}
+		ulong tracetr = 0;
+		public string Trace(TraceType tt)
+		{
+			disassemble = true;
+			Execute();
+			StringBuilder sb = new StringBuilder(256);
+			sb.AppendFormat("{0}:{1}:{2:X8} ", tracetr, _CurrentInstrSet() == EInstrSet.ARM ? 'A' : 'T', instruct_adr);
+			tracetr++;
+			if(thumb_32bit)
+				sb.AppendFormat("{0:X4}{1:X4} ", instruction,thumb_32bit_extra);
+			else
+				sb.AppendFormat("{0:X8} ",instruction);
+			sb.Append(disassembly.PadRight(30,' '));
+			if(tt == TraceType.Full)
+				for(int i=0;i<16;i++)
+					sb.AppendFormat(" {0:X8}", r[i]);
+			disassemble = false;
+			return sb.ToString();
+		}
+
+		public uint Fetch()
+		{
+			thumb_32bit = false;
+			instruct_adr = next_instruct_adr;
+			if (APSR.T)
+			{
+				//THUMB:
+				Debug.Assert((instruct_adr & 1) == 0);
+				_R[15] = instruct_adr;
+				next_instruct_adr += 2;
+				instruction = bus.Read16(AT.FETCH, instruct_adr);
+			}
+			else
+			{
+				Debug.Assert((instruct_adr & 3) == 0);
+				_R[15] = instruct_adr;
+				next_instruct_adr += 4;
+				instruction = bus.Read32(AT.FETCH, instruct_adr);
+			}
+
+			return 1;
+		}
+
+		void ThumbFetchExtra()
+		{
+			thumb_32bit = true;
+			thumb_32bit_extra = bus.Read16(AT.FETCH, next_instruct_adr);
+			next_instruct_adr = instruct_adr + 2;
+		}
+
+	}
+
+}
\ No newline at end of file
diff --git a/BizHawk.Emulation/CPUs/ARM/_.cs b/BizHawk.Emulation/CPUs/ARM/_.cs
new file mode 100644
index 0000000000..5afa778b5f
--- /dev/null
+++ b/BizHawk.Emulation/CPUs/ARM/_.cs
@@ -0,0 +1,8270 @@
+partial class _
+{
+	public const int b000000000000 = 0;
+	public const int b000000000001 = 1;
+	public const int b000000000010 = 2;
+	public const int b000000000011 = 3;
+	public const int b000000000100 = 4;
+	public const int b000000000101 = 5;
+	public const int b000000000110 = 6;
+	public const int b000000000111 = 7;
+	public const int b000000001000 = 8;
+	public const int b000000001001 = 9;
+	public const int b000000001010 = 10;
+	public const int b000000001011 = 11;
+	public const int b000000001100 = 12;
+	public const int b000000001101 = 13;
+	public const int b000000001110 = 14;
+	public const int b000000001111 = 15;
+	public const int b000000010000 = 16;
+	public const int b000000010001 = 17;
+	public const int b000000010010 = 18;
+	public const int b000000010011 = 19;
+	public const int b000000010100 = 20;
+	public const int b000000010101 = 21;
+	public const int b000000010110 = 22;
+	public const int b000000010111 = 23;
+	public const int b000000011000 = 24;
+	public const int b000000011001 = 25;
+	public const int b000000011010 = 26;
+	public const int b000000011011 = 27;
+	public const int b000000011100 = 28;
+	public const int b000000011101 = 29;
+	public const int b000000011110 = 30;
+	public const int b000000011111 = 31;
+	public const int b000000100000 = 32;
+	public const int b000000100001 = 33;
+	public const int b000000100010 = 34;
+	public const int b000000100011 = 35;
+	public const int b000000100100 = 36;
+	public const int b000000100101 = 37;
+	public const int b000000100110 = 38;
+	public const int b000000100111 = 39;
+	public const int b000000101000 = 40;
+	public const int b000000101001 = 41;
+	public const int b000000101010 = 42;
+	public const int b000000101011 = 43;
+	public const int b000000101100 = 44;
+	public const int b000000101101 = 45;
+	public const int b000000101110 = 46;
+	public const int b000000101111 = 47;
+	public const int b000000110000 = 48;
+	public const int b000000110001 = 49;
+	public const int b000000110010 = 50;
+	public const int b000000110011 = 51;
+	public const int b000000110100 = 52;
+	public const int b000000110101 = 53;
+	public const int b000000110110 = 54;
+	public const int b000000110111 = 55;
+	public const int b000000111000 = 56;
+	public const int b000000111001 = 57;
+	public const int b000000111010 = 58;
+	public const int b000000111011 = 59;
+	public const int b000000111100 = 60;
+	public const int b000000111101 = 61;
+	public const int b000000111110 = 62;
+	public const int b000000111111 = 63;
+	public const int b000001000000 = 64;
+	public const int b000001000001 = 65;
+	public const int b000001000010 = 66;
+	public const int b000001000011 = 67;
+	public const int b000001000100 = 68;
+	public const int b000001000101 = 69;
+	public const int b000001000110 = 70;
+	public const int b000001000111 = 71;
+	public const int b000001001000 = 72;
+	public const int b000001001001 = 73;
+	public const int b000001001010 = 74;
+	public const int b000001001011 = 75;
+	public const int b000001001100 = 76;
+	public const int b000001001101 = 77;
+	public const int b000001001110 = 78;
+	public const int b000001001111 = 79;
+	public const int b000001010000 = 80;
+	public const int b000001010001 = 81;
+	public const int b000001010010 = 82;
+	public const int b000001010011 = 83;
+	public const int b000001010100 = 84;
+	public const int b000001010101 = 85;
+	public const int b000001010110 = 86;
+	public const int b000001010111 = 87;
+	public const int b000001011000 = 88;
+	public const int b000001011001 = 89;
+	public const int b000001011010 = 90;
+	public const int b000001011011 = 91;
+	public const int b000001011100 = 92;
+	public const int b000001011101 = 93;
+	public const int b000001011110 = 94;
+	public const int b000001011111 = 95;
+	public const int b000001100000 = 96;
+	public const int b000001100001 = 97;
+	public const int b000001100010 = 98;
+	public const int b000001100011 = 99;
+	public const int b000001100100 = 100;
+	public const int b000001100101 = 101;
+	public const int b000001100110 = 102;
+	public const int b000001100111 = 103;
+	public const int b000001101000 = 104;
+	public const int b000001101001 = 105;
+	public const int b000001101010 = 106;
+	public const int b000001101011 = 107;
+	public const int b000001101100 = 108;
+	public const int b000001101101 = 109;
+	public const int b000001101110 = 110;
+	public const int b000001101111 = 111;
+	public const int b000001110000 = 112;
+	public const int b000001110001 = 113;
+	public const int b000001110010 = 114;
+	public const int b000001110011 = 115;
+	public const int b000001110100 = 116;
+	public const int b000001110101 = 117;
+	public const int b000001110110 = 118;
+	public const int b000001110111 = 119;
+	public const int b000001111000 = 120;
+	public const int b000001111001 = 121;
+	public const int b000001111010 = 122;
+	public const int b000001111011 = 123;
+	public const int b000001111100 = 124;
+	public const int b000001111101 = 125;
+	public const int b000001111110 = 126;
+	public const int b000001111111 = 127;
+	public const int b000010000000 = 128;
+	public const int b000010000001 = 129;
+	public const int b000010000010 = 130;
+	public const int b000010000011 = 131;
+	public const int b000010000100 = 132;
+	public const int b000010000101 = 133;
+	public const int b000010000110 = 134;
+	public const int b000010000111 = 135;
+	public const int b000010001000 = 136;
+	public const int b000010001001 = 137;
+	public const int b000010001010 = 138;
+	public const int b000010001011 = 139;
+	public const int b000010001100 = 140;
+	public const int b000010001101 = 141;
+	public const int b000010001110 = 142;
+	public const int b000010001111 = 143;
+	public const int b000010010000 = 144;
+	public const int b000010010001 = 145;
+	public const int b000010010010 = 146;
+	public const int b000010010011 = 147;
+	public const int b000010010100 = 148;
+	public const int b000010010101 = 149;
+	public const int b000010010110 = 150;
+	public const int b000010010111 = 151;
+	public const int b000010011000 = 152;
+	public const int b000010011001 = 153;
+	public const int b000010011010 = 154;
+	public const int b000010011011 = 155;
+	public const int b000010011100 = 156;
+	public const int b000010011101 = 157;
+	public const int b000010011110 = 158;
+	public const int b000010011111 = 159;
+	public const int b000010100000 = 160;
+	public const int b000010100001 = 161;
+	public const int b000010100010 = 162;
+	public const int b000010100011 = 163;
+	public const int b000010100100 = 164;
+	public const int b000010100101 = 165;
+	public const int b000010100110 = 166;
+	public const int b000010100111 = 167;
+	public const int b000010101000 = 168;
+	public const int b000010101001 = 169;
+	public const int b000010101010 = 170;
+	public const int b000010101011 = 171;
+	public const int b000010101100 = 172;
+	public const int b000010101101 = 173;
+	public const int b000010101110 = 174;
+	public const int b000010101111 = 175;
+	public const int b000010110000 = 176;
+	public const int b000010110001 = 177;
+	public const int b000010110010 = 178;
+	public const int b000010110011 = 179;
+	public const int b000010110100 = 180;
+	public const int b000010110101 = 181;
+	public const int b000010110110 = 182;
+	public const int b000010110111 = 183;
+	public const int b000010111000 = 184;
+	public const int b000010111001 = 185;
+	public const int b000010111010 = 186;
+	public const int b000010111011 = 187;
+	public const int b000010111100 = 188;
+	public const int b000010111101 = 189;
+	public const int b000010111110 = 190;
+	public const int b000010111111 = 191;
+	public const int b000011000000 = 192;
+	public const int b000011000001 = 193;
+	public const int b000011000010 = 194;
+	public const int b000011000011 = 195;
+	public const int b000011000100 = 196;
+	public const int b000011000101 = 197;
+	public const int b000011000110 = 198;
+	public const int b000011000111 = 199;
+	public const int b000011001000 = 200;
+	public const int b000011001001 = 201;
+	public const int b000011001010 = 202;
+	public const int b000011001011 = 203;
+	public const int b000011001100 = 204;
+	public const int b000011001101 = 205;
+	public const int b000011001110 = 206;
+	public const int b000011001111 = 207;
+	public const int b000011010000 = 208;
+	public const int b000011010001 = 209;
+	public const int b000011010010 = 210;
+	public const int b000011010011 = 211;
+	public const int b000011010100 = 212;
+	public const int b000011010101 = 213;
+	public const int b000011010110 = 214;
+	public const int b000011010111 = 215;
+	public const int b000011011000 = 216;
+	public const int b000011011001 = 217;
+	public const int b000011011010 = 218;
+	public const int b000011011011 = 219;
+	public const int b000011011100 = 220;
+	public const int b000011011101 = 221;
+	public const int b000011011110 = 222;
+	public const int b000011011111 = 223;
+	public const int b000011100000 = 224;
+	public const int b000011100001 = 225;
+	public const int b000011100010 = 226;
+	public const int b000011100011 = 227;
+	public const int b000011100100 = 228;
+	public const int b000011100101 = 229;
+	public const int b000011100110 = 230;
+	public const int b000011100111 = 231;
+	public const int b000011101000 = 232;
+	public const int b000011101001 = 233;
+	public const int b000011101010 = 234;
+	public const int b000011101011 = 235;
+	public const int b000011101100 = 236;
+	public const int b000011101101 = 237;
+	public const int b000011101110 = 238;
+	public const int b000011101111 = 239;
+	public const int b000011110000 = 240;
+	public const int b000011110001 = 241;
+	public const int b000011110010 = 242;
+	public const int b000011110011 = 243;
+	public const int b000011110100 = 244;
+	public const int b000011110101 = 245;
+	public const int b000011110110 = 246;
+	public const int b000011110111 = 247;
+	public const int b000011111000 = 248;
+	public const int b000011111001 = 249;
+	public const int b000011111010 = 250;
+	public const int b000011111011 = 251;
+	public const int b000011111100 = 252;
+	public const int b000011111101 = 253;
+	public const int b000011111110 = 254;
+	public const int b000011111111 = 255;
+	public const int b000100000000 = 256;
+	public const int b000100000001 = 257;
+	public const int b000100000010 = 258;
+	public const int b000100000011 = 259;
+	public const int b000100000100 = 260;
+	public const int b000100000101 = 261;
+	public const int b000100000110 = 262;
+	public const int b000100000111 = 263;
+	public const int b000100001000 = 264;
+	public const int b000100001001 = 265;
+	public const int b000100001010 = 266;
+	public const int b000100001011 = 267;
+	public const int b000100001100 = 268;
+	public const int b000100001101 = 269;
+	public const int b000100001110 = 270;
+	public const int b000100001111 = 271;
+	public const int b000100010000 = 272;
+	public const int b000100010001 = 273;
+	public const int b000100010010 = 274;
+	public const int b000100010011 = 275;
+	public const int b000100010100 = 276;
+	public const int b000100010101 = 277;
+	public const int b000100010110 = 278;
+	public const int b000100010111 = 279;
+	public const int b000100011000 = 280;
+	public const int b000100011001 = 281;
+	public const int b000100011010 = 282;
+	public const int b000100011011 = 283;
+	public const int b000100011100 = 284;
+	public const int b000100011101 = 285;
+	public const int b000100011110 = 286;
+	public const int b000100011111 = 287;
+	public const int b000100100000 = 288;
+	public const int b000100100001 = 289;
+	public const int b000100100010 = 290;
+	public const int b000100100011 = 291;
+	public const int b000100100100 = 292;
+	public const int b000100100101 = 293;
+	public const int b000100100110 = 294;
+	public const int b000100100111 = 295;
+	public const int b000100101000 = 296;
+	public const int b000100101001 = 297;
+	public const int b000100101010 = 298;
+	public const int b000100101011 = 299;
+	public const int b000100101100 = 300;
+	public const int b000100101101 = 301;
+	public const int b000100101110 = 302;
+	public const int b000100101111 = 303;
+	public const int b000100110000 = 304;
+	public const int b000100110001 = 305;
+	public const int b000100110010 = 306;
+	public const int b000100110011 = 307;
+	public const int b000100110100 = 308;
+	public const int b000100110101 = 309;
+	public const int b000100110110 = 310;
+	public const int b000100110111 = 311;
+	public const int b000100111000 = 312;
+	public const int b000100111001 = 313;
+	public const int b000100111010 = 314;
+	public const int b000100111011 = 315;
+	public const int b000100111100 = 316;
+	public const int b000100111101 = 317;
+	public const int b000100111110 = 318;
+	public const int b000100111111 = 319;
+	public const int b000101000000 = 320;
+	public const int b000101000001 = 321;
+	public const int b000101000010 = 322;
+	public const int b000101000011 = 323;
+	public const int b000101000100 = 324;
+	public const int b000101000101 = 325;
+	public const int b000101000110 = 326;
+	public const int b000101000111 = 327;
+	public const int b000101001000 = 328;
+	public const int b000101001001 = 329;
+	public const int b000101001010 = 330;
+	public const int b000101001011 = 331;
+	public const int b000101001100 = 332;
+	public const int b000101001101 = 333;
+	public const int b000101001110 = 334;
+	public const int b000101001111 = 335;
+	public const int b000101010000 = 336;
+	public const int b000101010001 = 337;
+	public const int b000101010010 = 338;
+	public const int b000101010011 = 339;
+	public const int b000101010100 = 340;
+	public const int b000101010101 = 341;
+	public const int b000101010110 = 342;
+	public const int b000101010111 = 343;
+	public const int b000101011000 = 344;
+	public const int b000101011001 = 345;
+	public const int b000101011010 = 346;
+	public const int b000101011011 = 347;
+	public const int b000101011100 = 348;
+	public const int b000101011101 = 349;
+	public const int b000101011110 = 350;
+	public const int b000101011111 = 351;
+	public const int b000101100000 = 352;
+	public const int b000101100001 = 353;
+	public const int b000101100010 = 354;
+	public const int b000101100011 = 355;
+	public const int b000101100100 = 356;
+	public const int b000101100101 = 357;
+	public const int b000101100110 = 358;
+	public const int b000101100111 = 359;
+	public const int b000101101000 = 360;
+	public const int b000101101001 = 361;
+	public const int b000101101010 = 362;
+	public const int b000101101011 = 363;
+	public const int b000101101100 = 364;
+	public const int b000101101101 = 365;
+	public const int b000101101110 = 366;
+	public const int b000101101111 = 367;
+	public const int b000101110000 = 368;
+	public const int b000101110001 = 369;
+	public const int b000101110010 = 370;
+	public const int b000101110011 = 371;
+	public const int b000101110100 = 372;
+	public const int b000101110101 = 373;
+	public const int b000101110110 = 374;
+	public const int b000101110111 = 375;
+	public const int b000101111000 = 376;
+	public const int b000101111001 = 377;
+	public const int b000101111010 = 378;
+	public const int b000101111011 = 379;
+	public const int b000101111100 = 380;
+	public const int b000101111101 = 381;
+	public const int b000101111110 = 382;
+	public const int b000101111111 = 383;
+	public const int b000110000000 = 384;
+	public const int b000110000001 = 385;
+	public const int b000110000010 = 386;
+	public const int b000110000011 = 387;
+	public const int b000110000100 = 388;
+	public const int b000110000101 = 389;
+	public const int b000110000110 = 390;
+	public const int b000110000111 = 391;
+	public const int b000110001000 = 392;
+	public const int b000110001001 = 393;
+	public const int b000110001010 = 394;
+	public const int b000110001011 = 395;
+	public const int b000110001100 = 396;
+	public const int b000110001101 = 397;
+	public const int b000110001110 = 398;
+	public const int b000110001111 = 399;
+	public const int b000110010000 = 400;
+	public const int b000110010001 = 401;
+	public const int b000110010010 = 402;
+	public const int b000110010011 = 403;
+	public const int b000110010100 = 404;
+	public const int b000110010101 = 405;
+	public const int b000110010110 = 406;
+	public const int b000110010111 = 407;
+	public const int b000110011000 = 408;
+	public const int b000110011001 = 409;
+	public const int b000110011010 = 410;
+	public const int b000110011011 = 411;
+	public const int b000110011100 = 412;
+	public const int b000110011101 = 413;
+	public const int b000110011110 = 414;
+	public const int b000110011111 = 415;
+	public const int b000110100000 = 416;
+	public const int b000110100001 = 417;
+	public const int b000110100010 = 418;
+	public const int b000110100011 = 419;
+	public const int b000110100100 = 420;
+	public const int b000110100101 = 421;
+	public const int b000110100110 = 422;
+	public const int b000110100111 = 423;
+	public const int b000110101000 = 424;
+	public const int b000110101001 = 425;
+	public const int b000110101010 = 426;
+	public const int b000110101011 = 427;
+	public const int b000110101100 = 428;
+	public const int b000110101101 = 429;
+	public const int b000110101110 = 430;
+	public const int b000110101111 = 431;
+	public const int b000110110000 = 432;
+	public const int b000110110001 = 433;
+	public const int b000110110010 = 434;
+	public const int b000110110011 = 435;
+	public const int b000110110100 = 436;
+	public const int b000110110101 = 437;
+	public const int b000110110110 = 438;
+	public const int b000110110111 = 439;
+	public const int b000110111000 = 440;
+	public const int b000110111001 = 441;
+	public const int b000110111010 = 442;
+	public const int b000110111011 = 443;
+	public const int b000110111100 = 444;
+	public const int b000110111101 = 445;
+	public const int b000110111110 = 446;
+	public const int b000110111111 = 447;
+	public const int b000111000000 = 448;
+	public const int b000111000001 = 449;
+	public const int b000111000010 = 450;
+	public const int b000111000011 = 451;
+	public const int b000111000100 = 452;
+	public const int b000111000101 = 453;
+	public const int b000111000110 = 454;
+	public const int b000111000111 = 455;
+	public const int b000111001000 = 456;
+	public const int b000111001001 = 457;
+	public const int b000111001010 = 458;
+	public const int b000111001011 = 459;
+	public const int b000111001100 = 460;
+	public const int b000111001101 = 461;
+	public const int b000111001110 = 462;
+	public const int b000111001111 = 463;
+	public const int b000111010000 = 464;
+	public const int b000111010001 = 465;
+	public const int b000111010010 = 466;
+	public const int b000111010011 = 467;
+	public const int b000111010100 = 468;
+	public const int b000111010101 = 469;
+	public const int b000111010110 = 470;
+	public const int b000111010111 = 471;
+	public const int b000111011000 = 472;
+	public const int b000111011001 = 473;
+	public const int b000111011010 = 474;
+	public const int b000111011011 = 475;
+	public const int b000111011100 = 476;
+	public const int b000111011101 = 477;
+	public const int b000111011110 = 478;
+	public const int b000111011111 = 479;
+	public const int b000111100000 = 480;
+	public const int b000111100001 = 481;
+	public const int b000111100010 = 482;
+	public const int b000111100011 = 483;
+	public const int b000111100100 = 484;
+	public const int b000111100101 = 485;
+	public const int b000111100110 = 486;
+	public const int b000111100111 = 487;
+	public const int b000111101000 = 488;
+	public const int b000111101001 = 489;
+	public const int b000111101010 = 490;
+	public const int b000111101011 = 491;
+	public const int b000111101100 = 492;
+	public const int b000111101101 = 493;
+	public const int b000111101110 = 494;
+	public const int b000111101111 = 495;
+	public const int b000111110000 = 496;
+	public const int b000111110001 = 497;
+	public const int b000111110010 = 498;
+	public const int b000111110011 = 499;
+	public const int b000111110100 = 500;
+	public const int b000111110101 = 501;
+	public const int b000111110110 = 502;
+	public const int b000111110111 = 503;
+	public const int b000111111000 = 504;
+	public const int b000111111001 = 505;
+	public const int b000111111010 = 506;
+	public const int b000111111011 = 507;
+	public const int b000111111100 = 508;
+	public const int b000111111101 = 509;
+	public const int b000111111110 = 510;
+	public const int b000111111111 = 511;
+	public const int b001000000000 = 512;
+	public const int b001000000001 = 513;
+	public const int b001000000010 = 514;
+	public const int b001000000011 = 515;
+	public const int b001000000100 = 516;
+	public const int b001000000101 = 517;
+	public const int b001000000110 = 518;
+	public const int b001000000111 = 519;
+	public const int b001000001000 = 520;
+	public const int b001000001001 = 521;
+	public const int b001000001010 = 522;
+	public const int b001000001011 = 523;
+	public const int b001000001100 = 524;
+	public const int b001000001101 = 525;
+	public const int b001000001110 = 526;
+	public const int b001000001111 = 527;
+	public const int b001000010000 = 528;
+	public const int b001000010001 = 529;
+	public const int b001000010010 = 530;
+	public const int b001000010011 = 531;
+	public const int b001000010100 = 532;
+	public const int b001000010101 = 533;
+	public const int b001000010110 = 534;
+	public const int b001000010111 = 535;
+	public const int b001000011000 = 536;
+	public const int b001000011001 = 537;
+	public const int b001000011010 = 538;
+	public const int b001000011011 = 539;
+	public const int b001000011100 = 540;
+	public const int b001000011101 = 541;
+	public const int b001000011110 = 542;
+	public const int b001000011111 = 543;
+	public const int b001000100000 = 544;
+	public const int b001000100001 = 545;
+	public const int b001000100010 = 546;
+	public const int b001000100011 = 547;
+	public const int b001000100100 = 548;
+	public const int b001000100101 = 549;
+	public const int b001000100110 = 550;
+	public const int b001000100111 = 551;
+	public const int b001000101000 = 552;
+	public const int b001000101001 = 553;
+	public const int b001000101010 = 554;
+	public const int b001000101011 = 555;
+	public const int b001000101100 = 556;
+	public const int b001000101101 = 557;
+	public const int b001000101110 = 558;
+	public const int b001000101111 = 559;
+	public const int b001000110000 = 560;
+	public const int b001000110001 = 561;
+	public const int b001000110010 = 562;
+	public const int b001000110011 = 563;
+	public const int b001000110100 = 564;
+	public const int b001000110101 = 565;
+	public const int b001000110110 = 566;
+	public const int b001000110111 = 567;
+	public const int b001000111000 = 568;
+	public const int b001000111001 = 569;
+	public const int b001000111010 = 570;
+	public const int b001000111011 = 571;
+	public const int b001000111100 = 572;
+	public const int b001000111101 = 573;
+	public const int b001000111110 = 574;
+	public const int b001000111111 = 575;
+	public const int b001001000000 = 576;
+	public const int b001001000001 = 577;
+	public const int b001001000010 = 578;
+	public const int b001001000011 = 579;
+	public const int b001001000100 = 580;
+	public const int b001001000101 = 581;
+	public const int b001001000110 = 582;
+	public const int b001001000111 = 583;
+	public const int b001001001000 = 584;
+	public const int b001001001001 = 585;
+	public const int b001001001010 = 586;
+	public const int b001001001011 = 587;
+	public const int b001001001100 = 588;
+	public const int b001001001101 = 589;
+	public const int b001001001110 = 590;
+	public const int b001001001111 = 591;
+	public const int b001001010000 = 592;
+	public const int b001001010001 = 593;
+	public const int b001001010010 = 594;
+	public const int b001001010011 = 595;
+	public const int b001001010100 = 596;
+	public const int b001001010101 = 597;
+	public const int b001001010110 = 598;
+	public const int b001001010111 = 599;
+	public const int b001001011000 = 600;
+	public const int b001001011001 = 601;
+	public const int b001001011010 = 602;
+	public const int b001001011011 = 603;
+	public const int b001001011100 = 604;
+	public const int b001001011101 = 605;
+	public const int b001001011110 = 606;
+	public const int b001001011111 = 607;
+	public const int b001001100000 = 608;
+	public const int b001001100001 = 609;
+	public const int b001001100010 = 610;
+	public const int b001001100011 = 611;
+	public const int b001001100100 = 612;
+	public const int b001001100101 = 613;
+	public const int b001001100110 = 614;
+	public const int b001001100111 = 615;
+	public const int b001001101000 = 616;
+	public const int b001001101001 = 617;
+	public const int b001001101010 = 618;
+	public const int b001001101011 = 619;
+	public const int b001001101100 = 620;
+	public const int b001001101101 = 621;
+	public const int b001001101110 = 622;
+	public const int b001001101111 = 623;
+	public const int b001001110000 = 624;
+	public const int b001001110001 = 625;
+	public const int b001001110010 = 626;
+	public const int b001001110011 = 627;
+	public const int b001001110100 = 628;
+	public const int b001001110101 = 629;
+	public const int b001001110110 = 630;
+	public const int b001001110111 = 631;
+	public const int b001001111000 = 632;
+	public const int b001001111001 = 633;
+	public const int b001001111010 = 634;
+	public const int b001001111011 = 635;
+	public const int b001001111100 = 636;
+	public const int b001001111101 = 637;
+	public const int b001001111110 = 638;
+	public const int b001001111111 = 639;
+	public const int b001010000000 = 640;
+	public const int b001010000001 = 641;
+	public const int b001010000010 = 642;
+	public const int b001010000011 = 643;
+	public const int b001010000100 = 644;
+	public const int b001010000101 = 645;
+	public const int b001010000110 = 646;
+	public const int b001010000111 = 647;
+	public const int b001010001000 = 648;
+	public const int b001010001001 = 649;
+	public const int b001010001010 = 650;
+	public const int b001010001011 = 651;
+	public const int b001010001100 = 652;
+	public const int b001010001101 = 653;
+	public const int b001010001110 = 654;
+	public const int b001010001111 = 655;
+	public const int b001010010000 = 656;
+	public const int b001010010001 = 657;
+	public const int b001010010010 = 658;
+	public const int b001010010011 = 659;
+	public const int b001010010100 = 660;
+	public const int b001010010101 = 661;
+	public const int b001010010110 = 662;
+	public const int b001010010111 = 663;
+	public const int b001010011000 = 664;
+	public const int b001010011001 = 665;
+	public const int b001010011010 = 666;
+	public const int b001010011011 = 667;
+	public const int b001010011100 = 668;
+	public const int b001010011101 = 669;
+	public const int b001010011110 = 670;
+	public const int b001010011111 = 671;
+	public const int b001010100000 = 672;
+	public const int b001010100001 = 673;
+	public const int b001010100010 = 674;
+	public const int b001010100011 = 675;
+	public const int b001010100100 = 676;
+	public const int b001010100101 = 677;
+	public const int b001010100110 = 678;
+	public const int b001010100111 = 679;
+	public const int b001010101000 = 680;
+	public const int b001010101001 = 681;
+	public const int b001010101010 = 682;
+	public const int b001010101011 = 683;
+	public const int b001010101100 = 684;
+	public const int b001010101101 = 685;
+	public const int b001010101110 = 686;
+	public const int b001010101111 = 687;
+	public const int b001010110000 = 688;
+	public const int b001010110001 = 689;
+	public const int b001010110010 = 690;
+	public const int b001010110011 = 691;
+	public const int b001010110100 = 692;
+	public const int b001010110101 = 693;
+	public const int b001010110110 = 694;
+	public const int b001010110111 = 695;
+	public const int b001010111000 = 696;
+	public const int b001010111001 = 697;
+	public const int b001010111010 = 698;
+	public const int b001010111011 = 699;
+	public const int b001010111100 = 700;
+	public const int b001010111101 = 701;
+	public const int b001010111110 = 702;
+	public const int b001010111111 = 703;
+	public const int b001011000000 = 704;
+	public const int b001011000001 = 705;
+	public const int b001011000010 = 706;
+	public const int b001011000011 = 707;
+	public const int b001011000100 = 708;
+	public const int b001011000101 = 709;
+	public const int b001011000110 = 710;
+	public const int b001011000111 = 711;
+	public const int b001011001000 = 712;
+	public const int b001011001001 = 713;
+	public const int b001011001010 = 714;
+	public const int b001011001011 = 715;
+	public const int b001011001100 = 716;
+	public const int b001011001101 = 717;
+	public const int b001011001110 = 718;
+	public const int b001011001111 = 719;
+	public const int b001011010000 = 720;
+	public const int b001011010001 = 721;
+	public const int b001011010010 = 722;
+	public const int b001011010011 = 723;
+	public const int b001011010100 = 724;
+	public const int b001011010101 = 725;
+	public const int b001011010110 = 726;
+	public const int b001011010111 = 727;
+	public const int b001011011000 = 728;
+	public const int b001011011001 = 729;
+	public const int b001011011010 = 730;
+	public const int b001011011011 = 731;
+	public const int b001011011100 = 732;
+	public const int b001011011101 = 733;
+	public const int b001011011110 = 734;
+	public const int b001011011111 = 735;
+	public const int b001011100000 = 736;
+	public const int b001011100001 = 737;
+	public const int b001011100010 = 738;
+	public const int b001011100011 = 739;
+	public const int b001011100100 = 740;
+	public const int b001011100101 = 741;
+	public const int b001011100110 = 742;
+	public const int b001011100111 = 743;
+	public const int b001011101000 = 744;
+	public const int b001011101001 = 745;
+	public const int b001011101010 = 746;
+	public const int b001011101011 = 747;
+	public const int b001011101100 = 748;
+	public const int b001011101101 = 749;
+	public const int b001011101110 = 750;
+	public const int b001011101111 = 751;
+	public const int b001011110000 = 752;
+	public const int b001011110001 = 753;
+	public const int b001011110010 = 754;
+	public const int b001011110011 = 755;
+	public const int b001011110100 = 756;
+	public const int b001011110101 = 757;
+	public const int b001011110110 = 758;
+	public const int b001011110111 = 759;
+	public const int b001011111000 = 760;
+	public const int b001011111001 = 761;
+	public const int b001011111010 = 762;
+	public const int b001011111011 = 763;
+	public const int b001011111100 = 764;
+	public const int b001011111101 = 765;
+	public const int b001011111110 = 766;
+	public const int b001011111111 = 767;
+	public const int b001100000000 = 768;
+	public const int b001100000001 = 769;
+	public const int b001100000010 = 770;
+	public const int b001100000011 = 771;
+	public const int b001100000100 = 772;
+	public const int b001100000101 = 773;
+	public const int b001100000110 = 774;
+	public const int b001100000111 = 775;
+	public const int b001100001000 = 776;
+	public const int b001100001001 = 777;
+	public const int b001100001010 = 778;
+	public const int b001100001011 = 779;
+	public const int b001100001100 = 780;
+	public const int b001100001101 = 781;
+	public const int b001100001110 = 782;
+	public const int b001100001111 = 783;
+	public const int b001100010000 = 784;
+	public const int b001100010001 = 785;
+	public const int b001100010010 = 786;
+	public const int b001100010011 = 787;
+	public const int b001100010100 = 788;
+	public const int b001100010101 = 789;
+	public const int b001100010110 = 790;
+	public const int b001100010111 = 791;
+	public const int b001100011000 = 792;
+	public const int b001100011001 = 793;
+	public const int b001100011010 = 794;
+	public const int b001100011011 = 795;
+	public const int b001100011100 = 796;
+	public const int b001100011101 = 797;
+	public const int b001100011110 = 798;
+	public const int b001100011111 = 799;
+	public const int b001100100000 = 800;
+	public const int b001100100001 = 801;
+	public const int b001100100010 = 802;
+	public const int b001100100011 = 803;
+	public const int b001100100100 = 804;
+	public const int b001100100101 = 805;
+	public const int b001100100110 = 806;
+	public const int b001100100111 = 807;
+	public const int b001100101000 = 808;
+	public const int b001100101001 = 809;
+	public const int b001100101010 = 810;
+	public const int b001100101011 = 811;
+	public const int b001100101100 = 812;
+	public const int b001100101101 = 813;
+	public const int b001100101110 = 814;
+	public const int b001100101111 = 815;
+	public const int b001100110000 = 816;
+	public const int b001100110001 = 817;
+	public const int b001100110010 = 818;
+	public const int b001100110011 = 819;
+	public const int b001100110100 = 820;
+	public const int b001100110101 = 821;
+	public const int b001100110110 = 822;
+	public const int b001100110111 = 823;
+	public const int b001100111000 = 824;
+	public const int b001100111001 = 825;
+	public const int b001100111010 = 826;
+	public const int b001100111011 = 827;
+	public const int b001100111100 = 828;
+	public const int b001100111101 = 829;
+	public const int b001100111110 = 830;
+	public const int b001100111111 = 831;
+	public const int b001101000000 = 832;
+	public const int b001101000001 = 833;
+	public const int b001101000010 = 834;
+	public const int b001101000011 = 835;
+	public const int b001101000100 = 836;
+	public const int b001101000101 = 837;
+	public const int b001101000110 = 838;
+	public const int b001101000111 = 839;
+	public const int b001101001000 = 840;
+	public const int b001101001001 = 841;
+	public const int b001101001010 = 842;
+	public const int b001101001011 = 843;
+	public const int b001101001100 = 844;
+	public const int b001101001101 = 845;
+	public const int b001101001110 = 846;
+	public const int b001101001111 = 847;
+	public const int b001101010000 = 848;
+	public const int b001101010001 = 849;
+	public const int b001101010010 = 850;
+	public const int b001101010011 = 851;
+	public const int b001101010100 = 852;
+	public const int b001101010101 = 853;
+	public const int b001101010110 = 854;
+	public const int b001101010111 = 855;
+	public const int b001101011000 = 856;
+	public const int b001101011001 = 857;
+	public const int b001101011010 = 858;
+	public const int b001101011011 = 859;
+	public const int b001101011100 = 860;
+	public const int b001101011101 = 861;
+	public const int b001101011110 = 862;
+	public const int b001101011111 = 863;
+	public const int b001101100000 = 864;
+	public const int b001101100001 = 865;
+	public const int b001101100010 = 866;
+	public const int b001101100011 = 867;
+	public const int b001101100100 = 868;
+	public const int b001101100101 = 869;
+	public const int b001101100110 = 870;
+	public const int b001101100111 = 871;
+	public const int b001101101000 = 872;
+	public const int b001101101001 = 873;
+	public const int b001101101010 = 874;
+	public const int b001101101011 = 875;
+	public const int b001101101100 = 876;
+	public const int b001101101101 = 877;
+	public const int b001101101110 = 878;
+	public const int b001101101111 = 879;
+	public const int b001101110000 = 880;
+	public const int b001101110001 = 881;
+	public const int b001101110010 = 882;
+	public const int b001101110011 = 883;
+	public const int b001101110100 = 884;
+	public const int b001101110101 = 885;
+	public const int b001101110110 = 886;
+	public const int b001101110111 = 887;
+	public const int b001101111000 = 888;
+	public const int b001101111001 = 889;
+	public const int b001101111010 = 890;
+	public const int b001101111011 = 891;
+	public const int b001101111100 = 892;
+	public const int b001101111101 = 893;
+	public const int b001101111110 = 894;
+	public const int b001101111111 = 895;
+	public const int b001110000000 = 896;
+	public const int b001110000001 = 897;
+	public const int b001110000010 = 898;
+	public const int b001110000011 = 899;
+	public const int b001110000100 = 900;
+	public const int b001110000101 = 901;
+	public const int b001110000110 = 902;
+	public const int b001110000111 = 903;
+	public const int b001110001000 = 904;
+	public const int b001110001001 = 905;
+	public const int b001110001010 = 906;
+	public const int b001110001011 = 907;
+	public const int b001110001100 = 908;
+	public const int b001110001101 = 909;
+	public const int b001110001110 = 910;
+	public const int b001110001111 = 911;
+	public const int b001110010000 = 912;
+	public const int b001110010001 = 913;
+	public const int b001110010010 = 914;
+	public const int b001110010011 = 915;
+	public const int b001110010100 = 916;
+	public const int b001110010101 = 917;
+	public const int b001110010110 = 918;
+	public const int b001110010111 = 919;
+	public const int b001110011000 = 920;
+	public const int b001110011001 = 921;
+	public const int b001110011010 = 922;
+	public const int b001110011011 = 923;
+	public const int b001110011100 = 924;
+	public const int b001110011101 = 925;
+	public const int b001110011110 = 926;
+	public const int b001110011111 = 927;
+	public const int b001110100000 = 928;
+	public const int b001110100001 = 929;
+	public const int b001110100010 = 930;
+	public const int b001110100011 = 931;
+	public const int b001110100100 = 932;
+	public const int b001110100101 = 933;
+	public const int b001110100110 = 934;
+	public const int b001110100111 = 935;
+	public const int b001110101000 = 936;
+	public const int b001110101001 = 937;
+	public const int b001110101010 = 938;
+	public const int b001110101011 = 939;
+	public const int b001110101100 = 940;
+	public const int b001110101101 = 941;
+	public const int b001110101110 = 942;
+	public const int b001110101111 = 943;
+	public const int b001110110000 = 944;
+	public const int b001110110001 = 945;
+	public const int b001110110010 = 946;
+	public const int b001110110011 = 947;
+	public const int b001110110100 = 948;
+	public const int b001110110101 = 949;
+	public const int b001110110110 = 950;
+	public const int b001110110111 = 951;
+	public const int b001110111000 = 952;
+	public const int b001110111001 = 953;
+	public const int b001110111010 = 954;
+	public const int b001110111011 = 955;
+	public const int b001110111100 = 956;
+	public const int b001110111101 = 957;
+	public const int b001110111110 = 958;
+	public const int b001110111111 = 959;
+	public const int b001111000000 = 960;
+	public const int b001111000001 = 961;
+	public const int b001111000010 = 962;
+	public const int b001111000011 = 963;
+	public const int b001111000100 = 964;
+	public const int b001111000101 = 965;
+	public const int b001111000110 = 966;
+	public const int b001111000111 = 967;
+	public const int b001111001000 = 968;
+	public const int b001111001001 = 969;
+	public const int b001111001010 = 970;
+	public const int b001111001011 = 971;
+	public const int b001111001100 = 972;
+	public const int b001111001101 = 973;
+	public const int b001111001110 = 974;
+	public const int b001111001111 = 975;
+	public const int b001111010000 = 976;
+	public const int b001111010001 = 977;
+	public const int b001111010010 = 978;
+	public const int b001111010011 = 979;
+	public const int b001111010100 = 980;
+	public const int b001111010101 = 981;
+	public const int b001111010110 = 982;
+	public const int b001111010111 = 983;
+	public const int b001111011000 = 984;
+	public const int b001111011001 = 985;
+	public const int b001111011010 = 986;
+	public const int b001111011011 = 987;
+	public const int b001111011100 = 988;
+	public const int b001111011101 = 989;
+	public const int b001111011110 = 990;
+	public const int b001111011111 = 991;
+	public const int b001111100000 = 992;
+	public const int b001111100001 = 993;
+	public const int b001111100010 = 994;
+	public const int b001111100011 = 995;
+	public const int b001111100100 = 996;
+	public const int b001111100101 = 997;
+	public const int b001111100110 = 998;
+	public const int b001111100111 = 999;
+	public const int b001111101000 = 1000;
+	public const int b001111101001 = 1001;
+	public const int b001111101010 = 1002;
+	public const int b001111101011 = 1003;
+	public const int b001111101100 = 1004;
+	public const int b001111101101 = 1005;
+	public const int b001111101110 = 1006;
+	public const int b001111101111 = 1007;
+	public const int b001111110000 = 1008;
+	public const int b001111110001 = 1009;
+	public const int b001111110010 = 1010;
+	public const int b001111110011 = 1011;
+	public const int b001111110100 = 1012;
+	public const int b001111110101 = 1013;
+	public const int b001111110110 = 1014;
+	public const int b001111110111 = 1015;
+	public const int b001111111000 = 1016;
+	public const int b001111111001 = 1017;
+	public const int b001111111010 = 1018;
+	public const int b001111111011 = 1019;
+	public const int b001111111100 = 1020;
+	public const int b001111111101 = 1021;
+	public const int b001111111110 = 1022;
+	public const int b001111111111 = 1023;
+	public const int b010000000000 = 1024;
+	public const int b010000000001 = 1025;
+	public const int b010000000010 = 1026;
+	public const int b010000000011 = 1027;
+	public const int b010000000100 = 1028;
+	public const int b010000000101 = 1029;
+	public const int b010000000110 = 1030;
+	public const int b010000000111 = 1031;
+	public const int b010000001000 = 1032;
+	public const int b010000001001 = 1033;
+	public const int b010000001010 = 1034;
+	public const int b010000001011 = 1035;
+	public const int b010000001100 = 1036;
+	public const int b010000001101 = 1037;
+	public const int b010000001110 = 1038;
+	public const int b010000001111 = 1039;
+	public const int b010000010000 = 1040;
+	public const int b010000010001 = 1041;
+	public const int b010000010010 = 1042;
+	public const int b010000010011 = 1043;
+	public const int b010000010100 = 1044;
+	public const int b010000010101 = 1045;
+	public const int b010000010110 = 1046;
+	public const int b010000010111 = 1047;
+	public const int b010000011000 = 1048;
+	public const int b010000011001 = 1049;
+	public const int b010000011010 = 1050;
+	public const int b010000011011 = 1051;
+	public const int b010000011100 = 1052;
+	public const int b010000011101 = 1053;
+	public const int b010000011110 = 1054;
+	public const int b010000011111 = 1055;
+	public const int b010000100000 = 1056;
+	public const int b010000100001 = 1057;
+	public const int b010000100010 = 1058;
+	public const int b010000100011 = 1059;
+	public const int b010000100100 = 1060;
+	public const int b010000100101 = 1061;
+	public const int b010000100110 = 1062;
+	public const int b010000100111 = 1063;
+	public const int b010000101000 = 1064;
+	public const int b010000101001 = 1065;
+	public const int b010000101010 = 1066;
+	public const int b010000101011 = 1067;
+	public const int b010000101100 = 1068;
+	public const int b010000101101 = 1069;
+	public const int b010000101110 = 1070;
+	public const int b010000101111 = 1071;
+	public const int b010000110000 = 1072;
+	public const int b010000110001 = 1073;
+	public const int b010000110010 = 1074;
+	public const int b010000110011 = 1075;
+	public const int b010000110100 = 1076;
+	public const int b010000110101 = 1077;
+	public const int b010000110110 = 1078;
+	public const int b010000110111 = 1079;
+	public const int b010000111000 = 1080;
+	public const int b010000111001 = 1081;
+	public const int b010000111010 = 1082;
+	public const int b010000111011 = 1083;
+	public const int b010000111100 = 1084;
+	public const int b010000111101 = 1085;
+	public const int b010000111110 = 1086;
+	public const int b010000111111 = 1087;
+	public const int b010001000000 = 1088;
+	public const int b010001000001 = 1089;
+	public const int b010001000010 = 1090;
+	public const int b010001000011 = 1091;
+	public const int b010001000100 = 1092;
+	public const int b010001000101 = 1093;
+	public const int b010001000110 = 1094;
+	public const int b010001000111 = 1095;
+	public const int b010001001000 = 1096;
+	public const int b010001001001 = 1097;
+	public const int b010001001010 = 1098;
+	public const int b010001001011 = 1099;
+	public const int b010001001100 = 1100;
+	public const int b010001001101 = 1101;
+	public const int b010001001110 = 1102;
+	public const int b010001001111 = 1103;
+	public const int b010001010000 = 1104;
+	public const int b010001010001 = 1105;
+	public const int b010001010010 = 1106;
+	public const int b010001010011 = 1107;
+	public const int b010001010100 = 1108;
+	public const int b010001010101 = 1109;
+	public const int b010001010110 = 1110;
+	public const int b010001010111 = 1111;
+	public const int b010001011000 = 1112;
+	public const int b010001011001 = 1113;
+	public const int b010001011010 = 1114;
+	public const int b010001011011 = 1115;
+	public const int b010001011100 = 1116;
+	public const int b010001011101 = 1117;
+	public const int b010001011110 = 1118;
+	public const int b010001011111 = 1119;
+	public const int b010001100000 = 1120;
+	public const int b010001100001 = 1121;
+	public const int b010001100010 = 1122;
+	public const int b010001100011 = 1123;
+	public const int b010001100100 = 1124;
+	public const int b010001100101 = 1125;
+	public const int b010001100110 = 1126;
+	public const int b010001100111 = 1127;
+	public const int b010001101000 = 1128;
+	public const int b010001101001 = 1129;
+	public const int b010001101010 = 1130;
+	public const int b010001101011 = 1131;
+	public const int b010001101100 = 1132;
+	public const int b010001101101 = 1133;
+	public const int b010001101110 = 1134;
+	public const int b010001101111 = 1135;
+	public const int b010001110000 = 1136;
+	public const int b010001110001 = 1137;
+	public const int b010001110010 = 1138;
+	public const int b010001110011 = 1139;
+	public const int b010001110100 = 1140;
+	public const int b010001110101 = 1141;
+	public const int b010001110110 = 1142;
+	public const int b010001110111 = 1143;
+	public const int b010001111000 = 1144;
+	public const int b010001111001 = 1145;
+	public const int b010001111010 = 1146;
+	public const int b010001111011 = 1147;
+	public const int b010001111100 = 1148;
+	public const int b010001111101 = 1149;
+	public const int b010001111110 = 1150;
+	public const int b010001111111 = 1151;
+	public const int b010010000000 = 1152;
+	public const int b010010000001 = 1153;
+	public const int b010010000010 = 1154;
+	public const int b010010000011 = 1155;
+	public const int b010010000100 = 1156;
+	public const int b010010000101 = 1157;
+	public const int b010010000110 = 1158;
+	public const int b010010000111 = 1159;
+	public const int b010010001000 = 1160;
+	public const int b010010001001 = 1161;
+	public const int b010010001010 = 1162;
+	public const int b010010001011 = 1163;
+	public const int b010010001100 = 1164;
+	public const int b010010001101 = 1165;
+	public const int b010010001110 = 1166;
+	public const int b010010001111 = 1167;
+	public const int b010010010000 = 1168;
+	public const int b010010010001 = 1169;
+	public const int b010010010010 = 1170;
+	public const int b010010010011 = 1171;
+	public const int b010010010100 = 1172;
+	public const int b010010010101 = 1173;
+	public const int b010010010110 = 1174;
+	public const int b010010010111 = 1175;
+	public const int b010010011000 = 1176;
+	public const int b010010011001 = 1177;
+	public const int b010010011010 = 1178;
+	public const int b010010011011 = 1179;
+	public const int b010010011100 = 1180;
+	public const int b010010011101 = 1181;
+	public const int b010010011110 = 1182;
+	public const int b010010011111 = 1183;
+	public const int b010010100000 = 1184;
+	public const int b010010100001 = 1185;
+	public const int b010010100010 = 1186;
+	public const int b010010100011 = 1187;
+	public const int b010010100100 = 1188;
+	public const int b010010100101 = 1189;
+	public const int b010010100110 = 1190;
+	public const int b010010100111 = 1191;
+	public const int b010010101000 = 1192;
+	public const int b010010101001 = 1193;
+	public const int b010010101010 = 1194;
+	public const int b010010101011 = 1195;
+	public const int b010010101100 = 1196;
+	public const int b010010101101 = 1197;
+	public const int b010010101110 = 1198;
+	public const int b010010101111 = 1199;
+	public const int b010010110000 = 1200;
+	public const int b010010110001 = 1201;
+	public const int b010010110010 = 1202;
+	public const int b010010110011 = 1203;
+	public const int b010010110100 = 1204;
+	public const int b010010110101 = 1205;
+	public const int b010010110110 = 1206;
+	public const int b010010110111 = 1207;
+	public const int b010010111000 = 1208;
+	public const int b010010111001 = 1209;
+	public const int b010010111010 = 1210;
+	public const int b010010111011 = 1211;
+	public const int b010010111100 = 1212;
+	public const int b010010111101 = 1213;
+	public const int b010010111110 = 1214;
+	public const int b010010111111 = 1215;
+	public const int b010011000000 = 1216;
+	public const int b010011000001 = 1217;
+	public const int b010011000010 = 1218;
+	public const int b010011000011 = 1219;
+	public const int b010011000100 = 1220;
+	public const int b010011000101 = 1221;
+	public const int b010011000110 = 1222;
+	public const int b010011000111 = 1223;
+	public const int b010011001000 = 1224;
+	public const int b010011001001 = 1225;
+	public const int b010011001010 = 1226;
+	public const int b010011001011 = 1227;
+	public const int b010011001100 = 1228;
+	public const int b010011001101 = 1229;
+	public const int b010011001110 = 1230;
+	public const int b010011001111 = 1231;
+	public const int b010011010000 = 1232;
+	public const int b010011010001 = 1233;
+	public const int b010011010010 = 1234;
+	public const int b010011010011 = 1235;
+	public const int b010011010100 = 1236;
+	public const int b010011010101 = 1237;
+	public const int b010011010110 = 1238;
+	public const int b010011010111 = 1239;
+	public const int b010011011000 = 1240;
+	public const int b010011011001 = 1241;
+	public const int b010011011010 = 1242;
+	public const int b010011011011 = 1243;
+	public const int b010011011100 = 1244;
+	public const int b010011011101 = 1245;
+	public const int b010011011110 = 1246;
+	public const int b010011011111 = 1247;
+	public const int b010011100000 = 1248;
+	public const int b010011100001 = 1249;
+	public const int b010011100010 = 1250;
+	public const int b010011100011 = 1251;
+	public const int b010011100100 = 1252;
+	public const int b010011100101 = 1253;
+	public const int b010011100110 = 1254;
+	public const int b010011100111 = 1255;
+	public const int b010011101000 = 1256;
+	public const int b010011101001 = 1257;
+	public const int b010011101010 = 1258;
+	public const int b010011101011 = 1259;
+	public const int b010011101100 = 1260;
+	public const int b010011101101 = 1261;
+	public const int b010011101110 = 1262;
+	public const int b010011101111 = 1263;
+	public const int b010011110000 = 1264;
+	public const int b010011110001 = 1265;
+	public const int b010011110010 = 1266;
+	public const int b010011110011 = 1267;
+	public const int b010011110100 = 1268;
+	public const int b010011110101 = 1269;
+	public const int b010011110110 = 1270;
+	public const int b010011110111 = 1271;
+	public const int b010011111000 = 1272;
+	public const int b010011111001 = 1273;
+	public const int b010011111010 = 1274;
+	public const int b010011111011 = 1275;
+	public const int b010011111100 = 1276;
+	public const int b010011111101 = 1277;
+	public const int b010011111110 = 1278;
+	public const int b010011111111 = 1279;
+	public const int b010100000000 = 1280;
+	public const int b010100000001 = 1281;
+	public const int b010100000010 = 1282;
+	public const int b010100000011 = 1283;
+	public const int b010100000100 = 1284;
+	public const int b010100000101 = 1285;
+	public const int b010100000110 = 1286;
+	public const int b010100000111 = 1287;
+	public const int b010100001000 = 1288;
+	public const int b010100001001 = 1289;
+	public const int b010100001010 = 1290;
+	public const int b010100001011 = 1291;
+	public const int b010100001100 = 1292;
+	public const int b010100001101 = 1293;
+	public const int b010100001110 = 1294;
+	public const int b010100001111 = 1295;
+	public const int b010100010000 = 1296;
+	public const int b010100010001 = 1297;
+	public const int b010100010010 = 1298;
+	public const int b010100010011 = 1299;
+	public const int b010100010100 = 1300;
+	public const int b010100010101 = 1301;
+	public const int b010100010110 = 1302;
+	public const int b010100010111 = 1303;
+	public const int b010100011000 = 1304;
+	public const int b010100011001 = 1305;
+	public const int b010100011010 = 1306;
+	public const int b010100011011 = 1307;
+	public const int b010100011100 = 1308;
+	public const int b010100011101 = 1309;
+	public const int b010100011110 = 1310;
+	public const int b010100011111 = 1311;
+	public const int b010100100000 = 1312;
+	public const int b010100100001 = 1313;
+	public const int b010100100010 = 1314;
+	public const int b010100100011 = 1315;
+	public const int b010100100100 = 1316;
+	public const int b010100100101 = 1317;
+	public const int b010100100110 = 1318;
+	public const int b010100100111 = 1319;
+	public const int b010100101000 = 1320;
+	public const int b010100101001 = 1321;
+	public const int b010100101010 = 1322;
+	public const int b010100101011 = 1323;
+	public const int b010100101100 = 1324;
+	public const int b010100101101 = 1325;
+	public const int b010100101110 = 1326;
+	public const int b010100101111 = 1327;
+	public const int b010100110000 = 1328;
+	public const int b010100110001 = 1329;
+	public const int b010100110010 = 1330;
+	public const int b010100110011 = 1331;
+	public const int b010100110100 = 1332;
+	public const int b010100110101 = 1333;
+	public const int b010100110110 = 1334;
+	public const int b010100110111 = 1335;
+	public const int b010100111000 = 1336;
+	public const int b010100111001 = 1337;
+	public const int b010100111010 = 1338;
+	public const int b010100111011 = 1339;
+	public const int b010100111100 = 1340;
+	public const int b010100111101 = 1341;
+	public const int b010100111110 = 1342;
+	public const int b010100111111 = 1343;
+	public const int b010101000000 = 1344;
+	public const int b010101000001 = 1345;
+	public const int b010101000010 = 1346;
+	public const int b010101000011 = 1347;
+	public const int b010101000100 = 1348;
+	public const int b010101000101 = 1349;
+	public const int b010101000110 = 1350;
+	public const int b010101000111 = 1351;
+	public const int b010101001000 = 1352;
+	public const int b010101001001 = 1353;
+	public const int b010101001010 = 1354;
+	public const int b010101001011 = 1355;
+	public const int b010101001100 = 1356;
+	public const int b010101001101 = 1357;
+	public const int b010101001110 = 1358;
+	public const int b010101001111 = 1359;
+	public const int b010101010000 = 1360;
+	public const int b010101010001 = 1361;
+	public const int b010101010010 = 1362;
+	public const int b010101010011 = 1363;
+	public const int b010101010100 = 1364;
+	public const int b010101010101 = 1365;
+	public const int b010101010110 = 1366;
+	public const int b010101010111 = 1367;
+	public const int b010101011000 = 1368;
+	public const int b010101011001 = 1369;
+	public const int b010101011010 = 1370;
+	public const int b010101011011 = 1371;
+	public const int b010101011100 = 1372;
+	public const int b010101011101 = 1373;
+	public const int b010101011110 = 1374;
+	public const int b010101011111 = 1375;
+	public const int b010101100000 = 1376;
+	public const int b010101100001 = 1377;
+	public const int b010101100010 = 1378;
+	public const int b010101100011 = 1379;
+	public const int b010101100100 = 1380;
+	public const int b010101100101 = 1381;
+	public const int b010101100110 = 1382;
+	public const int b010101100111 = 1383;
+	public const int b010101101000 = 1384;
+	public const int b010101101001 = 1385;
+	public const int b010101101010 = 1386;
+	public const int b010101101011 = 1387;
+	public const int b010101101100 = 1388;
+	public const int b010101101101 = 1389;
+	public const int b010101101110 = 1390;
+	public const int b010101101111 = 1391;
+	public const int b010101110000 = 1392;
+	public const int b010101110001 = 1393;
+	public const int b010101110010 = 1394;
+	public const int b010101110011 = 1395;
+	public const int b010101110100 = 1396;
+	public const int b010101110101 = 1397;
+	public const int b010101110110 = 1398;
+	public const int b010101110111 = 1399;
+	public const int b010101111000 = 1400;
+	public const int b010101111001 = 1401;
+	public const int b010101111010 = 1402;
+	public const int b010101111011 = 1403;
+	public const int b010101111100 = 1404;
+	public const int b010101111101 = 1405;
+	public const int b010101111110 = 1406;
+	public const int b010101111111 = 1407;
+	public const int b010110000000 = 1408;
+	public const int b010110000001 = 1409;
+	public const int b010110000010 = 1410;
+	public const int b010110000011 = 1411;
+	public const int b010110000100 = 1412;
+	public const int b010110000101 = 1413;
+	public const int b010110000110 = 1414;
+	public const int b010110000111 = 1415;
+	public const int b010110001000 = 1416;
+	public const int b010110001001 = 1417;
+	public const int b010110001010 = 1418;
+	public const int b010110001011 = 1419;
+	public const int b010110001100 = 1420;
+	public const int b010110001101 = 1421;
+	public const int b010110001110 = 1422;
+	public const int b010110001111 = 1423;
+	public const int b010110010000 = 1424;
+	public const int b010110010001 = 1425;
+	public const int b010110010010 = 1426;
+	public const int b010110010011 = 1427;
+	public const int b010110010100 = 1428;
+	public const int b010110010101 = 1429;
+	public const int b010110010110 = 1430;
+	public const int b010110010111 = 1431;
+	public const int b010110011000 = 1432;
+	public const int b010110011001 = 1433;
+	public const int b010110011010 = 1434;
+	public const int b010110011011 = 1435;
+	public const int b010110011100 = 1436;
+	public const int b010110011101 = 1437;
+	public const int b010110011110 = 1438;
+	public const int b010110011111 = 1439;
+	public const int b010110100000 = 1440;
+	public const int b010110100001 = 1441;
+	public const int b010110100010 = 1442;
+	public const int b010110100011 = 1443;
+	public const int b010110100100 = 1444;
+	public const int b010110100101 = 1445;
+	public const int b010110100110 = 1446;
+	public const int b010110100111 = 1447;
+	public const int b010110101000 = 1448;
+	public const int b010110101001 = 1449;
+	public const int b010110101010 = 1450;
+	public const int b010110101011 = 1451;
+	public const int b010110101100 = 1452;
+	public const int b010110101101 = 1453;
+	public const int b010110101110 = 1454;
+	public const int b010110101111 = 1455;
+	public const int b010110110000 = 1456;
+	public const int b010110110001 = 1457;
+	public const int b010110110010 = 1458;
+	public const int b010110110011 = 1459;
+	public const int b010110110100 = 1460;
+	public const int b010110110101 = 1461;
+	public const int b010110110110 = 1462;
+	public const int b010110110111 = 1463;
+	public const int b010110111000 = 1464;
+	public const int b010110111001 = 1465;
+	public const int b010110111010 = 1466;
+	public const int b010110111011 = 1467;
+	public const int b010110111100 = 1468;
+	public const int b010110111101 = 1469;
+	public const int b010110111110 = 1470;
+	public const int b010110111111 = 1471;
+	public const int b010111000000 = 1472;
+	public const int b010111000001 = 1473;
+	public const int b010111000010 = 1474;
+	public const int b010111000011 = 1475;
+	public const int b010111000100 = 1476;
+	public const int b010111000101 = 1477;
+	public const int b010111000110 = 1478;
+	public const int b010111000111 = 1479;
+	public const int b010111001000 = 1480;
+	public const int b010111001001 = 1481;
+	public const int b010111001010 = 1482;
+	public const int b010111001011 = 1483;
+	public const int b010111001100 = 1484;
+	public const int b010111001101 = 1485;
+	public const int b010111001110 = 1486;
+	public const int b010111001111 = 1487;
+	public const int b010111010000 = 1488;
+	public const int b010111010001 = 1489;
+	public const int b010111010010 = 1490;
+	public const int b010111010011 = 1491;
+	public const int b010111010100 = 1492;
+	public const int b010111010101 = 1493;
+	public const int b010111010110 = 1494;
+	public const int b010111010111 = 1495;
+	public const int b010111011000 = 1496;
+	public const int b010111011001 = 1497;
+	public const int b010111011010 = 1498;
+	public const int b010111011011 = 1499;
+	public const int b010111011100 = 1500;
+	public const int b010111011101 = 1501;
+	public const int b010111011110 = 1502;
+	public const int b010111011111 = 1503;
+	public const int b010111100000 = 1504;
+	public const int b010111100001 = 1505;
+	public const int b010111100010 = 1506;
+	public const int b010111100011 = 1507;
+	public const int b010111100100 = 1508;
+	public const int b010111100101 = 1509;
+	public const int b010111100110 = 1510;
+	public const int b010111100111 = 1511;
+	public const int b010111101000 = 1512;
+	public const int b010111101001 = 1513;
+	public const int b010111101010 = 1514;
+	public const int b010111101011 = 1515;
+	public const int b010111101100 = 1516;
+	public const int b010111101101 = 1517;
+	public const int b010111101110 = 1518;
+	public const int b010111101111 = 1519;
+	public const int b010111110000 = 1520;
+	public const int b010111110001 = 1521;
+	public const int b010111110010 = 1522;
+	public const int b010111110011 = 1523;
+	public const int b010111110100 = 1524;
+	public const int b010111110101 = 1525;
+	public const int b010111110110 = 1526;
+	public const int b010111110111 = 1527;
+	public const int b010111111000 = 1528;
+	public const int b010111111001 = 1529;
+	public const int b010111111010 = 1530;
+	public const int b010111111011 = 1531;
+	public const int b010111111100 = 1532;
+	public const int b010111111101 = 1533;
+	public const int b010111111110 = 1534;
+	public const int b010111111111 = 1535;
+	public const int b011000000000 = 1536;
+	public const int b011000000001 = 1537;
+	public const int b011000000010 = 1538;
+	public const int b011000000011 = 1539;
+	public const int b011000000100 = 1540;
+	public const int b011000000101 = 1541;
+	public const int b011000000110 = 1542;
+	public const int b011000000111 = 1543;
+	public const int b011000001000 = 1544;
+	public const int b011000001001 = 1545;
+	public const int b011000001010 = 1546;
+	public const int b011000001011 = 1547;
+	public const int b011000001100 = 1548;
+	public const int b011000001101 = 1549;
+	public const int b011000001110 = 1550;
+	public const int b011000001111 = 1551;
+	public const int b011000010000 = 1552;
+	public const int b011000010001 = 1553;
+	public const int b011000010010 = 1554;
+	public const int b011000010011 = 1555;
+	public const int b011000010100 = 1556;
+	public const int b011000010101 = 1557;
+	public const int b011000010110 = 1558;
+	public const int b011000010111 = 1559;
+	public const int b011000011000 = 1560;
+	public const int b011000011001 = 1561;
+	public const int b011000011010 = 1562;
+	public const int b011000011011 = 1563;
+	public const int b011000011100 = 1564;
+	public const int b011000011101 = 1565;
+	public const int b011000011110 = 1566;
+	public const int b011000011111 = 1567;
+	public const int b011000100000 = 1568;
+	public const int b011000100001 = 1569;
+	public const int b011000100010 = 1570;
+	public const int b011000100011 = 1571;
+	public const int b011000100100 = 1572;
+	public const int b011000100101 = 1573;
+	public const int b011000100110 = 1574;
+	public const int b011000100111 = 1575;
+	public const int b011000101000 = 1576;
+	public const int b011000101001 = 1577;
+	public const int b011000101010 = 1578;
+	public const int b011000101011 = 1579;
+	public const int b011000101100 = 1580;
+	public const int b011000101101 = 1581;
+	public const int b011000101110 = 1582;
+	public const int b011000101111 = 1583;
+	public const int b011000110000 = 1584;
+	public const int b011000110001 = 1585;
+	public const int b011000110010 = 1586;
+	public const int b011000110011 = 1587;
+	public const int b011000110100 = 1588;
+	public const int b011000110101 = 1589;
+	public const int b011000110110 = 1590;
+	public const int b011000110111 = 1591;
+	public const int b011000111000 = 1592;
+	public const int b011000111001 = 1593;
+	public const int b011000111010 = 1594;
+	public const int b011000111011 = 1595;
+	public const int b011000111100 = 1596;
+	public const int b011000111101 = 1597;
+	public const int b011000111110 = 1598;
+	public const int b011000111111 = 1599;
+	public const int b011001000000 = 1600;
+	public const int b011001000001 = 1601;
+	public const int b011001000010 = 1602;
+	public const int b011001000011 = 1603;
+	public const int b011001000100 = 1604;
+	public const int b011001000101 = 1605;
+	public const int b011001000110 = 1606;
+	public const int b011001000111 = 1607;
+	public const int b011001001000 = 1608;
+	public const int b011001001001 = 1609;
+	public const int b011001001010 = 1610;
+	public const int b011001001011 = 1611;
+	public const int b011001001100 = 1612;
+	public const int b011001001101 = 1613;
+	public const int b011001001110 = 1614;
+	public const int b011001001111 = 1615;
+	public const int b011001010000 = 1616;
+	public const int b011001010001 = 1617;
+	public const int b011001010010 = 1618;
+	public const int b011001010011 = 1619;
+	public const int b011001010100 = 1620;
+	public const int b011001010101 = 1621;
+	public const int b011001010110 = 1622;
+	public const int b011001010111 = 1623;
+	public const int b011001011000 = 1624;
+	public const int b011001011001 = 1625;
+	public const int b011001011010 = 1626;
+	public const int b011001011011 = 1627;
+	public const int b011001011100 = 1628;
+	public const int b011001011101 = 1629;
+	public const int b011001011110 = 1630;
+	public const int b011001011111 = 1631;
+	public const int b011001100000 = 1632;
+	public const int b011001100001 = 1633;
+	public const int b011001100010 = 1634;
+	public const int b011001100011 = 1635;
+	public const int b011001100100 = 1636;
+	public const int b011001100101 = 1637;
+	public const int b011001100110 = 1638;
+	public const int b011001100111 = 1639;
+	public const int b011001101000 = 1640;
+	public const int b011001101001 = 1641;
+	public const int b011001101010 = 1642;
+	public const int b011001101011 = 1643;
+	public const int b011001101100 = 1644;
+	public const int b011001101101 = 1645;
+	public const int b011001101110 = 1646;
+	public const int b011001101111 = 1647;
+	public const int b011001110000 = 1648;
+	public const int b011001110001 = 1649;
+	public const int b011001110010 = 1650;
+	public const int b011001110011 = 1651;
+	public const int b011001110100 = 1652;
+	public const int b011001110101 = 1653;
+	public const int b011001110110 = 1654;
+	public const int b011001110111 = 1655;
+	public const int b011001111000 = 1656;
+	public const int b011001111001 = 1657;
+	public const int b011001111010 = 1658;
+	public const int b011001111011 = 1659;
+	public const int b011001111100 = 1660;
+	public const int b011001111101 = 1661;
+	public const int b011001111110 = 1662;
+	public const int b011001111111 = 1663;
+	public const int b011010000000 = 1664;
+	public const int b011010000001 = 1665;
+	public const int b011010000010 = 1666;
+	public const int b011010000011 = 1667;
+	public const int b011010000100 = 1668;
+	public const int b011010000101 = 1669;
+	public const int b011010000110 = 1670;
+	public const int b011010000111 = 1671;
+	public const int b011010001000 = 1672;
+	public const int b011010001001 = 1673;
+	public const int b011010001010 = 1674;
+	public const int b011010001011 = 1675;
+	public const int b011010001100 = 1676;
+	public const int b011010001101 = 1677;
+	public const int b011010001110 = 1678;
+	public const int b011010001111 = 1679;
+	public const int b011010010000 = 1680;
+	public const int b011010010001 = 1681;
+	public const int b011010010010 = 1682;
+	public const int b011010010011 = 1683;
+	public const int b011010010100 = 1684;
+	public const int b011010010101 = 1685;
+	public const int b011010010110 = 1686;
+	public const int b011010010111 = 1687;
+	public const int b011010011000 = 1688;
+	public const int b011010011001 = 1689;
+	public const int b011010011010 = 1690;
+	public const int b011010011011 = 1691;
+	public const int b011010011100 = 1692;
+	public const int b011010011101 = 1693;
+	public const int b011010011110 = 1694;
+	public const int b011010011111 = 1695;
+	public const int b011010100000 = 1696;
+	public const int b011010100001 = 1697;
+	public const int b011010100010 = 1698;
+	public const int b011010100011 = 1699;
+	public const int b011010100100 = 1700;
+	public const int b011010100101 = 1701;
+	public const int b011010100110 = 1702;
+	public const int b011010100111 = 1703;
+	public const int b011010101000 = 1704;
+	public const int b011010101001 = 1705;
+	public const int b011010101010 = 1706;
+	public const int b011010101011 = 1707;
+	public const int b011010101100 = 1708;
+	public const int b011010101101 = 1709;
+	public const int b011010101110 = 1710;
+	public const int b011010101111 = 1711;
+	public const int b011010110000 = 1712;
+	public const int b011010110001 = 1713;
+	public const int b011010110010 = 1714;
+	public const int b011010110011 = 1715;
+	public const int b011010110100 = 1716;
+	public const int b011010110101 = 1717;
+	public const int b011010110110 = 1718;
+	public const int b011010110111 = 1719;
+	public const int b011010111000 = 1720;
+	public const int b011010111001 = 1721;
+	public const int b011010111010 = 1722;
+	public const int b011010111011 = 1723;
+	public const int b011010111100 = 1724;
+	public const int b011010111101 = 1725;
+	public const int b011010111110 = 1726;
+	public const int b011010111111 = 1727;
+	public const int b011011000000 = 1728;
+	public const int b011011000001 = 1729;
+	public const int b011011000010 = 1730;
+	public const int b011011000011 = 1731;
+	public const int b011011000100 = 1732;
+	public const int b011011000101 = 1733;
+	public const int b011011000110 = 1734;
+	public const int b011011000111 = 1735;
+	public const int b011011001000 = 1736;
+	public const int b011011001001 = 1737;
+	public const int b011011001010 = 1738;
+	public const int b011011001011 = 1739;
+	public const int b011011001100 = 1740;
+	public const int b011011001101 = 1741;
+	public const int b011011001110 = 1742;
+	public const int b011011001111 = 1743;
+	public const int b011011010000 = 1744;
+	public const int b011011010001 = 1745;
+	public const int b011011010010 = 1746;
+	public const int b011011010011 = 1747;
+	public const int b011011010100 = 1748;
+	public const int b011011010101 = 1749;
+	public const int b011011010110 = 1750;
+	public const int b011011010111 = 1751;
+	public const int b011011011000 = 1752;
+	public const int b011011011001 = 1753;
+	public const int b011011011010 = 1754;
+	public const int b011011011011 = 1755;
+	public const int b011011011100 = 1756;
+	public const int b011011011101 = 1757;
+	public const int b011011011110 = 1758;
+	public const int b011011011111 = 1759;
+	public const int b011011100000 = 1760;
+	public const int b011011100001 = 1761;
+	public const int b011011100010 = 1762;
+	public const int b011011100011 = 1763;
+	public const int b011011100100 = 1764;
+	public const int b011011100101 = 1765;
+	public const int b011011100110 = 1766;
+	public const int b011011100111 = 1767;
+	public const int b011011101000 = 1768;
+	public const int b011011101001 = 1769;
+	public const int b011011101010 = 1770;
+	public const int b011011101011 = 1771;
+	public const int b011011101100 = 1772;
+	public const int b011011101101 = 1773;
+	public const int b011011101110 = 1774;
+	public const int b011011101111 = 1775;
+	public const int b011011110000 = 1776;
+	public const int b011011110001 = 1777;
+	public const int b011011110010 = 1778;
+	public const int b011011110011 = 1779;
+	public const int b011011110100 = 1780;
+	public const int b011011110101 = 1781;
+	public const int b011011110110 = 1782;
+	public const int b011011110111 = 1783;
+	public const int b011011111000 = 1784;
+	public const int b011011111001 = 1785;
+	public const int b011011111010 = 1786;
+	public const int b011011111011 = 1787;
+	public const int b011011111100 = 1788;
+	public const int b011011111101 = 1789;
+	public const int b011011111110 = 1790;
+	public const int b011011111111 = 1791;
+	public const int b011100000000 = 1792;
+	public const int b011100000001 = 1793;
+	public const int b011100000010 = 1794;
+	public const int b011100000011 = 1795;
+	public const int b011100000100 = 1796;
+	public const int b011100000101 = 1797;
+	public const int b011100000110 = 1798;
+	public const int b011100000111 = 1799;
+	public const int b011100001000 = 1800;
+	public const int b011100001001 = 1801;
+	public const int b011100001010 = 1802;
+	public const int b011100001011 = 1803;
+	public const int b011100001100 = 1804;
+	public const int b011100001101 = 1805;
+	public const int b011100001110 = 1806;
+	public const int b011100001111 = 1807;
+	public const int b011100010000 = 1808;
+	public const int b011100010001 = 1809;
+	public const int b011100010010 = 1810;
+	public const int b011100010011 = 1811;
+	public const int b011100010100 = 1812;
+	public const int b011100010101 = 1813;
+	public const int b011100010110 = 1814;
+	public const int b011100010111 = 1815;
+	public const int b011100011000 = 1816;
+	public const int b011100011001 = 1817;
+	public const int b011100011010 = 1818;
+	public const int b011100011011 = 1819;
+	public const int b011100011100 = 1820;
+	public const int b011100011101 = 1821;
+	public const int b011100011110 = 1822;
+	public const int b011100011111 = 1823;
+	public const int b011100100000 = 1824;
+	public const int b011100100001 = 1825;
+	public const int b011100100010 = 1826;
+	public const int b011100100011 = 1827;
+	public const int b011100100100 = 1828;
+	public const int b011100100101 = 1829;
+	public const int b011100100110 = 1830;
+	public const int b011100100111 = 1831;
+	public const int b011100101000 = 1832;
+	public const int b011100101001 = 1833;
+	public const int b011100101010 = 1834;
+	public const int b011100101011 = 1835;
+	public const int b011100101100 = 1836;
+	public const int b011100101101 = 1837;
+	public const int b011100101110 = 1838;
+	public const int b011100101111 = 1839;
+	public const int b011100110000 = 1840;
+	public const int b011100110001 = 1841;
+	public const int b011100110010 = 1842;
+	public const int b011100110011 = 1843;
+	public const int b011100110100 = 1844;
+	public const int b011100110101 = 1845;
+	public const int b011100110110 = 1846;
+	public const int b011100110111 = 1847;
+	public const int b011100111000 = 1848;
+	public const int b011100111001 = 1849;
+	public const int b011100111010 = 1850;
+	public const int b011100111011 = 1851;
+	public const int b011100111100 = 1852;
+	public const int b011100111101 = 1853;
+	public const int b011100111110 = 1854;
+	public const int b011100111111 = 1855;
+	public const int b011101000000 = 1856;
+	public const int b011101000001 = 1857;
+	public const int b011101000010 = 1858;
+	public const int b011101000011 = 1859;
+	public const int b011101000100 = 1860;
+	public const int b011101000101 = 1861;
+	public const int b011101000110 = 1862;
+	public const int b011101000111 = 1863;
+	public const int b011101001000 = 1864;
+	public const int b011101001001 = 1865;
+	public const int b011101001010 = 1866;
+	public const int b011101001011 = 1867;
+	public const int b011101001100 = 1868;
+	public const int b011101001101 = 1869;
+	public const int b011101001110 = 1870;
+	public const int b011101001111 = 1871;
+	public const int b011101010000 = 1872;
+	public const int b011101010001 = 1873;
+	public const int b011101010010 = 1874;
+	public const int b011101010011 = 1875;
+	public const int b011101010100 = 1876;
+	public const int b011101010101 = 1877;
+	public const int b011101010110 = 1878;
+	public const int b011101010111 = 1879;
+	public const int b011101011000 = 1880;
+	public const int b011101011001 = 1881;
+	public const int b011101011010 = 1882;
+	public const int b011101011011 = 1883;
+	public const int b011101011100 = 1884;
+	public const int b011101011101 = 1885;
+	public const int b011101011110 = 1886;
+	public const int b011101011111 = 1887;
+	public const int b011101100000 = 1888;
+	public const int b011101100001 = 1889;
+	public const int b011101100010 = 1890;
+	public const int b011101100011 = 1891;
+	public const int b011101100100 = 1892;
+	public const int b011101100101 = 1893;
+	public const int b011101100110 = 1894;
+	public const int b011101100111 = 1895;
+	public const int b011101101000 = 1896;
+	public const int b011101101001 = 1897;
+	public const int b011101101010 = 1898;
+	public const int b011101101011 = 1899;
+	public const int b011101101100 = 1900;
+	public const int b011101101101 = 1901;
+	public const int b011101101110 = 1902;
+	public const int b011101101111 = 1903;
+	public const int b011101110000 = 1904;
+	public const int b011101110001 = 1905;
+	public const int b011101110010 = 1906;
+	public const int b011101110011 = 1907;
+	public const int b011101110100 = 1908;
+	public const int b011101110101 = 1909;
+	public const int b011101110110 = 1910;
+	public const int b011101110111 = 1911;
+	public const int b011101111000 = 1912;
+	public const int b011101111001 = 1913;
+	public const int b011101111010 = 1914;
+	public const int b011101111011 = 1915;
+	public const int b011101111100 = 1916;
+	public const int b011101111101 = 1917;
+	public const int b011101111110 = 1918;
+	public const int b011101111111 = 1919;
+	public const int b011110000000 = 1920;
+	public const int b011110000001 = 1921;
+	public const int b011110000010 = 1922;
+	public const int b011110000011 = 1923;
+	public const int b011110000100 = 1924;
+	public const int b011110000101 = 1925;
+	public const int b011110000110 = 1926;
+	public const int b011110000111 = 1927;
+	public const int b011110001000 = 1928;
+	public const int b011110001001 = 1929;
+	public const int b011110001010 = 1930;
+	public const int b011110001011 = 1931;
+	public const int b011110001100 = 1932;
+	public const int b011110001101 = 1933;
+	public const int b011110001110 = 1934;
+	public const int b011110001111 = 1935;
+	public const int b011110010000 = 1936;
+	public const int b011110010001 = 1937;
+	public const int b011110010010 = 1938;
+	public const int b011110010011 = 1939;
+	public const int b011110010100 = 1940;
+	public const int b011110010101 = 1941;
+	public const int b011110010110 = 1942;
+	public const int b011110010111 = 1943;
+	public const int b011110011000 = 1944;
+	public const int b011110011001 = 1945;
+	public const int b011110011010 = 1946;
+	public const int b011110011011 = 1947;
+	public const int b011110011100 = 1948;
+	public const int b011110011101 = 1949;
+	public const int b011110011110 = 1950;
+	public const int b011110011111 = 1951;
+	public const int b011110100000 = 1952;
+	public const int b011110100001 = 1953;
+	public const int b011110100010 = 1954;
+	public const int b011110100011 = 1955;
+	public const int b011110100100 = 1956;
+	public const int b011110100101 = 1957;
+	public const int b011110100110 = 1958;
+	public const int b011110100111 = 1959;
+	public const int b011110101000 = 1960;
+	public const int b011110101001 = 1961;
+	public const int b011110101010 = 1962;
+	public const int b011110101011 = 1963;
+	public const int b011110101100 = 1964;
+	public const int b011110101101 = 1965;
+	public const int b011110101110 = 1966;
+	public const int b011110101111 = 1967;
+	public const int b011110110000 = 1968;
+	public const int b011110110001 = 1969;
+	public const int b011110110010 = 1970;
+	public const int b011110110011 = 1971;
+	public const int b011110110100 = 1972;
+	public const int b011110110101 = 1973;
+	public const int b011110110110 = 1974;
+	public const int b011110110111 = 1975;
+	public const int b011110111000 = 1976;
+	public const int b011110111001 = 1977;
+	public const int b011110111010 = 1978;
+	public const int b011110111011 = 1979;
+	public const int b011110111100 = 1980;
+	public const int b011110111101 = 1981;
+	public const int b011110111110 = 1982;
+	public const int b011110111111 = 1983;
+	public const int b011111000000 = 1984;
+	public const int b011111000001 = 1985;
+	public const int b011111000010 = 1986;
+	public const int b011111000011 = 1987;
+	public const int b011111000100 = 1988;
+	public const int b011111000101 = 1989;
+	public const int b011111000110 = 1990;
+	public const int b011111000111 = 1991;
+	public const int b011111001000 = 1992;
+	public const int b011111001001 = 1993;
+	public const int b011111001010 = 1994;
+	public const int b011111001011 = 1995;
+	public const int b011111001100 = 1996;
+	public const int b011111001101 = 1997;
+	public const int b011111001110 = 1998;
+	public const int b011111001111 = 1999;
+	public const int b011111010000 = 2000;
+	public const int b011111010001 = 2001;
+	public const int b011111010010 = 2002;
+	public const int b011111010011 = 2003;
+	public const int b011111010100 = 2004;
+	public const int b011111010101 = 2005;
+	public const int b011111010110 = 2006;
+	public const int b011111010111 = 2007;
+	public const int b011111011000 = 2008;
+	public const int b011111011001 = 2009;
+	public const int b011111011010 = 2010;
+	public const int b011111011011 = 2011;
+	public const int b011111011100 = 2012;
+	public const int b011111011101 = 2013;
+	public const int b011111011110 = 2014;
+	public const int b011111011111 = 2015;
+	public const int b011111100000 = 2016;
+	public const int b011111100001 = 2017;
+	public const int b011111100010 = 2018;
+	public const int b011111100011 = 2019;
+	public const int b011111100100 = 2020;
+	public const int b011111100101 = 2021;
+	public const int b011111100110 = 2022;
+	public const int b011111100111 = 2023;
+	public const int b011111101000 = 2024;
+	public const int b011111101001 = 2025;
+	public const int b011111101010 = 2026;
+	public const int b011111101011 = 2027;
+	public const int b011111101100 = 2028;
+	public const int b011111101101 = 2029;
+	public const int b011111101110 = 2030;
+	public const int b011111101111 = 2031;
+	public const int b011111110000 = 2032;
+	public const int b011111110001 = 2033;
+	public const int b011111110010 = 2034;
+	public const int b011111110011 = 2035;
+	public const int b011111110100 = 2036;
+	public const int b011111110101 = 2037;
+	public const int b011111110110 = 2038;
+	public const int b011111110111 = 2039;
+	public const int b011111111000 = 2040;
+	public const int b011111111001 = 2041;
+	public const int b011111111010 = 2042;
+	public const int b011111111011 = 2043;
+	public const int b011111111100 = 2044;
+	public const int b011111111101 = 2045;
+	public const int b011111111110 = 2046;
+	public const int b011111111111 = 2047;
+	public const int b100000000000 = 2048;
+	public const int b100000000001 = 2049;
+	public const int b100000000010 = 2050;
+	public const int b100000000011 = 2051;
+	public const int b100000000100 = 2052;
+	public const int b100000000101 = 2053;
+	public const int b100000000110 = 2054;
+	public const int b100000000111 = 2055;
+	public const int b100000001000 = 2056;
+	public const int b100000001001 = 2057;
+	public const int b100000001010 = 2058;
+	public const int b100000001011 = 2059;
+	public const int b100000001100 = 2060;
+	public const int b100000001101 = 2061;
+	public const int b100000001110 = 2062;
+	public const int b100000001111 = 2063;
+	public const int b100000010000 = 2064;
+	public const int b100000010001 = 2065;
+	public const int b100000010010 = 2066;
+	public const int b100000010011 = 2067;
+	public const int b100000010100 = 2068;
+	public const int b100000010101 = 2069;
+	public const int b100000010110 = 2070;
+	public const int b100000010111 = 2071;
+	public const int b100000011000 = 2072;
+	public const int b100000011001 = 2073;
+	public const int b100000011010 = 2074;
+	public const int b100000011011 = 2075;
+	public const int b100000011100 = 2076;
+	public const int b100000011101 = 2077;
+	public const int b100000011110 = 2078;
+	public const int b100000011111 = 2079;
+	public const int b100000100000 = 2080;
+	public const int b100000100001 = 2081;
+	public const int b100000100010 = 2082;
+	public const int b100000100011 = 2083;
+	public const int b100000100100 = 2084;
+	public const int b100000100101 = 2085;
+	public const int b100000100110 = 2086;
+	public const int b100000100111 = 2087;
+	public const int b100000101000 = 2088;
+	public const int b100000101001 = 2089;
+	public const int b100000101010 = 2090;
+	public const int b100000101011 = 2091;
+	public const int b100000101100 = 2092;
+	public const int b100000101101 = 2093;
+	public const int b100000101110 = 2094;
+	public const int b100000101111 = 2095;
+	public const int b100000110000 = 2096;
+	public const int b100000110001 = 2097;
+	public const int b100000110010 = 2098;
+	public const int b100000110011 = 2099;
+	public const int b100000110100 = 2100;
+	public const int b100000110101 = 2101;
+	public const int b100000110110 = 2102;
+	public const int b100000110111 = 2103;
+	public const int b100000111000 = 2104;
+	public const int b100000111001 = 2105;
+	public const int b100000111010 = 2106;
+	public const int b100000111011 = 2107;
+	public const int b100000111100 = 2108;
+	public const int b100000111101 = 2109;
+	public const int b100000111110 = 2110;
+	public const int b100000111111 = 2111;
+	public const int b100001000000 = 2112;
+	public const int b100001000001 = 2113;
+	public const int b100001000010 = 2114;
+	public const int b100001000011 = 2115;
+	public const int b100001000100 = 2116;
+	public const int b100001000101 = 2117;
+	public const int b100001000110 = 2118;
+	public const int b100001000111 = 2119;
+	public const int b100001001000 = 2120;
+	public const int b100001001001 = 2121;
+	public const int b100001001010 = 2122;
+	public const int b100001001011 = 2123;
+	public const int b100001001100 = 2124;
+	public const int b100001001101 = 2125;
+	public const int b100001001110 = 2126;
+	public const int b100001001111 = 2127;
+	public const int b100001010000 = 2128;
+	public const int b100001010001 = 2129;
+	public const int b100001010010 = 2130;
+	public const int b100001010011 = 2131;
+	public const int b100001010100 = 2132;
+	public const int b100001010101 = 2133;
+	public const int b100001010110 = 2134;
+	public const int b100001010111 = 2135;
+	public const int b100001011000 = 2136;
+	public const int b100001011001 = 2137;
+	public const int b100001011010 = 2138;
+	public const int b100001011011 = 2139;
+	public const int b100001011100 = 2140;
+	public const int b100001011101 = 2141;
+	public const int b100001011110 = 2142;
+	public const int b100001011111 = 2143;
+	public const int b100001100000 = 2144;
+	public const int b100001100001 = 2145;
+	public const int b100001100010 = 2146;
+	public const int b100001100011 = 2147;
+	public const int b100001100100 = 2148;
+	public const int b100001100101 = 2149;
+	public const int b100001100110 = 2150;
+	public const int b100001100111 = 2151;
+	public const int b100001101000 = 2152;
+	public const int b100001101001 = 2153;
+	public const int b100001101010 = 2154;
+	public const int b100001101011 = 2155;
+	public const int b100001101100 = 2156;
+	public const int b100001101101 = 2157;
+	public const int b100001101110 = 2158;
+	public const int b100001101111 = 2159;
+	public const int b100001110000 = 2160;
+	public const int b100001110001 = 2161;
+	public const int b100001110010 = 2162;
+	public const int b100001110011 = 2163;
+	public const int b100001110100 = 2164;
+	public const int b100001110101 = 2165;
+	public const int b100001110110 = 2166;
+	public const int b100001110111 = 2167;
+	public const int b100001111000 = 2168;
+	public const int b100001111001 = 2169;
+	public const int b100001111010 = 2170;
+	public const int b100001111011 = 2171;
+	public const int b100001111100 = 2172;
+	public const int b100001111101 = 2173;
+	public const int b100001111110 = 2174;
+	public const int b100001111111 = 2175;
+	public const int b100010000000 = 2176;
+	public const int b100010000001 = 2177;
+	public const int b100010000010 = 2178;
+	public const int b100010000011 = 2179;
+	public const int b100010000100 = 2180;
+	public const int b100010000101 = 2181;
+	public const int b100010000110 = 2182;
+	public const int b100010000111 = 2183;
+	public const int b100010001000 = 2184;
+	public const int b100010001001 = 2185;
+	public const int b100010001010 = 2186;
+	public const int b100010001011 = 2187;
+	public const int b100010001100 = 2188;
+	public const int b100010001101 = 2189;
+	public const int b100010001110 = 2190;
+	public const int b100010001111 = 2191;
+	public const int b100010010000 = 2192;
+	public const int b100010010001 = 2193;
+	public const int b100010010010 = 2194;
+	public const int b100010010011 = 2195;
+	public const int b100010010100 = 2196;
+	public const int b100010010101 = 2197;
+	public const int b100010010110 = 2198;
+	public const int b100010010111 = 2199;
+	public const int b100010011000 = 2200;
+	public const int b100010011001 = 2201;
+	public const int b100010011010 = 2202;
+	public const int b100010011011 = 2203;
+	public const int b100010011100 = 2204;
+	public const int b100010011101 = 2205;
+	public const int b100010011110 = 2206;
+	public const int b100010011111 = 2207;
+	public const int b100010100000 = 2208;
+	public const int b100010100001 = 2209;
+	public const int b100010100010 = 2210;
+	public const int b100010100011 = 2211;
+	public const int b100010100100 = 2212;
+	public const int b100010100101 = 2213;
+	public const int b100010100110 = 2214;
+	public const int b100010100111 = 2215;
+	public const int b100010101000 = 2216;
+	public const int b100010101001 = 2217;
+	public const int b100010101010 = 2218;
+	public const int b100010101011 = 2219;
+	public const int b100010101100 = 2220;
+	public const int b100010101101 = 2221;
+	public const int b100010101110 = 2222;
+	public const int b100010101111 = 2223;
+	public const int b100010110000 = 2224;
+	public const int b100010110001 = 2225;
+	public const int b100010110010 = 2226;
+	public const int b100010110011 = 2227;
+	public const int b100010110100 = 2228;
+	public const int b100010110101 = 2229;
+	public const int b100010110110 = 2230;
+	public const int b100010110111 = 2231;
+	public const int b100010111000 = 2232;
+	public const int b100010111001 = 2233;
+	public const int b100010111010 = 2234;
+	public const int b100010111011 = 2235;
+	public const int b100010111100 = 2236;
+	public const int b100010111101 = 2237;
+	public const int b100010111110 = 2238;
+	public const int b100010111111 = 2239;
+	public const int b100011000000 = 2240;
+	public const int b100011000001 = 2241;
+	public const int b100011000010 = 2242;
+	public const int b100011000011 = 2243;
+	public const int b100011000100 = 2244;
+	public const int b100011000101 = 2245;
+	public const int b100011000110 = 2246;
+	public const int b100011000111 = 2247;
+	public const int b100011001000 = 2248;
+	public const int b100011001001 = 2249;
+	public const int b100011001010 = 2250;
+	public const int b100011001011 = 2251;
+	public const int b100011001100 = 2252;
+	public const int b100011001101 = 2253;
+	public const int b100011001110 = 2254;
+	public const int b100011001111 = 2255;
+	public const int b100011010000 = 2256;
+	public const int b100011010001 = 2257;
+	public const int b100011010010 = 2258;
+	public const int b100011010011 = 2259;
+	public const int b100011010100 = 2260;
+	public const int b100011010101 = 2261;
+	public const int b100011010110 = 2262;
+	public const int b100011010111 = 2263;
+	public const int b100011011000 = 2264;
+	public const int b100011011001 = 2265;
+	public const int b100011011010 = 2266;
+	public const int b100011011011 = 2267;
+	public const int b100011011100 = 2268;
+	public const int b100011011101 = 2269;
+	public const int b100011011110 = 2270;
+	public const int b100011011111 = 2271;
+	public const int b100011100000 = 2272;
+	public const int b100011100001 = 2273;
+	public const int b100011100010 = 2274;
+	public const int b100011100011 = 2275;
+	public const int b100011100100 = 2276;
+	public const int b100011100101 = 2277;
+	public const int b100011100110 = 2278;
+	public const int b100011100111 = 2279;
+	public const int b100011101000 = 2280;
+	public const int b100011101001 = 2281;
+	public const int b100011101010 = 2282;
+	public const int b100011101011 = 2283;
+	public const int b100011101100 = 2284;
+	public const int b100011101101 = 2285;
+	public const int b100011101110 = 2286;
+	public const int b100011101111 = 2287;
+	public const int b100011110000 = 2288;
+	public const int b100011110001 = 2289;
+	public const int b100011110010 = 2290;
+	public const int b100011110011 = 2291;
+	public const int b100011110100 = 2292;
+	public const int b100011110101 = 2293;
+	public const int b100011110110 = 2294;
+	public const int b100011110111 = 2295;
+	public const int b100011111000 = 2296;
+	public const int b100011111001 = 2297;
+	public const int b100011111010 = 2298;
+	public const int b100011111011 = 2299;
+	public const int b100011111100 = 2300;
+	public const int b100011111101 = 2301;
+	public const int b100011111110 = 2302;
+	public const int b100011111111 = 2303;
+	public const int b100100000000 = 2304;
+	public const int b100100000001 = 2305;
+	public const int b100100000010 = 2306;
+	public const int b100100000011 = 2307;
+	public const int b100100000100 = 2308;
+	public const int b100100000101 = 2309;
+	public const int b100100000110 = 2310;
+	public const int b100100000111 = 2311;
+	public const int b100100001000 = 2312;
+	public const int b100100001001 = 2313;
+	public const int b100100001010 = 2314;
+	public const int b100100001011 = 2315;
+	public const int b100100001100 = 2316;
+	public const int b100100001101 = 2317;
+	public const int b100100001110 = 2318;
+	public const int b100100001111 = 2319;
+	public const int b100100010000 = 2320;
+	public const int b100100010001 = 2321;
+	public const int b100100010010 = 2322;
+	public const int b100100010011 = 2323;
+	public const int b100100010100 = 2324;
+	public const int b100100010101 = 2325;
+	public const int b100100010110 = 2326;
+	public const int b100100010111 = 2327;
+	public const int b100100011000 = 2328;
+	public const int b100100011001 = 2329;
+	public const int b100100011010 = 2330;
+	public const int b100100011011 = 2331;
+	public const int b100100011100 = 2332;
+	public const int b100100011101 = 2333;
+	public const int b100100011110 = 2334;
+	public const int b100100011111 = 2335;
+	public const int b100100100000 = 2336;
+	public const int b100100100001 = 2337;
+	public const int b100100100010 = 2338;
+	public const int b100100100011 = 2339;
+	public const int b100100100100 = 2340;
+	public const int b100100100101 = 2341;
+	public const int b100100100110 = 2342;
+	public const int b100100100111 = 2343;
+	public const int b100100101000 = 2344;
+	public const int b100100101001 = 2345;
+	public const int b100100101010 = 2346;
+	public const int b100100101011 = 2347;
+	public const int b100100101100 = 2348;
+	public const int b100100101101 = 2349;
+	public const int b100100101110 = 2350;
+	public const int b100100101111 = 2351;
+	public const int b100100110000 = 2352;
+	public const int b100100110001 = 2353;
+	public const int b100100110010 = 2354;
+	public const int b100100110011 = 2355;
+	public const int b100100110100 = 2356;
+	public const int b100100110101 = 2357;
+	public const int b100100110110 = 2358;
+	public const int b100100110111 = 2359;
+	public const int b100100111000 = 2360;
+	public const int b100100111001 = 2361;
+	public const int b100100111010 = 2362;
+	public const int b100100111011 = 2363;
+	public const int b100100111100 = 2364;
+	public const int b100100111101 = 2365;
+	public const int b100100111110 = 2366;
+	public const int b100100111111 = 2367;
+	public const int b100101000000 = 2368;
+	public const int b100101000001 = 2369;
+	public const int b100101000010 = 2370;
+	public const int b100101000011 = 2371;
+	public const int b100101000100 = 2372;
+	public const int b100101000101 = 2373;
+	public const int b100101000110 = 2374;
+	public const int b100101000111 = 2375;
+	public const int b100101001000 = 2376;
+	public const int b100101001001 = 2377;
+	public const int b100101001010 = 2378;
+	public const int b100101001011 = 2379;
+	public const int b100101001100 = 2380;
+	public const int b100101001101 = 2381;
+	public const int b100101001110 = 2382;
+	public const int b100101001111 = 2383;
+	public const int b100101010000 = 2384;
+	public const int b100101010001 = 2385;
+	public const int b100101010010 = 2386;
+	public const int b100101010011 = 2387;
+	public const int b100101010100 = 2388;
+	public const int b100101010101 = 2389;
+	public const int b100101010110 = 2390;
+	public const int b100101010111 = 2391;
+	public const int b100101011000 = 2392;
+	public const int b100101011001 = 2393;
+	public const int b100101011010 = 2394;
+	public const int b100101011011 = 2395;
+	public const int b100101011100 = 2396;
+	public const int b100101011101 = 2397;
+	public const int b100101011110 = 2398;
+	public const int b100101011111 = 2399;
+	public const int b100101100000 = 2400;
+	public const int b100101100001 = 2401;
+	public const int b100101100010 = 2402;
+	public const int b100101100011 = 2403;
+	public const int b100101100100 = 2404;
+	public const int b100101100101 = 2405;
+	public const int b100101100110 = 2406;
+	public const int b100101100111 = 2407;
+	public const int b100101101000 = 2408;
+	public const int b100101101001 = 2409;
+	public const int b100101101010 = 2410;
+	public const int b100101101011 = 2411;
+	public const int b100101101100 = 2412;
+	public const int b100101101101 = 2413;
+	public const int b100101101110 = 2414;
+	public const int b100101101111 = 2415;
+	public const int b100101110000 = 2416;
+	public const int b100101110001 = 2417;
+	public const int b100101110010 = 2418;
+	public const int b100101110011 = 2419;
+	public const int b100101110100 = 2420;
+	public const int b100101110101 = 2421;
+	public const int b100101110110 = 2422;
+	public const int b100101110111 = 2423;
+	public const int b100101111000 = 2424;
+	public const int b100101111001 = 2425;
+	public const int b100101111010 = 2426;
+	public const int b100101111011 = 2427;
+	public const int b100101111100 = 2428;
+	public const int b100101111101 = 2429;
+	public const int b100101111110 = 2430;
+	public const int b100101111111 = 2431;
+	public const int b100110000000 = 2432;
+	public const int b100110000001 = 2433;
+	public const int b100110000010 = 2434;
+	public const int b100110000011 = 2435;
+	public const int b100110000100 = 2436;
+	public const int b100110000101 = 2437;
+	public const int b100110000110 = 2438;
+	public const int b100110000111 = 2439;
+	public const int b100110001000 = 2440;
+	public const int b100110001001 = 2441;
+	public const int b100110001010 = 2442;
+	public const int b100110001011 = 2443;
+	public const int b100110001100 = 2444;
+	public const int b100110001101 = 2445;
+	public const int b100110001110 = 2446;
+	public const int b100110001111 = 2447;
+	public const int b100110010000 = 2448;
+	public const int b100110010001 = 2449;
+	public const int b100110010010 = 2450;
+	public const int b100110010011 = 2451;
+	public const int b100110010100 = 2452;
+	public const int b100110010101 = 2453;
+	public const int b100110010110 = 2454;
+	public const int b100110010111 = 2455;
+	public const int b100110011000 = 2456;
+	public const int b100110011001 = 2457;
+	public const int b100110011010 = 2458;
+	public const int b100110011011 = 2459;
+	public const int b100110011100 = 2460;
+	public const int b100110011101 = 2461;
+	public const int b100110011110 = 2462;
+	public const int b100110011111 = 2463;
+	public const int b100110100000 = 2464;
+	public const int b100110100001 = 2465;
+	public const int b100110100010 = 2466;
+	public const int b100110100011 = 2467;
+	public const int b100110100100 = 2468;
+	public const int b100110100101 = 2469;
+	public const int b100110100110 = 2470;
+	public const int b100110100111 = 2471;
+	public const int b100110101000 = 2472;
+	public const int b100110101001 = 2473;
+	public const int b100110101010 = 2474;
+	public const int b100110101011 = 2475;
+	public const int b100110101100 = 2476;
+	public const int b100110101101 = 2477;
+	public const int b100110101110 = 2478;
+	public const int b100110101111 = 2479;
+	public const int b100110110000 = 2480;
+	public const int b100110110001 = 2481;
+	public const int b100110110010 = 2482;
+	public const int b100110110011 = 2483;
+	public const int b100110110100 = 2484;
+	public const int b100110110101 = 2485;
+	public const int b100110110110 = 2486;
+	public const int b100110110111 = 2487;
+	public const int b100110111000 = 2488;
+	public const int b100110111001 = 2489;
+	public const int b100110111010 = 2490;
+	public const int b100110111011 = 2491;
+	public const int b100110111100 = 2492;
+	public const int b100110111101 = 2493;
+	public const int b100110111110 = 2494;
+	public const int b100110111111 = 2495;
+	public const int b100111000000 = 2496;
+	public const int b100111000001 = 2497;
+	public const int b100111000010 = 2498;
+	public const int b100111000011 = 2499;
+	public const int b100111000100 = 2500;
+	public const int b100111000101 = 2501;
+	public const int b100111000110 = 2502;
+	public const int b100111000111 = 2503;
+	public const int b100111001000 = 2504;
+	public const int b100111001001 = 2505;
+	public const int b100111001010 = 2506;
+	public const int b100111001011 = 2507;
+	public const int b100111001100 = 2508;
+	public const int b100111001101 = 2509;
+	public const int b100111001110 = 2510;
+	public const int b100111001111 = 2511;
+	public const int b100111010000 = 2512;
+	public const int b100111010001 = 2513;
+	public const int b100111010010 = 2514;
+	public const int b100111010011 = 2515;
+	public const int b100111010100 = 2516;
+	public const int b100111010101 = 2517;
+	public const int b100111010110 = 2518;
+	public const int b100111010111 = 2519;
+	public const int b100111011000 = 2520;
+	public const int b100111011001 = 2521;
+	public const int b100111011010 = 2522;
+	public const int b100111011011 = 2523;
+	public const int b100111011100 = 2524;
+	public const int b100111011101 = 2525;
+	public const int b100111011110 = 2526;
+	public const int b100111011111 = 2527;
+	public const int b100111100000 = 2528;
+	public const int b100111100001 = 2529;
+	public const int b100111100010 = 2530;
+	public const int b100111100011 = 2531;
+	public const int b100111100100 = 2532;
+	public const int b100111100101 = 2533;
+	public const int b100111100110 = 2534;
+	public const int b100111100111 = 2535;
+	public const int b100111101000 = 2536;
+	public const int b100111101001 = 2537;
+	public const int b100111101010 = 2538;
+	public const int b100111101011 = 2539;
+	public const int b100111101100 = 2540;
+	public const int b100111101101 = 2541;
+	public const int b100111101110 = 2542;
+	public const int b100111101111 = 2543;
+	public const int b100111110000 = 2544;
+	public const int b100111110001 = 2545;
+	public const int b100111110010 = 2546;
+	public const int b100111110011 = 2547;
+	public const int b100111110100 = 2548;
+	public const int b100111110101 = 2549;
+	public const int b100111110110 = 2550;
+	public const int b100111110111 = 2551;
+	public const int b100111111000 = 2552;
+	public const int b100111111001 = 2553;
+	public const int b100111111010 = 2554;
+	public const int b100111111011 = 2555;
+	public const int b100111111100 = 2556;
+	public const int b100111111101 = 2557;
+	public const int b100111111110 = 2558;
+	public const int b100111111111 = 2559;
+	public const int b101000000000 = 2560;
+	public const int b101000000001 = 2561;
+	public const int b101000000010 = 2562;
+	public const int b101000000011 = 2563;
+	public const int b101000000100 = 2564;
+	public const int b101000000101 = 2565;
+	public const int b101000000110 = 2566;
+	public const int b101000000111 = 2567;
+	public const int b101000001000 = 2568;
+	public const int b101000001001 = 2569;
+	public const int b101000001010 = 2570;
+	public const int b101000001011 = 2571;
+	public const int b101000001100 = 2572;
+	public const int b101000001101 = 2573;
+	public const int b101000001110 = 2574;
+	public const int b101000001111 = 2575;
+	public const int b101000010000 = 2576;
+	public const int b101000010001 = 2577;
+	public const int b101000010010 = 2578;
+	public const int b101000010011 = 2579;
+	public const int b101000010100 = 2580;
+	public const int b101000010101 = 2581;
+	public const int b101000010110 = 2582;
+	public const int b101000010111 = 2583;
+	public const int b101000011000 = 2584;
+	public const int b101000011001 = 2585;
+	public const int b101000011010 = 2586;
+	public const int b101000011011 = 2587;
+	public const int b101000011100 = 2588;
+	public const int b101000011101 = 2589;
+	public const int b101000011110 = 2590;
+	public const int b101000011111 = 2591;
+	public const int b101000100000 = 2592;
+	public const int b101000100001 = 2593;
+	public const int b101000100010 = 2594;
+	public const int b101000100011 = 2595;
+	public const int b101000100100 = 2596;
+	public const int b101000100101 = 2597;
+	public const int b101000100110 = 2598;
+	public const int b101000100111 = 2599;
+	public const int b101000101000 = 2600;
+	public const int b101000101001 = 2601;
+	public const int b101000101010 = 2602;
+	public const int b101000101011 = 2603;
+	public const int b101000101100 = 2604;
+	public const int b101000101101 = 2605;
+	public const int b101000101110 = 2606;
+	public const int b101000101111 = 2607;
+	public const int b101000110000 = 2608;
+	public const int b101000110001 = 2609;
+	public const int b101000110010 = 2610;
+	public const int b101000110011 = 2611;
+	public const int b101000110100 = 2612;
+	public const int b101000110101 = 2613;
+	public const int b101000110110 = 2614;
+	public const int b101000110111 = 2615;
+	public const int b101000111000 = 2616;
+	public const int b101000111001 = 2617;
+	public const int b101000111010 = 2618;
+	public const int b101000111011 = 2619;
+	public const int b101000111100 = 2620;
+	public const int b101000111101 = 2621;
+	public const int b101000111110 = 2622;
+	public const int b101000111111 = 2623;
+	public const int b101001000000 = 2624;
+	public const int b101001000001 = 2625;
+	public const int b101001000010 = 2626;
+	public const int b101001000011 = 2627;
+	public const int b101001000100 = 2628;
+	public const int b101001000101 = 2629;
+	public const int b101001000110 = 2630;
+	public const int b101001000111 = 2631;
+	public const int b101001001000 = 2632;
+	public const int b101001001001 = 2633;
+	public const int b101001001010 = 2634;
+	public const int b101001001011 = 2635;
+	public const int b101001001100 = 2636;
+	public const int b101001001101 = 2637;
+	public const int b101001001110 = 2638;
+	public const int b101001001111 = 2639;
+	public const int b101001010000 = 2640;
+	public const int b101001010001 = 2641;
+	public const int b101001010010 = 2642;
+	public const int b101001010011 = 2643;
+	public const int b101001010100 = 2644;
+	public const int b101001010101 = 2645;
+	public const int b101001010110 = 2646;
+	public const int b101001010111 = 2647;
+	public const int b101001011000 = 2648;
+	public const int b101001011001 = 2649;
+	public const int b101001011010 = 2650;
+	public const int b101001011011 = 2651;
+	public const int b101001011100 = 2652;
+	public const int b101001011101 = 2653;
+	public const int b101001011110 = 2654;
+	public const int b101001011111 = 2655;
+	public const int b101001100000 = 2656;
+	public const int b101001100001 = 2657;
+	public const int b101001100010 = 2658;
+	public const int b101001100011 = 2659;
+	public const int b101001100100 = 2660;
+	public const int b101001100101 = 2661;
+	public const int b101001100110 = 2662;
+	public const int b101001100111 = 2663;
+	public const int b101001101000 = 2664;
+	public const int b101001101001 = 2665;
+	public const int b101001101010 = 2666;
+	public const int b101001101011 = 2667;
+	public const int b101001101100 = 2668;
+	public const int b101001101101 = 2669;
+	public const int b101001101110 = 2670;
+	public const int b101001101111 = 2671;
+	public const int b101001110000 = 2672;
+	public const int b101001110001 = 2673;
+	public const int b101001110010 = 2674;
+	public const int b101001110011 = 2675;
+	public const int b101001110100 = 2676;
+	public const int b101001110101 = 2677;
+	public const int b101001110110 = 2678;
+	public const int b101001110111 = 2679;
+	public const int b101001111000 = 2680;
+	public const int b101001111001 = 2681;
+	public const int b101001111010 = 2682;
+	public const int b101001111011 = 2683;
+	public const int b101001111100 = 2684;
+	public const int b101001111101 = 2685;
+	public const int b101001111110 = 2686;
+	public const int b101001111111 = 2687;
+	public const int b101010000000 = 2688;
+	public const int b101010000001 = 2689;
+	public const int b101010000010 = 2690;
+	public const int b101010000011 = 2691;
+	public const int b101010000100 = 2692;
+	public const int b101010000101 = 2693;
+	public const int b101010000110 = 2694;
+	public const int b101010000111 = 2695;
+	public const int b101010001000 = 2696;
+	public const int b101010001001 = 2697;
+	public const int b101010001010 = 2698;
+	public const int b101010001011 = 2699;
+	public const int b101010001100 = 2700;
+	public const int b101010001101 = 2701;
+	public const int b101010001110 = 2702;
+	public const int b101010001111 = 2703;
+	public const int b101010010000 = 2704;
+	public const int b101010010001 = 2705;
+	public const int b101010010010 = 2706;
+	public const int b101010010011 = 2707;
+	public const int b101010010100 = 2708;
+	public const int b101010010101 = 2709;
+	public const int b101010010110 = 2710;
+	public const int b101010010111 = 2711;
+	public const int b101010011000 = 2712;
+	public const int b101010011001 = 2713;
+	public const int b101010011010 = 2714;
+	public const int b101010011011 = 2715;
+	public const int b101010011100 = 2716;
+	public const int b101010011101 = 2717;
+	public const int b101010011110 = 2718;
+	public const int b101010011111 = 2719;
+	public const int b101010100000 = 2720;
+	public const int b101010100001 = 2721;
+	public const int b101010100010 = 2722;
+	public const int b101010100011 = 2723;
+	public const int b101010100100 = 2724;
+	public const int b101010100101 = 2725;
+	public const int b101010100110 = 2726;
+	public const int b101010100111 = 2727;
+	public const int b101010101000 = 2728;
+	public const int b101010101001 = 2729;
+	public const int b101010101010 = 2730;
+	public const int b101010101011 = 2731;
+	public const int b101010101100 = 2732;
+	public const int b101010101101 = 2733;
+	public const int b101010101110 = 2734;
+	public const int b101010101111 = 2735;
+	public const int b101010110000 = 2736;
+	public const int b101010110001 = 2737;
+	public const int b101010110010 = 2738;
+	public const int b101010110011 = 2739;
+	public const int b101010110100 = 2740;
+	public const int b101010110101 = 2741;
+	public const int b101010110110 = 2742;
+	public const int b101010110111 = 2743;
+	public const int b101010111000 = 2744;
+	public const int b101010111001 = 2745;
+	public const int b101010111010 = 2746;
+	public const int b101010111011 = 2747;
+	public const int b101010111100 = 2748;
+	public const int b101010111101 = 2749;
+	public const int b101010111110 = 2750;
+	public const int b101010111111 = 2751;
+	public const int b101011000000 = 2752;
+	public const int b101011000001 = 2753;
+	public const int b101011000010 = 2754;
+	public const int b101011000011 = 2755;
+	public const int b101011000100 = 2756;
+	public const int b101011000101 = 2757;
+	public const int b101011000110 = 2758;
+	public const int b101011000111 = 2759;
+	public const int b101011001000 = 2760;
+	public const int b101011001001 = 2761;
+	public const int b101011001010 = 2762;
+	public const int b101011001011 = 2763;
+	public const int b101011001100 = 2764;
+	public const int b101011001101 = 2765;
+	public const int b101011001110 = 2766;
+	public const int b101011001111 = 2767;
+	public const int b101011010000 = 2768;
+	public const int b101011010001 = 2769;
+	public const int b101011010010 = 2770;
+	public const int b101011010011 = 2771;
+	public const int b101011010100 = 2772;
+	public const int b101011010101 = 2773;
+	public const int b101011010110 = 2774;
+	public const int b101011010111 = 2775;
+	public const int b101011011000 = 2776;
+	public const int b101011011001 = 2777;
+	public const int b101011011010 = 2778;
+	public const int b101011011011 = 2779;
+	public const int b101011011100 = 2780;
+	public const int b101011011101 = 2781;
+	public const int b101011011110 = 2782;
+	public const int b101011011111 = 2783;
+	public const int b101011100000 = 2784;
+	public const int b101011100001 = 2785;
+	public const int b101011100010 = 2786;
+	public const int b101011100011 = 2787;
+	public const int b101011100100 = 2788;
+	public const int b101011100101 = 2789;
+	public const int b101011100110 = 2790;
+	public const int b101011100111 = 2791;
+	public const int b101011101000 = 2792;
+	public const int b101011101001 = 2793;
+	public const int b101011101010 = 2794;
+	public const int b101011101011 = 2795;
+	public const int b101011101100 = 2796;
+	public const int b101011101101 = 2797;
+	public const int b101011101110 = 2798;
+	public const int b101011101111 = 2799;
+	public const int b101011110000 = 2800;
+	public const int b101011110001 = 2801;
+	public const int b101011110010 = 2802;
+	public const int b101011110011 = 2803;
+	public const int b101011110100 = 2804;
+	public const int b101011110101 = 2805;
+	public const int b101011110110 = 2806;
+	public const int b101011110111 = 2807;
+	public const int b101011111000 = 2808;
+	public const int b101011111001 = 2809;
+	public const int b101011111010 = 2810;
+	public const int b101011111011 = 2811;
+	public const int b101011111100 = 2812;
+	public const int b101011111101 = 2813;
+	public const int b101011111110 = 2814;
+	public const int b101011111111 = 2815;
+	public const int b101100000000 = 2816;
+	public const int b101100000001 = 2817;
+	public const int b101100000010 = 2818;
+	public const int b101100000011 = 2819;
+	public const int b101100000100 = 2820;
+	public const int b101100000101 = 2821;
+	public const int b101100000110 = 2822;
+	public const int b101100000111 = 2823;
+	public const int b101100001000 = 2824;
+	public const int b101100001001 = 2825;
+	public const int b101100001010 = 2826;
+	public const int b101100001011 = 2827;
+	public const int b101100001100 = 2828;
+	public const int b101100001101 = 2829;
+	public const int b101100001110 = 2830;
+	public const int b101100001111 = 2831;
+	public const int b101100010000 = 2832;
+	public const int b101100010001 = 2833;
+	public const int b101100010010 = 2834;
+	public const int b101100010011 = 2835;
+	public const int b101100010100 = 2836;
+	public const int b101100010101 = 2837;
+	public const int b101100010110 = 2838;
+	public const int b101100010111 = 2839;
+	public const int b101100011000 = 2840;
+	public const int b101100011001 = 2841;
+	public const int b101100011010 = 2842;
+	public const int b101100011011 = 2843;
+	public const int b101100011100 = 2844;
+	public const int b101100011101 = 2845;
+	public const int b101100011110 = 2846;
+	public const int b101100011111 = 2847;
+	public const int b101100100000 = 2848;
+	public const int b101100100001 = 2849;
+	public const int b101100100010 = 2850;
+	public const int b101100100011 = 2851;
+	public const int b101100100100 = 2852;
+	public const int b101100100101 = 2853;
+	public const int b101100100110 = 2854;
+	public const int b101100100111 = 2855;
+	public const int b101100101000 = 2856;
+	public const int b101100101001 = 2857;
+	public const int b101100101010 = 2858;
+	public const int b101100101011 = 2859;
+	public const int b101100101100 = 2860;
+	public const int b101100101101 = 2861;
+	public const int b101100101110 = 2862;
+	public const int b101100101111 = 2863;
+	public const int b101100110000 = 2864;
+	public const int b101100110001 = 2865;
+	public const int b101100110010 = 2866;
+	public const int b101100110011 = 2867;
+	public const int b101100110100 = 2868;
+	public const int b101100110101 = 2869;
+	public const int b101100110110 = 2870;
+	public const int b101100110111 = 2871;
+	public const int b101100111000 = 2872;
+	public const int b101100111001 = 2873;
+	public const int b101100111010 = 2874;
+	public const int b101100111011 = 2875;
+	public const int b101100111100 = 2876;
+	public const int b101100111101 = 2877;
+	public const int b101100111110 = 2878;
+	public const int b101100111111 = 2879;
+	public const int b101101000000 = 2880;
+	public const int b101101000001 = 2881;
+	public const int b101101000010 = 2882;
+	public const int b101101000011 = 2883;
+	public const int b101101000100 = 2884;
+	public const int b101101000101 = 2885;
+	public const int b101101000110 = 2886;
+	public const int b101101000111 = 2887;
+	public const int b101101001000 = 2888;
+	public const int b101101001001 = 2889;
+	public const int b101101001010 = 2890;
+	public const int b101101001011 = 2891;
+	public const int b101101001100 = 2892;
+	public const int b101101001101 = 2893;
+	public const int b101101001110 = 2894;
+	public const int b101101001111 = 2895;
+	public const int b101101010000 = 2896;
+	public const int b101101010001 = 2897;
+	public const int b101101010010 = 2898;
+	public const int b101101010011 = 2899;
+	public const int b101101010100 = 2900;
+	public const int b101101010101 = 2901;
+	public const int b101101010110 = 2902;
+	public const int b101101010111 = 2903;
+	public const int b101101011000 = 2904;
+	public const int b101101011001 = 2905;
+	public const int b101101011010 = 2906;
+	public const int b101101011011 = 2907;
+	public const int b101101011100 = 2908;
+	public const int b101101011101 = 2909;
+	public const int b101101011110 = 2910;
+	public const int b101101011111 = 2911;
+	public const int b101101100000 = 2912;
+	public const int b101101100001 = 2913;
+	public const int b101101100010 = 2914;
+	public const int b101101100011 = 2915;
+	public const int b101101100100 = 2916;
+	public const int b101101100101 = 2917;
+	public const int b101101100110 = 2918;
+	public const int b101101100111 = 2919;
+	public const int b101101101000 = 2920;
+	public const int b101101101001 = 2921;
+	public const int b101101101010 = 2922;
+	public const int b101101101011 = 2923;
+	public const int b101101101100 = 2924;
+	public const int b101101101101 = 2925;
+	public const int b101101101110 = 2926;
+	public const int b101101101111 = 2927;
+	public const int b101101110000 = 2928;
+	public const int b101101110001 = 2929;
+	public const int b101101110010 = 2930;
+	public const int b101101110011 = 2931;
+	public const int b101101110100 = 2932;
+	public const int b101101110101 = 2933;
+	public const int b101101110110 = 2934;
+	public const int b101101110111 = 2935;
+	public const int b101101111000 = 2936;
+	public const int b101101111001 = 2937;
+	public const int b101101111010 = 2938;
+	public const int b101101111011 = 2939;
+	public const int b101101111100 = 2940;
+	public const int b101101111101 = 2941;
+	public const int b101101111110 = 2942;
+	public const int b101101111111 = 2943;
+	public const int b101110000000 = 2944;
+	public const int b101110000001 = 2945;
+	public const int b101110000010 = 2946;
+	public const int b101110000011 = 2947;
+	public const int b101110000100 = 2948;
+	public const int b101110000101 = 2949;
+	public const int b101110000110 = 2950;
+	public const int b101110000111 = 2951;
+	public const int b101110001000 = 2952;
+	public const int b101110001001 = 2953;
+	public const int b101110001010 = 2954;
+	public const int b101110001011 = 2955;
+	public const int b101110001100 = 2956;
+	public const int b101110001101 = 2957;
+	public const int b101110001110 = 2958;
+	public const int b101110001111 = 2959;
+	public const int b101110010000 = 2960;
+	public const int b101110010001 = 2961;
+	public const int b101110010010 = 2962;
+	public const int b101110010011 = 2963;
+	public const int b101110010100 = 2964;
+	public const int b101110010101 = 2965;
+	public const int b101110010110 = 2966;
+	public const int b101110010111 = 2967;
+	public const int b101110011000 = 2968;
+	public const int b101110011001 = 2969;
+	public const int b101110011010 = 2970;
+	public const int b101110011011 = 2971;
+	public const int b101110011100 = 2972;
+	public const int b101110011101 = 2973;
+	public const int b101110011110 = 2974;
+	public const int b101110011111 = 2975;
+	public const int b101110100000 = 2976;
+	public const int b101110100001 = 2977;
+	public const int b101110100010 = 2978;
+	public const int b101110100011 = 2979;
+	public const int b101110100100 = 2980;
+	public const int b101110100101 = 2981;
+	public const int b101110100110 = 2982;
+	public const int b101110100111 = 2983;
+	public const int b101110101000 = 2984;
+	public const int b101110101001 = 2985;
+	public const int b101110101010 = 2986;
+	public const int b101110101011 = 2987;
+	public const int b101110101100 = 2988;
+	public const int b101110101101 = 2989;
+	public const int b101110101110 = 2990;
+	public const int b101110101111 = 2991;
+	public const int b101110110000 = 2992;
+	public const int b101110110001 = 2993;
+	public const int b101110110010 = 2994;
+	public const int b101110110011 = 2995;
+	public const int b101110110100 = 2996;
+	public const int b101110110101 = 2997;
+	public const int b101110110110 = 2998;
+	public const int b101110110111 = 2999;
+	public const int b101110111000 = 3000;
+	public const int b101110111001 = 3001;
+	public const int b101110111010 = 3002;
+	public const int b101110111011 = 3003;
+	public const int b101110111100 = 3004;
+	public const int b101110111101 = 3005;
+	public const int b101110111110 = 3006;
+	public const int b101110111111 = 3007;
+	public const int b101111000000 = 3008;
+	public const int b101111000001 = 3009;
+	public const int b101111000010 = 3010;
+	public const int b101111000011 = 3011;
+	public const int b101111000100 = 3012;
+	public const int b101111000101 = 3013;
+	public const int b101111000110 = 3014;
+	public const int b101111000111 = 3015;
+	public const int b101111001000 = 3016;
+	public const int b101111001001 = 3017;
+	public const int b101111001010 = 3018;
+	public const int b101111001011 = 3019;
+	public const int b101111001100 = 3020;
+	public const int b101111001101 = 3021;
+	public const int b101111001110 = 3022;
+	public const int b101111001111 = 3023;
+	public const int b101111010000 = 3024;
+	public const int b101111010001 = 3025;
+	public const int b101111010010 = 3026;
+	public const int b101111010011 = 3027;
+	public const int b101111010100 = 3028;
+	public const int b101111010101 = 3029;
+	public const int b101111010110 = 3030;
+	public const int b101111010111 = 3031;
+	public const int b101111011000 = 3032;
+	public const int b101111011001 = 3033;
+	public const int b101111011010 = 3034;
+	public const int b101111011011 = 3035;
+	public const int b101111011100 = 3036;
+	public const int b101111011101 = 3037;
+	public const int b101111011110 = 3038;
+	public const int b101111011111 = 3039;
+	public const int b101111100000 = 3040;
+	public const int b101111100001 = 3041;
+	public const int b101111100010 = 3042;
+	public const int b101111100011 = 3043;
+	public const int b101111100100 = 3044;
+	public const int b101111100101 = 3045;
+	public const int b101111100110 = 3046;
+	public const int b101111100111 = 3047;
+	public const int b101111101000 = 3048;
+	public const int b101111101001 = 3049;
+	public const int b101111101010 = 3050;
+	public const int b101111101011 = 3051;
+	public const int b101111101100 = 3052;
+	public const int b101111101101 = 3053;
+	public const int b101111101110 = 3054;
+	public const int b101111101111 = 3055;
+	public const int b101111110000 = 3056;
+	public const int b101111110001 = 3057;
+	public const int b101111110010 = 3058;
+	public const int b101111110011 = 3059;
+	public const int b101111110100 = 3060;
+	public const int b101111110101 = 3061;
+	public const int b101111110110 = 3062;
+	public const int b101111110111 = 3063;
+	public const int b101111111000 = 3064;
+	public const int b101111111001 = 3065;
+	public const int b101111111010 = 3066;
+	public const int b101111111011 = 3067;
+	public const int b101111111100 = 3068;
+	public const int b101111111101 = 3069;
+	public const int b101111111110 = 3070;
+	public const int b101111111111 = 3071;
+	public const int b110000000000 = 3072;
+	public const int b110000000001 = 3073;
+	public const int b110000000010 = 3074;
+	public const int b110000000011 = 3075;
+	public const int b110000000100 = 3076;
+	public const int b110000000101 = 3077;
+	public const int b110000000110 = 3078;
+	public const int b110000000111 = 3079;
+	public const int b110000001000 = 3080;
+	public const int b110000001001 = 3081;
+	public const int b110000001010 = 3082;
+	public const int b110000001011 = 3083;
+	public const int b110000001100 = 3084;
+	public const int b110000001101 = 3085;
+	public const int b110000001110 = 3086;
+	public const int b110000001111 = 3087;
+	public const int b110000010000 = 3088;
+	public const int b110000010001 = 3089;
+	public const int b110000010010 = 3090;
+	public const int b110000010011 = 3091;
+	public const int b110000010100 = 3092;
+	public const int b110000010101 = 3093;
+	public const int b110000010110 = 3094;
+	public const int b110000010111 = 3095;
+	public const int b110000011000 = 3096;
+	public const int b110000011001 = 3097;
+	public const int b110000011010 = 3098;
+	public const int b110000011011 = 3099;
+	public const int b110000011100 = 3100;
+	public const int b110000011101 = 3101;
+	public const int b110000011110 = 3102;
+	public const int b110000011111 = 3103;
+	public const int b110000100000 = 3104;
+	public const int b110000100001 = 3105;
+	public const int b110000100010 = 3106;
+	public const int b110000100011 = 3107;
+	public const int b110000100100 = 3108;
+	public const int b110000100101 = 3109;
+	public const int b110000100110 = 3110;
+	public const int b110000100111 = 3111;
+	public const int b110000101000 = 3112;
+	public const int b110000101001 = 3113;
+	public const int b110000101010 = 3114;
+	public const int b110000101011 = 3115;
+	public const int b110000101100 = 3116;
+	public const int b110000101101 = 3117;
+	public const int b110000101110 = 3118;
+	public const int b110000101111 = 3119;
+	public const int b110000110000 = 3120;
+	public const int b110000110001 = 3121;
+	public const int b110000110010 = 3122;
+	public const int b110000110011 = 3123;
+	public const int b110000110100 = 3124;
+	public const int b110000110101 = 3125;
+	public const int b110000110110 = 3126;
+	public const int b110000110111 = 3127;
+	public const int b110000111000 = 3128;
+	public const int b110000111001 = 3129;
+	public const int b110000111010 = 3130;
+	public const int b110000111011 = 3131;
+	public const int b110000111100 = 3132;
+	public const int b110000111101 = 3133;
+	public const int b110000111110 = 3134;
+	public const int b110000111111 = 3135;
+	public const int b110001000000 = 3136;
+	public const int b110001000001 = 3137;
+	public const int b110001000010 = 3138;
+	public const int b110001000011 = 3139;
+	public const int b110001000100 = 3140;
+	public const int b110001000101 = 3141;
+	public const int b110001000110 = 3142;
+	public const int b110001000111 = 3143;
+	public const int b110001001000 = 3144;
+	public const int b110001001001 = 3145;
+	public const int b110001001010 = 3146;
+	public const int b110001001011 = 3147;
+	public const int b110001001100 = 3148;
+	public const int b110001001101 = 3149;
+	public const int b110001001110 = 3150;
+	public const int b110001001111 = 3151;
+	public const int b110001010000 = 3152;
+	public const int b110001010001 = 3153;
+	public const int b110001010010 = 3154;
+	public const int b110001010011 = 3155;
+	public const int b110001010100 = 3156;
+	public const int b110001010101 = 3157;
+	public const int b110001010110 = 3158;
+	public const int b110001010111 = 3159;
+	public const int b110001011000 = 3160;
+	public const int b110001011001 = 3161;
+	public const int b110001011010 = 3162;
+	public const int b110001011011 = 3163;
+	public const int b110001011100 = 3164;
+	public const int b110001011101 = 3165;
+	public const int b110001011110 = 3166;
+	public const int b110001011111 = 3167;
+	public const int b110001100000 = 3168;
+	public const int b110001100001 = 3169;
+	public const int b110001100010 = 3170;
+	public const int b110001100011 = 3171;
+	public const int b110001100100 = 3172;
+	public const int b110001100101 = 3173;
+	public const int b110001100110 = 3174;
+	public const int b110001100111 = 3175;
+	public const int b110001101000 = 3176;
+	public const int b110001101001 = 3177;
+	public const int b110001101010 = 3178;
+	public const int b110001101011 = 3179;
+	public const int b110001101100 = 3180;
+	public const int b110001101101 = 3181;
+	public const int b110001101110 = 3182;
+	public const int b110001101111 = 3183;
+	public const int b110001110000 = 3184;
+	public const int b110001110001 = 3185;
+	public const int b110001110010 = 3186;
+	public const int b110001110011 = 3187;
+	public const int b110001110100 = 3188;
+	public const int b110001110101 = 3189;
+	public const int b110001110110 = 3190;
+	public const int b110001110111 = 3191;
+	public const int b110001111000 = 3192;
+	public const int b110001111001 = 3193;
+	public const int b110001111010 = 3194;
+	public const int b110001111011 = 3195;
+	public const int b110001111100 = 3196;
+	public const int b110001111101 = 3197;
+	public const int b110001111110 = 3198;
+	public const int b110001111111 = 3199;
+	public const int b110010000000 = 3200;
+	public const int b110010000001 = 3201;
+	public const int b110010000010 = 3202;
+	public const int b110010000011 = 3203;
+	public const int b110010000100 = 3204;
+	public const int b110010000101 = 3205;
+	public const int b110010000110 = 3206;
+	public const int b110010000111 = 3207;
+	public const int b110010001000 = 3208;
+	public const int b110010001001 = 3209;
+	public const int b110010001010 = 3210;
+	public const int b110010001011 = 3211;
+	public const int b110010001100 = 3212;
+	public const int b110010001101 = 3213;
+	public const int b110010001110 = 3214;
+	public const int b110010001111 = 3215;
+	public const int b110010010000 = 3216;
+	public const int b110010010001 = 3217;
+	public const int b110010010010 = 3218;
+	public const int b110010010011 = 3219;
+	public const int b110010010100 = 3220;
+	public const int b110010010101 = 3221;
+	public const int b110010010110 = 3222;
+	public const int b110010010111 = 3223;
+	public const int b110010011000 = 3224;
+	public const int b110010011001 = 3225;
+	public const int b110010011010 = 3226;
+	public const int b110010011011 = 3227;
+	public const int b110010011100 = 3228;
+	public const int b110010011101 = 3229;
+	public const int b110010011110 = 3230;
+	public const int b110010011111 = 3231;
+	public const int b110010100000 = 3232;
+	public const int b110010100001 = 3233;
+	public const int b110010100010 = 3234;
+	public const int b110010100011 = 3235;
+	public const int b110010100100 = 3236;
+	public const int b110010100101 = 3237;
+	public const int b110010100110 = 3238;
+	public const int b110010100111 = 3239;
+	public const int b110010101000 = 3240;
+	public const int b110010101001 = 3241;
+	public const int b110010101010 = 3242;
+	public const int b110010101011 = 3243;
+	public const int b110010101100 = 3244;
+	public const int b110010101101 = 3245;
+	public const int b110010101110 = 3246;
+	public const int b110010101111 = 3247;
+	public const int b110010110000 = 3248;
+	public const int b110010110001 = 3249;
+	public const int b110010110010 = 3250;
+	public const int b110010110011 = 3251;
+	public const int b110010110100 = 3252;
+	public const int b110010110101 = 3253;
+	public const int b110010110110 = 3254;
+	public const int b110010110111 = 3255;
+	public const int b110010111000 = 3256;
+	public const int b110010111001 = 3257;
+	public const int b110010111010 = 3258;
+	public const int b110010111011 = 3259;
+	public const int b110010111100 = 3260;
+	public const int b110010111101 = 3261;
+	public const int b110010111110 = 3262;
+	public const int b110010111111 = 3263;
+	public const int b110011000000 = 3264;
+	public const int b110011000001 = 3265;
+	public const int b110011000010 = 3266;
+	public const int b110011000011 = 3267;
+	public const int b110011000100 = 3268;
+	public const int b110011000101 = 3269;
+	public const int b110011000110 = 3270;
+	public const int b110011000111 = 3271;
+	public const int b110011001000 = 3272;
+	public const int b110011001001 = 3273;
+	public const int b110011001010 = 3274;
+	public const int b110011001011 = 3275;
+	public const int b110011001100 = 3276;
+	public const int b110011001101 = 3277;
+	public const int b110011001110 = 3278;
+	public const int b110011001111 = 3279;
+	public const int b110011010000 = 3280;
+	public const int b110011010001 = 3281;
+	public const int b110011010010 = 3282;
+	public const int b110011010011 = 3283;
+	public const int b110011010100 = 3284;
+	public const int b110011010101 = 3285;
+	public const int b110011010110 = 3286;
+	public const int b110011010111 = 3287;
+	public const int b110011011000 = 3288;
+	public const int b110011011001 = 3289;
+	public const int b110011011010 = 3290;
+	public const int b110011011011 = 3291;
+	public const int b110011011100 = 3292;
+	public const int b110011011101 = 3293;
+	public const int b110011011110 = 3294;
+	public const int b110011011111 = 3295;
+	public const int b110011100000 = 3296;
+	public const int b110011100001 = 3297;
+	public const int b110011100010 = 3298;
+	public const int b110011100011 = 3299;
+	public const int b110011100100 = 3300;
+	public const int b110011100101 = 3301;
+	public const int b110011100110 = 3302;
+	public const int b110011100111 = 3303;
+	public const int b110011101000 = 3304;
+	public const int b110011101001 = 3305;
+	public const int b110011101010 = 3306;
+	public const int b110011101011 = 3307;
+	public const int b110011101100 = 3308;
+	public const int b110011101101 = 3309;
+	public const int b110011101110 = 3310;
+	public const int b110011101111 = 3311;
+	public const int b110011110000 = 3312;
+	public const int b110011110001 = 3313;
+	public const int b110011110010 = 3314;
+	public const int b110011110011 = 3315;
+	public const int b110011110100 = 3316;
+	public const int b110011110101 = 3317;
+	public const int b110011110110 = 3318;
+	public const int b110011110111 = 3319;
+	public const int b110011111000 = 3320;
+	public const int b110011111001 = 3321;
+	public const int b110011111010 = 3322;
+	public const int b110011111011 = 3323;
+	public const int b110011111100 = 3324;
+	public const int b110011111101 = 3325;
+	public const int b110011111110 = 3326;
+	public const int b110011111111 = 3327;
+	public const int b110100000000 = 3328;
+	public const int b110100000001 = 3329;
+	public const int b110100000010 = 3330;
+	public const int b110100000011 = 3331;
+	public const int b110100000100 = 3332;
+	public const int b110100000101 = 3333;
+	public const int b110100000110 = 3334;
+	public const int b110100000111 = 3335;
+	public const int b110100001000 = 3336;
+	public const int b110100001001 = 3337;
+	public const int b110100001010 = 3338;
+	public const int b110100001011 = 3339;
+	public const int b110100001100 = 3340;
+	public const int b110100001101 = 3341;
+	public const int b110100001110 = 3342;
+	public const int b110100001111 = 3343;
+	public const int b110100010000 = 3344;
+	public const int b110100010001 = 3345;
+	public const int b110100010010 = 3346;
+	public const int b110100010011 = 3347;
+	public const int b110100010100 = 3348;
+	public const int b110100010101 = 3349;
+	public const int b110100010110 = 3350;
+	public const int b110100010111 = 3351;
+	public const int b110100011000 = 3352;
+	public const int b110100011001 = 3353;
+	public const int b110100011010 = 3354;
+	public const int b110100011011 = 3355;
+	public const int b110100011100 = 3356;
+	public const int b110100011101 = 3357;
+	public const int b110100011110 = 3358;
+	public const int b110100011111 = 3359;
+	public const int b110100100000 = 3360;
+	public const int b110100100001 = 3361;
+	public const int b110100100010 = 3362;
+	public const int b110100100011 = 3363;
+	public const int b110100100100 = 3364;
+	public const int b110100100101 = 3365;
+	public const int b110100100110 = 3366;
+	public const int b110100100111 = 3367;
+	public const int b110100101000 = 3368;
+	public const int b110100101001 = 3369;
+	public const int b110100101010 = 3370;
+	public const int b110100101011 = 3371;
+	public const int b110100101100 = 3372;
+	public const int b110100101101 = 3373;
+	public const int b110100101110 = 3374;
+	public const int b110100101111 = 3375;
+	public const int b110100110000 = 3376;
+	public const int b110100110001 = 3377;
+	public const int b110100110010 = 3378;
+	public const int b110100110011 = 3379;
+	public const int b110100110100 = 3380;
+	public const int b110100110101 = 3381;
+	public const int b110100110110 = 3382;
+	public const int b110100110111 = 3383;
+	public const int b110100111000 = 3384;
+	public const int b110100111001 = 3385;
+	public const int b110100111010 = 3386;
+	public const int b110100111011 = 3387;
+	public const int b110100111100 = 3388;
+	public const int b110100111101 = 3389;
+	public const int b110100111110 = 3390;
+	public const int b110100111111 = 3391;
+	public const int b110101000000 = 3392;
+	public const int b110101000001 = 3393;
+	public const int b110101000010 = 3394;
+	public const int b110101000011 = 3395;
+	public const int b110101000100 = 3396;
+	public const int b110101000101 = 3397;
+	public const int b110101000110 = 3398;
+	public const int b110101000111 = 3399;
+	public const int b110101001000 = 3400;
+	public const int b110101001001 = 3401;
+	public const int b110101001010 = 3402;
+	public const int b110101001011 = 3403;
+	public const int b110101001100 = 3404;
+	public const int b110101001101 = 3405;
+	public const int b110101001110 = 3406;
+	public const int b110101001111 = 3407;
+	public const int b110101010000 = 3408;
+	public const int b110101010001 = 3409;
+	public const int b110101010010 = 3410;
+	public const int b110101010011 = 3411;
+	public const int b110101010100 = 3412;
+	public const int b110101010101 = 3413;
+	public const int b110101010110 = 3414;
+	public const int b110101010111 = 3415;
+	public const int b110101011000 = 3416;
+	public const int b110101011001 = 3417;
+	public const int b110101011010 = 3418;
+	public const int b110101011011 = 3419;
+	public const int b110101011100 = 3420;
+	public const int b110101011101 = 3421;
+	public const int b110101011110 = 3422;
+	public const int b110101011111 = 3423;
+	public const int b110101100000 = 3424;
+	public const int b110101100001 = 3425;
+	public const int b110101100010 = 3426;
+	public const int b110101100011 = 3427;
+	public const int b110101100100 = 3428;
+	public const int b110101100101 = 3429;
+	public const int b110101100110 = 3430;
+	public const int b110101100111 = 3431;
+	public const int b110101101000 = 3432;
+	public const int b110101101001 = 3433;
+	public const int b110101101010 = 3434;
+	public const int b110101101011 = 3435;
+	public const int b110101101100 = 3436;
+	public const int b110101101101 = 3437;
+	public const int b110101101110 = 3438;
+	public const int b110101101111 = 3439;
+	public const int b110101110000 = 3440;
+	public const int b110101110001 = 3441;
+	public const int b110101110010 = 3442;
+	public const int b110101110011 = 3443;
+	public const int b110101110100 = 3444;
+	public const int b110101110101 = 3445;
+	public const int b110101110110 = 3446;
+	public const int b110101110111 = 3447;
+	public const int b110101111000 = 3448;
+	public const int b110101111001 = 3449;
+	public const int b110101111010 = 3450;
+	public const int b110101111011 = 3451;
+	public const int b110101111100 = 3452;
+	public const int b110101111101 = 3453;
+	public const int b110101111110 = 3454;
+	public const int b110101111111 = 3455;
+	public const int b110110000000 = 3456;
+	public const int b110110000001 = 3457;
+	public const int b110110000010 = 3458;
+	public const int b110110000011 = 3459;
+	public const int b110110000100 = 3460;
+	public const int b110110000101 = 3461;
+	public const int b110110000110 = 3462;
+	public const int b110110000111 = 3463;
+	public const int b110110001000 = 3464;
+	public const int b110110001001 = 3465;
+	public const int b110110001010 = 3466;
+	public const int b110110001011 = 3467;
+	public const int b110110001100 = 3468;
+	public const int b110110001101 = 3469;
+	public const int b110110001110 = 3470;
+	public const int b110110001111 = 3471;
+	public const int b110110010000 = 3472;
+	public const int b110110010001 = 3473;
+	public const int b110110010010 = 3474;
+	public const int b110110010011 = 3475;
+	public const int b110110010100 = 3476;
+	public const int b110110010101 = 3477;
+	public const int b110110010110 = 3478;
+	public const int b110110010111 = 3479;
+	public const int b110110011000 = 3480;
+	public const int b110110011001 = 3481;
+	public const int b110110011010 = 3482;
+	public const int b110110011011 = 3483;
+	public const int b110110011100 = 3484;
+	public const int b110110011101 = 3485;
+	public const int b110110011110 = 3486;
+	public const int b110110011111 = 3487;
+	public const int b110110100000 = 3488;
+	public const int b110110100001 = 3489;
+	public const int b110110100010 = 3490;
+	public const int b110110100011 = 3491;
+	public const int b110110100100 = 3492;
+	public const int b110110100101 = 3493;
+	public const int b110110100110 = 3494;
+	public const int b110110100111 = 3495;
+	public const int b110110101000 = 3496;
+	public const int b110110101001 = 3497;
+	public const int b110110101010 = 3498;
+	public const int b110110101011 = 3499;
+	public const int b110110101100 = 3500;
+	public const int b110110101101 = 3501;
+	public const int b110110101110 = 3502;
+	public const int b110110101111 = 3503;
+	public const int b110110110000 = 3504;
+	public const int b110110110001 = 3505;
+	public const int b110110110010 = 3506;
+	public const int b110110110011 = 3507;
+	public const int b110110110100 = 3508;
+	public const int b110110110101 = 3509;
+	public const int b110110110110 = 3510;
+	public const int b110110110111 = 3511;
+	public const int b110110111000 = 3512;
+	public const int b110110111001 = 3513;
+	public const int b110110111010 = 3514;
+	public const int b110110111011 = 3515;
+	public const int b110110111100 = 3516;
+	public const int b110110111101 = 3517;
+	public const int b110110111110 = 3518;
+	public const int b110110111111 = 3519;
+	public const int b110111000000 = 3520;
+	public const int b110111000001 = 3521;
+	public const int b110111000010 = 3522;
+	public const int b110111000011 = 3523;
+	public const int b110111000100 = 3524;
+	public const int b110111000101 = 3525;
+	public const int b110111000110 = 3526;
+	public const int b110111000111 = 3527;
+	public const int b110111001000 = 3528;
+	public const int b110111001001 = 3529;
+	public const int b110111001010 = 3530;
+	public const int b110111001011 = 3531;
+	public const int b110111001100 = 3532;
+	public const int b110111001101 = 3533;
+	public const int b110111001110 = 3534;
+	public const int b110111001111 = 3535;
+	public const int b110111010000 = 3536;
+	public const int b110111010001 = 3537;
+	public const int b110111010010 = 3538;
+	public const int b110111010011 = 3539;
+	public const int b110111010100 = 3540;
+	public const int b110111010101 = 3541;
+	public const int b110111010110 = 3542;
+	public const int b110111010111 = 3543;
+	public const int b110111011000 = 3544;
+	public const int b110111011001 = 3545;
+	public const int b110111011010 = 3546;
+	public const int b110111011011 = 3547;
+	public const int b110111011100 = 3548;
+	public const int b110111011101 = 3549;
+	public const int b110111011110 = 3550;
+	public const int b110111011111 = 3551;
+	public const int b110111100000 = 3552;
+	public const int b110111100001 = 3553;
+	public const int b110111100010 = 3554;
+	public const int b110111100011 = 3555;
+	public const int b110111100100 = 3556;
+	public const int b110111100101 = 3557;
+	public const int b110111100110 = 3558;
+	public const int b110111100111 = 3559;
+	public const int b110111101000 = 3560;
+	public const int b110111101001 = 3561;
+	public const int b110111101010 = 3562;
+	public const int b110111101011 = 3563;
+	public const int b110111101100 = 3564;
+	public const int b110111101101 = 3565;
+	public const int b110111101110 = 3566;
+	public const int b110111101111 = 3567;
+	public const int b110111110000 = 3568;
+	public const int b110111110001 = 3569;
+	public const int b110111110010 = 3570;
+	public const int b110111110011 = 3571;
+	public const int b110111110100 = 3572;
+	public const int b110111110101 = 3573;
+	public const int b110111110110 = 3574;
+	public const int b110111110111 = 3575;
+	public const int b110111111000 = 3576;
+	public const int b110111111001 = 3577;
+	public const int b110111111010 = 3578;
+	public const int b110111111011 = 3579;
+	public const int b110111111100 = 3580;
+	public const int b110111111101 = 3581;
+	public const int b110111111110 = 3582;
+	public const int b110111111111 = 3583;
+	public const int b111000000000 = 3584;
+	public const int b111000000001 = 3585;
+	public const int b111000000010 = 3586;
+	public const int b111000000011 = 3587;
+	public const int b111000000100 = 3588;
+	public const int b111000000101 = 3589;
+	public const int b111000000110 = 3590;
+	public const int b111000000111 = 3591;
+	public const int b111000001000 = 3592;
+	public const int b111000001001 = 3593;
+	public const int b111000001010 = 3594;
+	public const int b111000001011 = 3595;
+	public const int b111000001100 = 3596;
+	public const int b111000001101 = 3597;
+	public const int b111000001110 = 3598;
+	public const int b111000001111 = 3599;
+	public const int b111000010000 = 3600;
+	public const int b111000010001 = 3601;
+	public const int b111000010010 = 3602;
+	public const int b111000010011 = 3603;
+	public const int b111000010100 = 3604;
+	public const int b111000010101 = 3605;
+	public const int b111000010110 = 3606;
+	public const int b111000010111 = 3607;
+	public const int b111000011000 = 3608;
+	public const int b111000011001 = 3609;
+	public const int b111000011010 = 3610;
+	public const int b111000011011 = 3611;
+	public const int b111000011100 = 3612;
+	public const int b111000011101 = 3613;
+	public const int b111000011110 = 3614;
+	public const int b111000011111 = 3615;
+	public const int b111000100000 = 3616;
+	public const int b111000100001 = 3617;
+	public const int b111000100010 = 3618;
+	public const int b111000100011 = 3619;
+	public const int b111000100100 = 3620;
+	public const int b111000100101 = 3621;
+	public const int b111000100110 = 3622;
+	public const int b111000100111 = 3623;
+	public const int b111000101000 = 3624;
+	public const int b111000101001 = 3625;
+	public const int b111000101010 = 3626;
+	public const int b111000101011 = 3627;
+	public const int b111000101100 = 3628;
+	public const int b111000101101 = 3629;
+	public const int b111000101110 = 3630;
+	public const int b111000101111 = 3631;
+	public const int b111000110000 = 3632;
+	public const int b111000110001 = 3633;
+	public const int b111000110010 = 3634;
+	public const int b111000110011 = 3635;
+	public const int b111000110100 = 3636;
+	public const int b111000110101 = 3637;
+	public const int b111000110110 = 3638;
+	public const int b111000110111 = 3639;
+	public const int b111000111000 = 3640;
+	public const int b111000111001 = 3641;
+	public const int b111000111010 = 3642;
+	public const int b111000111011 = 3643;
+	public const int b111000111100 = 3644;
+	public const int b111000111101 = 3645;
+	public const int b111000111110 = 3646;
+	public const int b111000111111 = 3647;
+	public const int b111001000000 = 3648;
+	public const int b111001000001 = 3649;
+	public const int b111001000010 = 3650;
+	public const int b111001000011 = 3651;
+	public const int b111001000100 = 3652;
+	public const int b111001000101 = 3653;
+	public const int b111001000110 = 3654;
+	public const int b111001000111 = 3655;
+	public const int b111001001000 = 3656;
+	public const int b111001001001 = 3657;
+	public const int b111001001010 = 3658;
+	public const int b111001001011 = 3659;
+	public const int b111001001100 = 3660;
+	public const int b111001001101 = 3661;
+	public const int b111001001110 = 3662;
+	public const int b111001001111 = 3663;
+	public const int b111001010000 = 3664;
+	public const int b111001010001 = 3665;
+	public const int b111001010010 = 3666;
+	public const int b111001010011 = 3667;
+	public const int b111001010100 = 3668;
+	public const int b111001010101 = 3669;
+	public const int b111001010110 = 3670;
+	public const int b111001010111 = 3671;
+	public const int b111001011000 = 3672;
+	public const int b111001011001 = 3673;
+	public const int b111001011010 = 3674;
+	public const int b111001011011 = 3675;
+	public const int b111001011100 = 3676;
+	public const int b111001011101 = 3677;
+	public const int b111001011110 = 3678;
+	public const int b111001011111 = 3679;
+	public const int b111001100000 = 3680;
+	public const int b111001100001 = 3681;
+	public const int b111001100010 = 3682;
+	public const int b111001100011 = 3683;
+	public const int b111001100100 = 3684;
+	public const int b111001100101 = 3685;
+	public const int b111001100110 = 3686;
+	public const int b111001100111 = 3687;
+	public const int b111001101000 = 3688;
+	public const int b111001101001 = 3689;
+	public const int b111001101010 = 3690;
+	public const int b111001101011 = 3691;
+	public const int b111001101100 = 3692;
+	public const int b111001101101 = 3693;
+	public const int b111001101110 = 3694;
+	public const int b111001101111 = 3695;
+	public const int b111001110000 = 3696;
+	public const int b111001110001 = 3697;
+	public const int b111001110010 = 3698;
+	public const int b111001110011 = 3699;
+	public const int b111001110100 = 3700;
+	public const int b111001110101 = 3701;
+	public const int b111001110110 = 3702;
+	public const int b111001110111 = 3703;
+	public const int b111001111000 = 3704;
+	public const int b111001111001 = 3705;
+	public const int b111001111010 = 3706;
+	public const int b111001111011 = 3707;
+	public const int b111001111100 = 3708;
+	public const int b111001111101 = 3709;
+	public const int b111001111110 = 3710;
+	public const int b111001111111 = 3711;
+	public const int b111010000000 = 3712;
+	public const int b111010000001 = 3713;
+	public const int b111010000010 = 3714;
+	public const int b111010000011 = 3715;
+	public const int b111010000100 = 3716;
+	public const int b111010000101 = 3717;
+	public const int b111010000110 = 3718;
+	public const int b111010000111 = 3719;
+	public const int b111010001000 = 3720;
+	public const int b111010001001 = 3721;
+	public const int b111010001010 = 3722;
+	public const int b111010001011 = 3723;
+	public const int b111010001100 = 3724;
+	public const int b111010001101 = 3725;
+	public const int b111010001110 = 3726;
+	public const int b111010001111 = 3727;
+	public const int b111010010000 = 3728;
+	public const int b111010010001 = 3729;
+	public const int b111010010010 = 3730;
+	public const int b111010010011 = 3731;
+	public const int b111010010100 = 3732;
+	public const int b111010010101 = 3733;
+	public const int b111010010110 = 3734;
+	public const int b111010010111 = 3735;
+	public const int b111010011000 = 3736;
+	public const int b111010011001 = 3737;
+	public const int b111010011010 = 3738;
+	public const int b111010011011 = 3739;
+	public const int b111010011100 = 3740;
+	public const int b111010011101 = 3741;
+	public const int b111010011110 = 3742;
+	public const int b111010011111 = 3743;
+	public const int b111010100000 = 3744;
+	public const int b111010100001 = 3745;
+	public const int b111010100010 = 3746;
+	public const int b111010100011 = 3747;
+	public const int b111010100100 = 3748;
+	public const int b111010100101 = 3749;
+	public const int b111010100110 = 3750;
+	public const int b111010100111 = 3751;
+	public const int b111010101000 = 3752;
+	public const int b111010101001 = 3753;
+	public const int b111010101010 = 3754;
+	public const int b111010101011 = 3755;
+	public const int b111010101100 = 3756;
+	public const int b111010101101 = 3757;
+	public const int b111010101110 = 3758;
+	public const int b111010101111 = 3759;
+	public const int b111010110000 = 3760;
+	public const int b111010110001 = 3761;
+	public const int b111010110010 = 3762;
+	public const int b111010110011 = 3763;
+	public const int b111010110100 = 3764;
+	public const int b111010110101 = 3765;
+	public const int b111010110110 = 3766;
+	public const int b111010110111 = 3767;
+	public const int b111010111000 = 3768;
+	public const int b111010111001 = 3769;
+	public const int b111010111010 = 3770;
+	public const int b111010111011 = 3771;
+	public const int b111010111100 = 3772;
+	public const int b111010111101 = 3773;
+	public const int b111010111110 = 3774;
+	public const int b111010111111 = 3775;
+	public const int b111011000000 = 3776;
+	public const int b111011000001 = 3777;
+	public const int b111011000010 = 3778;
+	public const int b111011000011 = 3779;
+	public const int b111011000100 = 3780;
+	public const int b111011000101 = 3781;
+	public const int b111011000110 = 3782;
+	public const int b111011000111 = 3783;
+	public const int b111011001000 = 3784;
+	public const int b111011001001 = 3785;
+	public const int b111011001010 = 3786;
+	public const int b111011001011 = 3787;
+	public const int b111011001100 = 3788;
+	public const int b111011001101 = 3789;
+	public const int b111011001110 = 3790;
+	public const int b111011001111 = 3791;
+	public const int b111011010000 = 3792;
+	public const int b111011010001 = 3793;
+	public const int b111011010010 = 3794;
+	public const int b111011010011 = 3795;
+	public const int b111011010100 = 3796;
+	public const int b111011010101 = 3797;
+	public const int b111011010110 = 3798;
+	public const int b111011010111 = 3799;
+	public const int b111011011000 = 3800;
+	public const int b111011011001 = 3801;
+	public const int b111011011010 = 3802;
+	public const int b111011011011 = 3803;
+	public const int b111011011100 = 3804;
+	public const int b111011011101 = 3805;
+	public const int b111011011110 = 3806;
+	public const int b111011011111 = 3807;
+	public const int b111011100000 = 3808;
+	public const int b111011100001 = 3809;
+	public const int b111011100010 = 3810;
+	public const int b111011100011 = 3811;
+	public const int b111011100100 = 3812;
+	public const int b111011100101 = 3813;
+	public const int b111011100110 = 3814;
+	public const int b111011100111 = 3815;
+	public const int b111011101000 = 3816;
+	public const int b111011101001 = 3817;
+	public const int b111011101010 = 3818;
+	public const int b111011101011 = 3819;
+	public const int b111011101100 = 3820;
+	public const int b111011101101 = 3821;
+	public const int b111011101110 = 3822;
+	public const int b111011101111 = 3823;
+	public const int b111011110000 = 3824;
+	public const int b111011110001 = 3825;
+	public const int b111011110010 = 3826;
+	public const int b111011110011 = 3827;
+	public const int b111011110100 = 3828;
+	public const int b111011110101 = 3829;
+	public const int b111011110110 = 3830;
+	public const int b111011110111 = 3831;
+	public const int b111011111000 = 3832;
+	public const int b111011111001 = 3833;
+	public const int b111011111010 = 3834;
+	public const int b111011111011 = 3835;
+	public const int b111011111100 = 3836;
+	public const int b111011111101 = 3837;
+	public const int b111011111110 = 3838;
+	public const int b111011111111 = 3839;
+	public const int b111100000000 = 3840;
+	public const int b111100000001 = 3841;
+	public const int b111100000010 = 3842;
+	public const int b111100000011 = 3843;
+	public const int b111100000100 = 3844;
+	public const int b111100000101 = 3845;
+	public const int b111100000110 = 3846;
+	public const int b111100000111 = 3847;
+	public const int b111100001000 = 3848;
+	public const int b111100001001 = 3849;
+	public const int b111100001010 = 3850;
+	public const int b111100001011 = 3851;
+	public const int b111100001100 = 3852;
+	public const int b111100001101 = 3853;
+	public const int b111100001110 = 3854;
+	public const int b111100001111 = 3855;
+	public const int b111100010000 = 3856;
+	public const int b111100010001 = 3857;
+	public const int b111100010010 = 3858;
+	public const int b111100010011 = 3859;
+	public const int b111100010100 = 3860;
+	public const int b111100010101 = 3861;
+	public const int b111100010110 = 3862;
+	public const int b111100010111 = 3863;
+	public const int b111100011000 = 3864;
+	public const int b111100011001 = 3865;
+	public const int b111100011010 = 3866;
+	public const int b111100011011 = 3867;
+	public const int b111100011100 = 3868;
+	public const int b111100011101 = 3869;
+	public const int b111100011110 = 3870;
+	public const int b111100011111 = 3871;
+	public const int b111100100000 = 3872;
+	public const int b111100100001 = 3873;
+	public const int b111100100010 = 3874;
+	public const int b111100100011 = 3875;
+	public const int b111100100100 = 3876;
+	public const int b111100100101 = 3877;
+	public const int b111100100110 = 3878;
+	public const int b111100100111 = 3879;
+	public const int b111100101000 = 3880;
+	public const int b111100101001 = 3881;
+	public const int b111100101010 = 3882;
+	public const int b111100101011 = 3883;
+	public const int b111100101100 = 3884;
+	public const int b111100101101 = 3885;
+	public const int b111100101110 = 3886;
+	public const int b111100101111 = 3887;
+	public const int b111100110000 = 3888;
+	public const int b111100110001 = 3889;
+	public const int b111100110010 = 3890;
+	public const int b111100110011 = 3891;
+	public const int b111100110100 = 3892;
+	public const int b111100110101 = 3893;
+	public const int b111100110110 = 3894;
+	public const int b111100110111 = 3895;
+	public const int b111100111000 = 3896;
+	public const int b111100111001 = 3897;
+	public const int b111100111010 = 3898;
+	public const int b111100111011 = 3899;
+	public const int b111100111100 = 3900;
+	public const int b111100111101 = 3901;
+	public const int b111100111110 = 3902;
+	public const int b111100111111 = 3903;
+	public const int b111101000000 = 3904;
+	public const int b111101000001 = 3905;
+	public const int b111101000010 = 3906;
+	public const int b111101000011 = 3907;
+	public const int b111101000100 = 3908;
+	public const int b111101000101 = 3909;
+	public const int b111101000110 = 3910;
+	public const int b111101000111 = 3911;
+	public const int b111101001000 = 3912;
+	public const int b111101001001 = 3913;
+	public const int b111101001010 = 3914;
+	public const int b111101001011 = 3915;
+	public const int b111101001100 = 3916;
+	public const int b111101001101 = 3917;
+	public const int b111101001110 = 3918;
+	public const int b111101001111 = 3919;
+	public const int b111101010000 = 3920;
+	public const int b111101010001 = 3921;
+	public const int b111101010010 = 3922;
+	public const int b111101010011 = 3923;
+	public const int b111101010100 = 3924;
+	public const int b111101010101 = 3925;
+	public const int b111101010110 = 3926;
+	public const int b111101010111 = 3927;
+	public const int b111101011000 = 3928;
+	public const int b111101011001 = 3929;
+	public const int b111101011010 = 3930;
+	public const int b111101011011 = 3931;
+	public const int b111101011100 = 3932;
+	public const int b111101011101 = 3933;
+	public const int b111101011110 = 3934;
+	public const int b111101011111 = 3935;
+	public const int b111101100000 = 3936;
+	public const int b111101100001 = 3937;
+	public const int b111101100010 = 3938;
+	public const int b111101100011 = 3939;
+	public const int b111101100100 = 3940;
+	public const int b111101100101 = 3941;
+	public const int b111101100110 = 3942;
+	public const int b111101100111 = 3943;
+	public const int b111101101000 = 3944;
+	public const int b111101101001 = 3945;
+	public const int b111101101010 = 3946;
+	public const int b111101101011 = 3947;
+	public const int b111101101100 = 3948;
+	public const int b111101101101 = 3949;
+	public const int b111101101110 = 3950;
+	public const int b111101101111 = 3951;
+	public const int b111101110000 = 3952;
+	public const int b111101110001 = 3953;
+	public const int b111101110010 = 3954;
+	public const int b111101110011 = 3955;
+	public const int b111101110100 = 3956;
+	public const int b111101110101 = 3957;
+	public const int b111101110110 = 3958;
+	public const int b111101110111 = 3959;
+	public const int b111101111000 = 3960;
+	public const int b111101111001 = 3961;
+	public const int b111101111010 = 3962;
+	public const int b111101111011 = 3963;
+	public const int b111101111100 = 3964;
+	public const int b111101111101 = 3965;
+	public const int b111101111110 = 3966;
+	public const int b111101111111 = 3967;
+	public const int b111110000000 = 3968;
+	public const int b111110000001 = 3969;
+	public const int b111110000010 = 3970;
+	public const int b111110000011 = 3971;
+	public const int b111110000100 = 3972;
+	public const int b111110000101 = 3973;
+	public const int b111110000110 = 3974;
+	public const int b111110000111 = 3975;
+	public const int b111110001000 = 3976;
+	public const int b111110001001 = 3977;
+	public const int b111110001010 = 3978;
+	public const int b111110001011 = 3979;
+	public const int b111110001100 = 3980;
+	public const int b111110001101 = 3981;
+	public const int b111110001110 = 3982;
+	public const int b111110001111 = 3983;
+	public const int b111110010000 = 3984;
+	public const int b111110010001 = 3985;
+	public const int b111110010010 = 3986;
+	public const int b111110010011 = 3987;
+	public const int b111110010100 = 3988;
+	public const int b111110010101 = 3989;
+	public const int b111110010110 = 3990;
+	public const int b111110010111 = 3991;
+	public const int b111110011000 = 3992;
+	public const int b111110011001 = 3993;
+	public const int b111110011010 = 3994;
+	public const int b111110011011 = 3995;
+	public const int b111110011100 = 3996;
+	public const int b111110011101 = 3997;
+	public const int b111110011110 = 3998;
+	public const int b111110011111 = 3999;
+	public const int b111110100000 = 4000;
+	public const int b111110100001 = 4001;
+	public const int b111110100010 = 4002;
+	public const int b111110100011 = 4003;
+	public const int b111110100100 = 4004;
+	public const int b111110100101 = 4005;
+	public const int b111110100110 = 4006;
+	public const int b111110100111 = 4007;
+	public const int b111110101000 = 4008;
+	public const int b111110101001 = 4009;
+	public const int b111110101010 = 4010;
+	public const int b111110101011 = 4011;
+	public const int b111110101100 = 4012;
+	public const int b111110101101 = 4013;
+	public const int b111110101110 = 4014;
+	public const int b111110101111 = 4015;
+	public const int b111110110000 = 4016;
+	public const int b111110110001 = 4017;
+	public const int b111110110010 = 4018;
+	public const int b111110110011 = 4019;
+	public const int b111110110100 = 4020;
+	public const int b111110110101 = 4021;
+	public const int b111110110110 = 4022;
+	public const int b111110110111 = 4023;
+	public const int b111110111000 = 4024;
+	public const int b111110111001 = 4025;
+	public const int b111110111010 = 4026;
+	public const int b111110111011 = 4027;
+	public const int b111110111100 = 4028;
+	public const int b111110111101 = 4029;
+	public const int b111110111110 = 4030;
+	public const int b111110111111 = 4031;
+	public const int b111111000000 = 4032;
+	public const int b111111000001 = 4033;
+	public const int b111111000010 = 4034;
+	public const int b111111000011 = 4035;
+	public const int b111111000100 = 4036;
+	public const int b111111000101 = 4037;
+	public const int b111111000110 = 4038;
+	public const int b111111000111 = 4039;
+	public const int b111111001000 = 4040;
+	public const int b111111001001 = 4041;
+	public const int b111111001010 = 4042;
+	public const int b111111001011 = 4043;
+	public const int b111111001100 = 4044;
+	public const int b111111001101 = 4045;
+	public const int b111111001110 = 4046;
+	public const int b111111001111 = 4047;
+	public const int b111111010000 = 4048;
+	public const int b111111010001 = 4049;
+	public const int b111111010010 = 4050;
+	public const int b111111010011 = 4051;
+	public const int b111111010100 = 4052;
+	public const int b111111010101 = 4053;
+	public const int b111111010110 = 4054;
+	public const int b111111010111 = 4055;
+	public const int b111111011000 = 4056;
+	public const int b111111011001 = 4057;
+	public const int b111111011010 = 4058;
+	public const int b111111011011 = 4059;
+	public const int b111111011100 = 4060;
+	public const int b111111011101 = 4061;
+	public const int b111111011110 = 4062;
+	public const int b111111011111 = 4063;
+	public const int b111111100000 = 4064;
+	public const int b111111100001 = 4065;
+	public const int b111111100010 = 4066;
+	public const int b111111100011 = 4067;
+	public const int b111111100100 = 4068;
+	public const int b111111100101 = 4069;
+	public const int b111111100110 = 4070;
+	public const int b111111100111 = 4071;
+	public const int b111111101000 = 4072;
+	public const int b111111101001 = 4073;
+	public const int b111111101010 = 4074;
+	public const int b111111101011 = 4075;
+	public const int b111111101100 = 4076;
+	public const int b111111101101 = 4077;
+	public const int b111111101110 = 4078;
+	public const int b111111101111 = 4079;
+	public const int b111111110000 = 4080;
+	public const int b111111110001 = 4081;
+	public const int b111111110010 = 4082;
+	public const int b111111110011 = 4083;
+	public const int b111111110100 = 4084;
+	public const int b111111110101 = 4085;
+	public const int b111111110110 = 4086;
+	public const int b111111110111 = 4087;
+	public const int b111111111000 = 4088;
+	public const int b111111111001 = 4089;
+	public const int b111111111010 = 4090;
+	public const int b111111111011 = 4091;
+	public const int b111111111100 = 4092;
+	public const int b111111111101 = 4093;
+	public const int b111111111110 = 4094;
+	public const int b111111111111 = 4095;
+	public const int b00000000000 = 0;
+	public const int b00000000001 = 1;
+	public const int b00000000010 = 2;
+	public const int b00000000011 = 3;
+	public const int b00000000100 = 4;
+	public const int b00000000101 = 5;
+	public const int b00000000110 = 6;
+	public const int b00000000111 = 7;
+	public const int b00000001000 = 8;
+	public const int b00000001001 = 9;
+	public const int b00000001010 = 10;
+	public const int b00000001011 = 11;
+	public const int b00000001100 = 12;
+	public const int b00000001101 = 13;
+	public const int b00000001110 = 14;
+	public const int b00000001111 = 15;
+	public const int b00000010000 = 16;
+	public const int b00000010001 = 17;
+	public const int b00000010010 = 18;
+	public const int b00000010011 = 19;
+	public const int b00000010100 = 20;
+	public const int b00000010101 = 21;
+	public const int b00000010110 = 22;
+	public const int b00000010111 = 23;
+	public const int b00000011000 = 24;
+	public const int b00000011001 = 25;
+	public const int b00000011010 = 26;
+	public const int b00000011011 = 27;
+	public const int b00000011100 = 28;
+	public const int b00000011101 = 29;
+	public const int b00000011110 = 30;
+	public const int b00000011111 = 31;
+	public const int b00000100000 = 32;
+	public const int b00000100001 = 33;
+	public const int b00000100010 = 34;
+	public const int b00000100011 = 35;
+	public const int b00000100100 = 36;
+	public const int b00000100101 = 37;
+	public const int b00000100110 = 38;
+	public const int b00000100111 = 39;
+	public const int b00000101000 = 40;
+	public const int b00000101001 = 41;
+	public const int b00000101010 = 42;
+	public const int b00000101011 = 43;
+	public const int b00000101100 = 44;
+	public const int b00000101101 = 45;
+	public const int b00000101110 = 46;
+	public const int b00000101111 = 47;
+	public const int b00000110000 = 48;
+	public const int b00000110001 = 49;
+	public const int b00000110010 = 50;
+	public const int b00000110011 = 51;
+	public const int b00000110100 = 52;
+	public const int b00000110101 = 53;
+	public const int b00000110110 = 54;
+	public const int b00000110111 = 55;
+	public const int b00000111000 = 56;
+	public const int b00000111001 = 57;
+	public const int b00000111010 = 58;
+	public const int b00000111011 = 59;
+	public const int b00000111100 = 60;
+	public const int b00000111101 = 61;
+	public const int b00000111110 = 62;
+	public const int b00000111111 = 63;
+	public const int b00001000000 = 64;
+	public const int b00001000001 = 65;
+	public const int b00001000010 = 66;
+	public const int b00001000011 = 67;
+	public const int b00001000100 = 68;
+	public const int b00001000101 = 69;
+	public const int b00001000110 = 70;
+	public const int b00001000111 = 71;
+	public const int b00001001000 = 72;
+	public const int b00001001001 = 73;
+	public const int b00001001010 = 74;
+	public const int b00001001011 = 75;
+	public const int b00001001100 = 76;
+	public const int b00001001101 = 77;
+	public const int b00001001110 = 78;
+	public const int b00001001111 = 79;
+	public const int b00001010000 = 80;
+	public const int b00001010001 = 81;
+	public const int b00001010010 = 82;
+	public const int b00001010011 = 83;
+	public const int b00001010100 = 84;
+	public const int b00001010101 = 85;
+	public const int b00001010110 = 86;
+	public const int b00001010111 = 87;
+	public const int b00001011000 = 88;
+	public const int b00001011001 = 89;
+	public const int b00001011010 = 90;
+	public const int b00001011011 = 91;
+	public const int b00001011100 = 92;
+	public const int b00001011101 = 93;
+	public const int b00001011110 = 94;
+	public const int b00001011111 = 95;
+	public const int b00001100000 = 96;
+	public const int b00001100001 = 97;
+	public const int b00001100010 = 98;
+	public const int b00001100011 = 99;
+	public const int b00001100100 = 100;
+	public const int b00001100101 = 101;
+	public const int b00001100110 = 102;
+	public const int b00001100111 = 103;
+	public const int b00001101000 = 104;
+	public const int b00001101001 = 105;
+	public const int b00001101010 = 106;
+	public const int b00001101011 = 107;
+	public const int b00001101100 = 108;
+	public const int b00001101101 = 109;
+	public const int b00001101110 = 110;
+	public const int b00001101111 = 111;
+	public const int b00001110000 = 112;
+	public const int b00001110001 = 113;
+	public const int b00001110010 = 114;
+	public const int b00001110011 = 115;
+	public const int b00001110100 = 116;
+	public const int b00001110101 = 117;
+	public const int b00001110110 = 118;
+	public const int b00001110111 = 119;
+	public const int b00001111000 = 120;
+	public const int b00001111001 = 121;
+	public const int b00001111010 = 122;
+	public const int b00001111011 = 123;
+	public const int b00001111100 = 124;
+	public const int b00001111101 = 125;
+	public const int b00001111110 = 126;
+	public const int b00001111111 = 127;
+	public const int b00010000000 = 128;
+	public const int b00010000001 = 129;
+	public const int b00010000010 = 130;
+	public const int b00010000011 = 131;
+	public const int b00010000100 = 132;
+	public const int b00010000101 = 133;
+	public const int b00010000110 = 134;
+	public const int b00010000111 = 135;
+	public const int b00010001000 = 136;
+	public const int b00010001001 = 137;
+	public const int b00010001010 = 138;
+	public const int b00010001011 = 139;
+	public const int b00010001100 = 140;
+	public const int b00010001101 = 141;
+	public const int b00010001110 = 142;
+	public const int b00010001111 = 143;
+	public const int b00010010000 = 144;
+	public const int b00010010001 = 145;
+	public const int b00010010010 = 146;
+	public const int b00010010011 = 147;
+	public const int b00010010100 = 148;
+	public const int b00010010101 = 149;
+	public const int b00010010110 = 150;
+	public const int b00010010111 = 151;
+	public const int b00010011000 = 152;
+	public const int b00010011001 = 153;
+	public const int b00010011010 = 154;
+	public const int b00010011011 = 155;
+	public const int b00010011100 = 156;
+	public const int b00010011101 = 157;
+	public const int b00010011110 = 158;
+	public const int b00010011111 = 159;
+	public const int b00010100000 = 160;
+	public const int b00010100001 = 161;
+	public const int b00010100010 = 162;
+	public const int b00010100011 = 163;
+	public const int b00010100100 = 164;
+	public const int b00010100101 = 165;
+	public const int b00010100110 = 166;
+	public const int b00010100111 = 167;
+	public const int b00010101000 = 168;
+	public const int b00010101001 = 169;
+	public const int b00010101010 = 170;
+	public const int b00010101011 = 171;
+	public const int b00010101100 = 172;
+	public const int b00010101101 = 173;
+	public const int b00010101110 = 174;
+	public const int b00010101111 = 175;
+	public const int b00010110000 = 176;
+	public const int b00010110001 = 177;
+	public const int b00010110010 = 178;
+	public const int b00010110011 = 179;
+	public const int b00010110100 = 180;
+	public const int b00010110101 = 181;
+	public const int b00010110110 = 182;
+	public const int b00010110111 = 183;
+	public const int b00010111000 = 184;
+	public const int b00010111001 = 185;
+	public const int b00010111010 = 186;
+	public const int b00010111011 = 187;
+	public const int b00010111100 = 188;
+	public const int b00010111101 = 189;
+	public const int b00010111110 = 190;
+	public const int b00010111111 = 191;
+	public const int b00011000000 = 192;
+	public const int b00011000001 = 193;
+	public const int b00011000010 = 194;
+	public const int b00011000011 = 195;
+	public const int b00011000100 = 196;
+	public const int b00011000101 = 197;
+	public const int b00011000110 = 198;
+	public const int b00011000111 = 199;
+	public const int b00011001000 = 200;
+	public const int b00011001001 = 201;
+	public const int b00011001010 = 202;
+	public const int b00011001011 = 203;
+	public const int b00011001100 = 204;
+	public const int b00011001101 = 205;
+	public const int b00011001110 = 206;
+	public const int b00011001111 = 207;
+	public const int b00011010000 = 208;
+	public const int b00011010001 = 209;
+	public const int b00011010010 = 210;
+	public const int b00011010011 = 211;
+	public const int b00011010100 = 212;
+	public const int b00011010101 = 213;
+	public const int b00011010110 = 214;
+	public const int b00011010111 = 215;
+	public const int b00011011000 = 216;
+	public const int b00011011001 = 217;
+	public const int b00011011010 = 218;
+	public const int b00011011011 = 219;
+	public const int b00011011100 = 220;
+	public const int b00011011101 = 221;
+	public const int b00011011110 = 222;
+	public const int b00011011111 = 223;
+	public const int b00011100000 = 224;
+	public const int b00011100001 = 225;
+	public const int b00011100010 = 226;
+	public const int b00011100011 = 227;
+	public const int b00011100100 = 228;
+	public const int b00011100101 = 229;
+	public const int b00011100110 = 230;
+	public const int b00011100111 = 231;
+	public const int b00011101000 = 232;
+	public const int b00011101001 = 233;
+	public const int b00011101010 = 234;
+	public const int b00011101011 = 235;
+	public const int b00011101100 = 236;
+	public const int b00011101101 = 237;
+	public const int b00011101110 = 238;
+	public const int b00011101111 = 239;
+	public const int b00011110000 = 240;
+	public const int b00011110001 = 241;
+	public const int b00011110010 = 242;
+	public const int b00011110011 = 243;
+	public const int b00011110100 = 244;
+	public const int b00011110101 = 245;
+	public const int b00011110110 = 246;
+	public const int b00011110111 = 247;
+	public const int b00011111000 = 248;
+	public const int b00011111001 = 249;
+	public const int b00011111010 = 250;
+	public const int b00011111011 = 251;
+	public const int b00011111100 = 252;
+	public const int b00011111101 = 253;
+	public const int b00011111110 = 254;
+	public const int b00011111111 = 255;
+	public const int b00100000000 = 256;
+	public const int b00100000001 = 257;
+	public const int b00100000010 = 258;
+	public const int b00100000011 = 259;
+	public const int b00100000100 = 260;
+	public const int b00100000101 = 261;
+	public const int b00100000110 = 262;
+	public const int b00100000111 = 263;
+	public const int b00100001000 = 264;
+	public const int b00100001001 = 265;
+	public const int b00100001010 = 266;
+	public const int b00100001011 = 267;
+	public const int b00100001100 = 268;
+	public const int b00100001101 = 269;
+	public const int b00100001110 = 270;
+	public const int b00100001111 = 271;
+	public const int b00100010000 = 272;
+	public const int b00100010001 = 273;
+	public const int b00100010010 = 274;
+	public const int b00100010011 = 275;
+	public const int b00100010100 = 276;
+	public const int b00100010101 = 277;
+	public const int b00100010110 = 278;
+	public const int b00100010111 = 279;
+	public const int b00100011000 = 280;
+	public const int b00100011001 = 281;
+	public const int b00100011010 = 282;
+	public const int b00100011011 = 283;
+	public const int b00100011100 = 284;
+	public const int b00100011101 = 285;
+	public const int b00100011110 = 286;
+	public const int b00100011111 = 287;
+	public const int b00100100000 = 288;
+	public const int b00100100001 = 289;
+	public const int b00100100010 = 290;
+	public const int b00100100011 = 291;
+	public const int b00100100100 = 292;
+	public const int b00100100101 = 293;
+	public const int b00100100110 = 294;
+	public const int b00100100111 = 295;
+	public const int b00100101000 = 296;
+	public const int b00100101001 = 297;
+	public const int b00100101010 = 298;
+	public const int b00100101011 = 299;
+	public const int b00100101100 = 300;
+	public const int b00100101101 = 301;
+	public const int b00100101110 = 302;
+	public const int b00100101111 = 303;
+	public const int b00100110000 = 304;
+	public const int b00100110001 = 305;
+	public const int b00100110010 = 306;
+	public const int b00100110011 = 307;
+	public const int b00100110100 = 308;
+	public const int b00100110101 = 309;
+	public const int b00100110110 = 310;
+	public const int b00100110111 = 311;
+	public const int b00100111000 = 312;
+	public const int b00100111001 = 313;
+	public const int b00100111010 = 314;
+	public const int b00100111011 = 315;
+	public const int b00100111100 = 316;
+	public const int b00100111101 = 317;
+	public const int b00100111110 = 318;
+	public const int b00100111111 = 319;
+	public const int b00101000000 = 320;
+	public const int b00101000001 = 321;
+	public const int b00101000010 = 322;
+	public const int b00101000011 = 323;
+	public const int b00101000100 = 324;
+	public const int b00101000101 = 325;
+	public const int b00101000110 = 326;
+	public const int b00101000111 = 327;
+	public const int b00101001000 = 328;
+	public const int b00101001001 = 329;
+	public const int b00101001010 = 330;
+	public const int b00101001011 = 331;
+	public const int b00101001100 = 332;
+	public const int b00101001101 = 333;
+	public const int b00101001110 = 334;
+	public const int b00101001111 = 335;
+	public const int b00101010000 = 336;
+	public const int b00101010001 = 337;
+	public const int b00101010010 = 338;
+	public const int b00101010011 = 339;
+	public const int b00101010100 = 340;
+	public const int b00101010101 = 341;
+	public const int b00101010110 = 342;
+	public const int b00101010111 = 343;
+	public const int b00101011000 = 344;
+	public const int b00101011001 = 345;
+	public const int b00101011010 = 346;
+	public const int b00101011011 = 347;
+	public const int b00101011100 = 348;
+	public const int b00101011101 = 349;
+	public const int b00101011110 = 350;
+	public const int b00101011111 = 351;
+	public const int b00101100000 = 352;
+	public const int b00101100001 = 353;
+	public const int b00101100010 = 354;
+	public const int b00101100011 = 355;
+	public const int b00101100100 = 356;
+	public const int b00101100101 = 357;
+	public const int b00101100110 = 358;
+	public const int b00101100111 = 359;
+	public const int b00101101000 = 360;
+	public const int b00101101001 = 361;
+	public const int b00101101010 = 362;
+	public const int b00101101011 = 363;
+	public const int b00101101100 = 364;
+	public const int b00101101101 = 365;
+	public const int b00101101110 = 366;
+	public const int b00101101111 = 367;
+	public const int b00101110000 = 368;
+	public const int b00101110001 = 369;
+	public const int b00101110010 = 370;
+	public const int b00101110011 = 371;
+	public const int b00101110100 = 372;
+	public const int b00101110101 = 373;
+	public const int b00101110110 = 374;
+	public const int b00101110111 = 375;
+	public const int b00101111000 = 376;
+	public const int b00101111001 = 377;
+	public const int b00101111010 = 378;
+	public const int b00101111011 = 379;
+	public const int b00101111100 = 380;
+	public const int b00101111101 = 381;
+	public const int b00101111110 = 382;
+	public const int b00101111111 = 383;
+	public const int b00110000000 = 384;
+	public const int b00110000001 = 385;
+	public const int b00110000010 = 386;
+	public const int b00110000011 = 387;
+	public const int b00110000100 = 388;
+	public const int b00110000101 = 389;
+	public const int b00110000110 = 390;
+	public const int b00110000111 = 391;
+	public const int b00110001000 = 392;
+	public const int b00110001001 = 393;
+	public const int b00110001010 = 394;
+	public const int b00110001011 = 395;
+	public const int b00110001100 = 396;
+	public const int b00110001101 = 397;
+	public const int b00110001110 = 398;
+	public const int b00110001111 = 399;
+	public const int b00110010000 = 400;
+	public const int b00110010001 = 401;
+	public const int b00110010010 = 402;
+	public const int b00110010011 = 403;
+	public const int b00110010100 = 404;
+	public const int b00110010101 = 405;
+	public const int b00110010110 = 406;
+	public const int b00110010111 = 407;
+	public const int b00110011000 = 408;
+	public const int b00110011001 = 409;
+	public const int b00110011010 = 410;
+	public const int b00110011011 = 411;
+	public const int b00110011100 = 412;
+	public const int b00110011101 = 413;
+	public const int b00110011110 = 414;
+	public const int b00110011111 = 415;
+	public const int b00110100000 = 416;
+	public const int b00110100001 = 417;
+	public const int b00110100010 = 418;
+	public const int b00110100011 = 419;
+	public const int b00110100100 = 420;
+	public const int b00110100101 = 421;
+	public const int b00110100110 = 422;
+	public const int b00110100111 = 423;
+	public const int b00110101000 = 424;
+	public const int b00110101001 = 425;
+	public const int b00110101010 = 426;
+	public const int b00110101011 = 427;
+	public const int b00110101100 = 428;
+	public const int b00110101101 = 429;
+	public const int b00110101110 = 430;
+	public const int b00110101111 = 431;
+	public const int b00110110000 = 432;
+	public const int b00110110001 = 433;
+	public const int b00110110010 = 434;
+	public const int b00110110011 = 435;
+	public const int b00110110100 = 436;
+	public const int b00110110101 = 437;
+	public const int b00110110110 = 438;
+	public const int b00110110111 = 439;
+	public const int b00110111000 = 440;
+	public const int b00110111001 = 441;
+	public const int b00110111010 = 442;
+	public const int b00110111011 = 443;
+	public const int b00110111100 = 444;
+	public const int b00110111101 = 445;
+	public const int b00110111110 = 446;
+	public const int b00110111111 = 447;
+	public const int b00111000000 = 448;
+	public const int b00111000001 = 449;
+	public const int b00111000010 = 450;
+	public const int b00111000011 = 451;
+	public const int b00111000100 = 452;
+	public const int b00111000101 = 453;
+	public const int b00111000110 = 454;
+	public const int b00111000111 = 455;
+	public const int b00111001000 = 456;
+	public const int b00111001001 = 457;
+	public const int b00111001010 = 458;
+	public const int b00111001011 = 459;
+	public const int b00111001100 = 460;
+	public const int b00111001101 = 461;
+	public const int b00111001110 = 462;
+	public const int b00111001111 = 463;
+	public const int b00111010000 = 464;
+	public const int b00111010001 = 465;
+	public const int b00111010010 = 466;
+	public const int b00111010011 = 467;
+	public const int b00111010100 = 468;
+	public const int b00111010101 = 469;
+	public const int b00111010110 = 470;
+	public const int b00111010111 = 471;
+	public const int b00111011000 = 472;
+	public const int b00111011001 = 473;
+	public const int b00111011010 = 474;
+	public const int b00111011011 = 475;
+	public const int b00111011100 = 476;
+	public const int b00111011101 = 477;
+	public const int b00111011110 = 478;
+	public const int b00111011111 = 479;
+	public const int b00111100000 = 480;
+	public const int b00111100001 = 481;
+	public const int b00111100010 = 482;
+	public const int b00111100011 = 483;
+	public const int b00111100100 = 484;
+	public const int b00111100101 = 485;
+	public const int b00111100110 = 486;
+	public const int b00111100111 = 487;
+	public const int b00111101000 = 488;
+	public const int b00111101001 = 489;
+	public const int b00111101010 = 490;
+	public const int b00111101011 = 491;
+	public const int b00111101100 = 492;
+	public const int b00111101101 = 493;
+	public const int b00111101110 = 494;
+	public const int b00111101111 = 495;
+	public const int b00111110000 = 496;
+	public const int b00111110001 = 497;
+	public const int b00111110010 = 498;
+	public const int b00111110011 = 499;
+	public const int b00111110100 = 500;
+	public const int b00111110101 = 501;
+	public const int b00111110110 = 502;
+	public const int b00111110111 = 503;
+	public const int b00111111000 = 504;
+	public const int b00111111001 = 505;
+	public const int b00111111010 = 506;
+	public const int b00111111011 = 507;
+	public const int b00111111100 = 508;
+	public const int b00111111101 = 509;
+	public const int b00111111110 = 510;
+	public const int b00111111111 = 511;
+	public const int b01000000000 = 512;
+	public const int b01000000001 = 513;
+	public const int b01000000010 = 514;
+	public const int b01000000011 = 515;
+	public const int b01000000100 = 516;
+	public const int b01000000101 = 517;
+	public const int b01000000110 = 518;
+	public const int b01000000111 = 519;
+	public const int b01000001000 = 520;
+	public const int b01000001001 = 521;
+	public const int b01000001010 = 522;
+	public const int b01000001011 = 523;
+	public const int b01000001100 = 524;
+	public const int b01000001101 = 525;
+	public const int b01000001110 = 526;
+	public const int b01000001111 = 527;
+	public const int b01000010000 = 528;
+	public const int b01000010001 = 529;
+	public const int b01000010010 = 530;
+	public const int b01000010011 = 531;
+	public const int b01000010100 = 532;
+	public const int b01000010101 = 533;
+	public const int b01000010110 = 534;
+	public const int b01000010111 = 535;
+	public const int b01000011000 = 536;
+	public const int b01000011001 = 537;
+	public const int b01000011010 = 538;
+	public const int b01000011011 = 539;
+	public const int b01000011100 = 540;
+	public const int b01000011101 = 541;
+	public const int b01000011110 = 542;
+	public const int b01000011111 = 543;
+	public const int b01000100000 = 544;
+	public const int b01000100001 = 545;
+	public const int b01000100010 = 546;
+	public const int b01000100011 = 547;
+	public const int b01000100100 = 548;
+	public const int b01000100101 = 549;
+	public const int b01000100110 = 550;
+	public const int b01000100111 = 551;
+	public const int b01000101000 = 552;
+	public const int b01000101001 = 553;
+	public const int b01000101010 = 554;
+	public const int b01000101011 = 555;
+	public const int b01000101100 = 556;
+	public const int b01000101101 = 557;
+	public const int b01000101110 = 558;
+	public const int b01000101111 = 559;
+	public const int b01000110000 = 560;
+	public const int b01000110001 = 561;
+	public const int b01000110010 = 562;
+	public const int b01000110011 = 563;
+	public const int b01000110100 = 564;
+	public const int b01000110101 = 565;
+	public const int b01000110110 = 566;
+	public const int b01000110111 = 567;
+	public const int b01000111000 = 568;
+	public const int b01000111001 = 569;
+	public const int b01000111010 = 570;
+	public const int b01000111011 = 571;
+	public const int b01000111100 = 572;
+	public const int b01000111101 = 573;
+	public const int b01000111110 = 574;
+	public const int b01000111111 = 575;
+	public const int b01001000000 = 576;
+	public const int b01001000001 = 577;
+	public const int b01001000010 = 578;
+	public const int b01001000011 = 579;
+	public const int b01001000100 = 580;
+	public const int b01001000101 = 581;
+	public const int b01001000110 = 582;
+	public const int b01001000111 = 583;
+	public const int b01001001000 = 584;
+	public const int b01001001001 = 585;
+	public const int b01001001010 = 586;
+	public const int b01001001011 = 587;
+	public const int b01001001100 = 588;
+	public const int b01001001101 = 589;
+	public const int b01001001110 = 590;
+	public const int b01001001111 = 591;
+	public const int b01001010000 = 592;
+	public const int b01001010001 = 593;
+	public const int b01001010010 = 594;
+	public const int b01001010011 = 595;
+	public const int b01001010100 = 596;
+	public const int b01001010101 = 597;
+	public const int b01001010110 = 598;
+	public const int b01001010111 = 599;
+	public const int b01001011000 = 600;
+	public const int b01001011001 = 601;
+	public const int b01001011010 = 602;
+	public const int b01001011011 = 603;
+	public const int b01001011100 = 604;
+	public const int b01001011101 = 605;
+	public const int b01001011110 = 606;
+	public const int b01001011111 = 607;
+	public const int b01001100000 = 608;
+	public const int b01001100001 = 609;
+	public const int b01001100010 = 610;
+	public const int b01001100011 = 611;
+	public const int b01001100100 = 612;
+	public const int b01001100101 = 613;
+	public const int b01001100110 = 614;
+	public const int b01001100111 = 615;
+	public const int b01001101000 = 616;
+	public const int b01001101001 = 617;
+	public const int b01001101010 = 618;
+	public const int b01001101011 = 619;
+	public const int b01001101100 = 620;
+	public const int b01001101101 = 621;
+	public const int b01001101110 = 622;
+	public const int b01001101111 = 623;
+	public const int b01001110000 = 624;
+	public const int b01001110001 = 625;
+	public const int b01001110010 = 626;
+	public const int b01001110011 = 627;
+	public const int b01001110100 = 628;
+	public const int b01001110101 = 629;
+	public const int b01001110110 = 630;
+	public const int b01001110111 = 631;
+	public const int b01001111000 = 632;
+	public const int b01001111001 = 633;
+	public const int b01001111010 = 634;
+	public const int b01001111011 = 635;
+	public const int b01001111100 = 636;
+	public const int b01001111101 = 637;
+	public const int b01001111110 = 638;
+	public const int b01001111111 = 639;
+	public const int b01010000000 = 640;
+	public const int b01010000001 = 641;
+	public const int b01010000010 = 642;
+	public const int b01010000011 = 643;
+	public const int b01010000100 = 644;
+	public const int b01010000101 = 645;
+	public const int b01010000110 = 646;
+	public const int b01010000111 = 647;
+	public const int b01010001000 = 648;
+	public const int b01010001001 = 649;
+	public const int b01010001010 = 650;
+	public const int b01010001011 = 651;
+	public const int b01010001100 = 652;
+	public const int b01010001101 = 653;
+	public const int b01010001110 = 654;
+	public const int b01010001111 = 655;
+	public const int b01010010000 = 656;
+	public const int b01010010001 = 657;
+	public const int b01010010010 = 658;
+	public const int b01010010011 = 659;
+	public const int b01010010100 = 660;
+	public const int b01010010101 = 661;
+	public const int b01010010110 = 662;
+	public const int b01010010111 = 663;
+	public const int b01010011000 = 664;
+	public const int b01010011001 = 665;
+	public const int b01010011010 = 666;
+	public const int b01010011011 = 667;
+	public const int b01010011100 = 668;
+	public const int b01010011101 = 669;
+	public const int b01010011110 = 670;
+	public const int b01010011111 = 671;
+	public const int b01010100000 = 672;
+	public const int b01010100001 = 673;
+	public const int b01010100010 = 674;
+	public const int b01010100011 = 675;
+	public const int b01010100100 = 676;
+	public const int b01010100101 = 677;
+	public const int b01010100110 = 678;
+	public const int b01010100111 = 679;
+	public const int b01010101000 = 680;
+	public const int b01010101001 = 681;
+	public const int b01010101010 = 682;
+	public const int b01010101011 = 683;
+	public const int b01010101100 = 684;
+	public const int b01010101101 = 685;
+	public const int b01010101110 = 686;
+	public const int b01010101111 = 687;
+	public const int b01010110000 = 688;
+	public const int b01010110001 = 689;
+	public const int b01010110010 = 690;
+	public const int b01010110011 = 691;
+	public const int b01010110100 = 692;
+	public const int b01010110101 = 693;
+	public const int b01010110110 = 694;
+	public const int b01010110111 = 695;
+	public const int b01010111000 = 696;
+	public const int b01010111001 = 697;
+	public const int b01010111010 = 698;
+	public const int b01010111011 = 699;
+	public const int b01010111100 = 700;
+	public const int b01010111101 = 701;
+	public const int b01010111110 = 702;
+	public const int b01010111111 = 703;
+	public const int b01011000000 = 704;
+	public const int b01011000001 = 705;
+	public const int b01011000010 = 706;
+	public const int b01011000011 = 707;
+	public const int b01011000100 = 708;
+	public const int b01011000101 = 709;
+	public const int b01011000110 = 710;
+	public const int b01011000111 = 711;
+	public const int b01011001000 = 712;
+	public const int b01011001001 = 713;
+	public const int b01011001010 = 714;
+	public const int b01011001011 = 715;
+	public const int b01011001100 = 716;
+	public const int b01011001101 = 717;
+	public const int b01011001110 = 718;
+	public const int b01011001111 = 719;
+	public const int b01011010000 = 720;
+	public const int b01011010001 = 721;
+	public const int b01011010010 = 722;
+	public const int b01011010011 = 723;
+	public const int b01011010100 = 724;
+	public const int b01011010101 = 725;
+	public const int b01011010110 = 726;
+	public const int b01011010111 = 727;
+	public const int b01011011000 = 728;
+	public const int b01011011001 = 729;
+	public const int b01011011010 = 730;
+	public const int b01011011011 = 731;
+	public const int b01011011100 = 732;
+	public const int b01011011101 = 733;
+	public const int b01011011110 = 734;
+	public const int b01011011111 = 735;
+	public const int b01011100000 = 736;
+	public const int b01011100001 = 737;
+	public const int b01011100010 = 738;
+	public const int b01011100011 = 739;
+	public const int b01011100100 = 740;
+	public const int b01011100101 = 741;
+	public const int b01011100110 = 742;
+	public const int b01011100111 = 743;
+	public const int b01011101000 = 744;
+	public const int b01011101001 = 745;
+	public const int b01011101010 = 746;
+	public const int b01011101011 = 747;
+	public const int b01011101100 = 748;
+	public const int b01011101101 = 749;
+	public const int b01011101110 = 750;
+	public const int b01011101111 = 751;
+	public const int b01011110000 = 752;
+	public const int b01011110001 = 753;
+	public const int b01011110010 = 754;
+	public const int b01011110011 = 755;
+	public const int b01011110100 = 756;
+	public const int b01011110101 = 757;
+	public const int b01011110110 = 758;
+	public const int b01011110111 = 759;
+	public const int b01011111000 = 760;
+	public const int b01011111001 = 761;
+	public const int b01011111010 = 762;
+	public const int b01011111011 = 763;
+	public const int b01011111100 = 764;
+	public const int b01011111101 = 765;
+	public const int b01011111110 = 766;
+	public const int b01011111111 = 767;
+	public const int b01100000000 = 768;
+	public const int b01100000001 = 769;
+	public const int b01100000010 = 770;
+	public const int b01100000011 = 771;
+	public const int b01100000100 = 772;
+	public const int b01100000101 = 773;
+	public const int b01100000110 = 774;
+	public const int b01100000111 = 775;
+	public const int b01100001000 = 776;
+	public const int b01100001001 = 777;
+	public const int b01100001010 = 778;
+	public const int b01100001011 = 779;
+	public const int b01100001100 = 780;
+	public const int b01100001101 = 781;
+	public const int b01100001110 = 782;
+	public const int b01100001111 = 783;
+	public const int b01100010000 = 784;
+	public const int b01100010001 = 785;
+	public const int b01100010010 = 786;
+	public const int b01100010011 = 787;
+	public const int b01100010100 = 788;
+	public const int b01100010101 = 789;
+	public const int b01100010110 = 790;
+	public const int b01100010111 = 791;
+	public const int b01100011000 = 792;
+	public const int b01100011001 = 793;
+	public const int b01100011010 = 794;
+	public const int b01100011011 = 795;
+	public const int b01100011100 = 796;
+	public const int b01100011101 = 797;
+	public const int b01100011110 = 798;
+	public const int b01100011111 = 799;
+	public const int b01100100000 = 800;
+	public const int b01100100001 = 801;
+	public const int b01100100010 = 802;
+	public const int b01100100011 = 803;
+	public const int b01100100100 = 804;
+	public const int b01100100101 = 805;
+	public const int b01100100110 = 806;
+	public const int b01100100111 = 807;
+	public const int b01100101000 = 808;
+	public const int b01100101001 = 809;
+	public const int b01100101010 = 810;
+	public const int b01100101011 = 811;
+	public const int b01100101100 = 812;
+	public const int b01100101101 = 813;
+	public const int b01100101110 = 814;
+	public const int b01100101111 = 815;
+	public const int b01100110000 = 816;
+	public const int b01100110001 = 817;
+	public const int b01100110010 = 818;
+	public const int b01100110011 = 819;
+	public const int b01100110100 = 820;
+	public const int b01100110101 = 821;
+	public const int b01100110110 = 822;
+	public const int b01100110111 = 823;
+	public const int b01100111000 = 824;
+	public const int b01100111001 = 825;
+	public const int b01100111010 = 826;
+	public const int b01100111011 = 827;
+	public const int b01100111100 = 828;
+	public const int b01100111101 = 829;
+	public const int b01100111110 = 830;
+	public const int b01100111111 = 831;
+	public const int b01101000000 = 832;
+	public const int b01101000001 = 833;
+	public const int b01101000010 = 834;
+	public const int b01101000011 = 835;
+	public const int b01101000100 = 836;
+	public const int b01101000101 = 837;
+	public const int b01101000110 = 838;
+	public const int b01101000111 = 839;
+	public const int b01101001000 = 840;
+	public const int b01101001001 = 841;
+	public const int b01101001010 = 842;
+	public const int b01101001011 = 843;
+	public const int b01101001100 = 844;
+	public const int b01101001101 = 845;
+	public const int b01101001110 = 846;
+	public const int b01101001111 = 847;
+	public const int b01101010000 = 848;
+	public const int b01101010001 = 849;
+	public const int b01101010010 = 850;
+	public const int b01101010011 = 851;
+	public const int b01101010100 = 852;
+	public const int b01101010101 = 853;
+	public const int b01101010110 = 854;
+	public const int b01101010111 = 855;
+	public const int b01101011000 = 856;
+	public const int b01101011001 = 857;
+	public const int b01101011010 = 858;
+	public const int b01101011011 = 859;
+	public const int b01101011100 = 860;
+	public const int b01101011101 = 861;
+	public const int b01101011110 = 862;
+	public const int b01101011111 = 863;
+	public const int b01101100000 = 864;
+	public const int b01101100001 = 865;
+	public const int b01101100010 = 866;
+	public const int b01101100011 = 867;
+	public const int b01101100100 = 868;
+	public const int b01101100101 = 869;
+	public const int b01101100110 = 870;
+	public const int b01101100111 = 871;
+	public const int b01101101000 = 872;
+	public const int b01101101001 = 873;
+	public const int b01101101010 = 874;
+	public const int b01101101011 = 875;
+	public const int b01101101100 = 876;
+	public const int b01101101101 = 877;
+	public const int b01101101110 = 878;
+	public const int b01101101111 = 879;
+	public const int b01101110000 = 880;
+	public const int b01101110001 = 881;
+	public const int b01101110010 = 882;
+	public const int b01101110011 = 883;
+	public const int b01101110100 = 884;
+	public const int b01101110101 = 885;
+	public const int b01101110110 = 886;
+	public const int b01101110111 = 887;
+	public const int b01101111000 = 888;
+	public const int b01101111001 = 889;
+	public const int b01101111010 = 890;
+	public const int b01101111011 = 891;
+	public const int b01101111100 = 892;
+	public const int b01101111101 = 893;
+	public const int b01101111110 = 894;
+	public const int b01101111111 = 895;
+	public const int b01110000000 = 896;
+	public const int b01110000001 = 897;
+	public const int b01110000010 = 898;
+	public const int b01110000011 = 899;
+	public const int b01110000100 = 900;
+	public const int b01110000101 = 901;
+	public const int b01110000110 = 902;
+	public const int b01110000111 = 903;
+	public const int b01110001000 = 904;
+	public const int b01110001001 = 905;
+	public const int b01110001010 = 906;
+	public const int b01110001011 = 907;
+	public const int b01110001100 = 908;
+	public const int b01110001101 = 909;
+	public const int b01110001110 = 910;
+	public const int b01110001111 = 911;
+	public const int b01110010000 = 912;
+	public const int b01110010001 = 913;
+	public const int b01110010010 = 914;
+	public const int b01110010011 = 915;
+	public const int b01110010100 = 916;
+	public const int b01110010101 = 917;
+	public const int b01110010110 = 918;
+	public const int b01110010111 = 919;
+	public const int b01110011000 = 920;
+	public const int b01110011001 = 921;
+	public const int b01110011010 = 922;
+	public const int b01110011011 = 923;
+	public const int b01110011100 = 924;
+	public const int b01110011101 = 925;
+	public const int b01110011110 = 926;
+	public const int b01110011111 = 927;
+	public const int b01110100000 = 928;
+	public const int b01110100001 = 929;
+	public const int b01110100010 = 930;
+	public const int b01110100011 = 931;
+	public const int b01110100100 = 932;
+	public const int b01110100101 = 933;
+	public const int b01110100110 = 934;
+	public const int b01110100111 = 935;
+	public const int b01110101000 = 936;
+	public const int b01110101001 = 937;
+	public const int b01110101010 = 938;
+	public const int b01110101011 = 939;
+	public const int b01110101100 = 940;
+	public const int b01110101101 = 941;
+	public const int b01110101110 = 942;
+	public const int b01110101111 = 943;
+	public const int b01110110000 = 944;
+	public const int b01110110001 = 945;
+	public const int b01110110010 = 946;
+	public const int b01110110011 = 947;
+	public const int b01110110100 = 948;
+	public const int b01110110101 = 949;
+	public const int b01110110110 = 950;
+	public const int b01110110111 = 951;
+	public const int b01110111000 = 952;
+	public const int b01110111001 = 953;
+	public const int b01110111010 = 954;
+	public const int b01110111011 = 955;
+	public const int b01110111100 = 956;
+	public const int b01110111101 = 957;
+	public const int b01110111110 = 958;
+	public const int b01110111111 = 959;
+	public const int b01111000000 = 960;
+	public const int b01111000001 = 961;
+	public const int b01111000010 = 962;
+	public const int b01111000011 = 963;
+	public const int b01111000100 = 964;
+	public const int b01111000101 = 965;
+	public const int b01111000110 = 966;
+	public const int b01111000111 = 967;
+	public const int b01111001000 = 968;
+	public const int b01111001001 = 969;
+	public const int b01111001010 = 970;
+	public const int b01111001011 = 971;
+	public const int b01111001100 = 972;
+	public const int b01111001101 = 973;
+	public const int b01111001110 = 974;
+	public const int b01111001111 = 975;
+	public const int b01111010000 = 976;
+	public const int b01111010001 = 977;
+	public const int b01111010010 = 978;
+	public const int b01111010011 = 979;
+	public const int b01111010100 = 980;
+	public const int b01111010101 = 981;
+	public const int b01111010110 = 982;
+	public const int b01111010111 = 983;
+	public const int b01111011000 = 984;
+	public const int b01111011001 = 985;
+	public const int b01111011010 = 986;
+	public const int b01111011011 = 987;
+	public const int b01111011100 = 988;
+	public const int b01111011101 = 989;
+	public const int b01111011110 = 990;
+	public const int b01111011111 = 991;
+	public const int b01111100000 = 992;
+	public const int b01111100001 = 993;
+	public const int b01111100010 = 994;
+	public const int b01111100011 = 995;
+	public const int b01111100100 = 996;
+	public const int b01111100101 = 997;
+	public const int b01111100110 = 998;
+	public const int b01111100111 = 999;
+	public const int b01111101000 = 1000;
+	public const int b01111101001 = 1001;
+	public const int b01111101010 = 1002;
+	public const int b01111101011 = 1003;
+	public const int b01111101100 = 1004;
+	public const int b01111101101 = 1005;
+	public const int b01111101110 = 1006;
+	public const int b01111101111 = 1007;
+	public const int b01111110000 = 1008;
+	public const int b01111110001 = 1009;
+	public const int b01111110010 = 1010;
+	public const int b01111110011 = 1011;
+	public const int b01111110100 = 1012;
+	public const int b01111110101 = 1013;
+	public const int b01111110110 = 1014;
+	public const int b01111110111 = 1015;
+	public const int b01111111000 = 1016;
+	public const int b01111111001 = 1017;
+	public const int b01111111010 = 1018;
+	public const int b01111111011 = 1019;
+	public const int b01111111100 = 1020;
+	public const int b01111111101 = 1021;
+	public const int b01111111110 = 1022;
+	public const int b01111111111 = 1023;
+	public const int b10000000000 = 1024;
+	public const int b10000000001 = 1025;
+	public const int b10000000010 = 1026;
+	public const int b10000000011 = 1027;
+	public const int b10000000100 = 1028;
+	public const int b10000000101 = 1029;
+	public const int b10000000110 = 1030;
+	public const int b10000000111 = 1031;
+	public const int b10000001000 = 1032;
+	public const int b10000001001 = 1033;
+	public const int b10000001010 = 1034;
+	public const int b10000001011 = 1035;
+	public const int b10000001100 = 1036;
+	public const int b10000001101 = 1037;
+	public const int b10000001110 = 1038;
+	public const int b10000001111 = 1039;
+	public const int b10000010000 = 1040;
+	public const int b10000010001 = 1041;
+	public const int b10000010010 = 1042;
+	public const int b10000010011 = 1043;
+	public const int b10000010100 = 1044;
+	public const int b10000010101 = 1045;
+	public const int b10000010110 = 1046;
+	public const int b10000010111 = 1047;
+	public const int b10000011000 = 1048;
+	public const int b10000011001 = 1049;
+	public const int b10000011010 = 1050;
+	public const int b10000011011 = 1051;
+	public const int b10000011100 = 1052;
+	public const int b10000011101 = 1053;
+	public const int b10000011110 = 1054;
+	public const int b10000011111 = 1055;
+	public const int b10000100000 = 1056;
+	public const int b10000100001 = 1057;
+	public const int b10000100010 = 1058;
+	public const int b10000100011 = 1059;
+	public const int b10000100100 = 1060;
+	public const int b10000100101 = 1061;
+	public const int b10000100110 = 1062;
+	public const int b10000100111 = 1063;
+	public const int b10000101000 = 1064;
+	public const int b10000101001 = 1065;
+	public const int b10000101010 = 1066;
+	public const int b10000101011 = 1067;
+	public const int b10000101100 = 1068;
+	public const int b10000101101 = 1069;
+	public const int b10000101110 = 1070;
+	public const int b10000101111 = 1071;
+	public const int b10000110000 = 1072;
+	public const int b10000110001 = 1073;
+	public const int b10000110010 = 1074;
+	public const int b10000110011 = 1075;
+	public const int b10000110100 = 1076;
+	public const int b10000110101 = 1077;
+	public const int b10000110110 = 1078;
+	public const int b10000110111 = 1079;
+	public const int b10000111000 = 1080;
+	public const int b10000111001 = 1081;
+	public const int b10000111010 = 1082;
+	public const int b10000111011 = 1083;
+	public const int b10000111100 = 1084;
+	public const int b10000111101 = 1085;
+	public const int b10000111110 = 1086;
+	public const int b10000111111 = 1087;
+	public const int b10001000000 = 1088;
+	public const int b10001000001 = 1089;
+	public const int b10001000010 = 1090;
+	public const int b10001000011 = 1091;
+	public const int b10001000100 = 1092;
+	public const int b10001000101 = 1093;
+	public const int b10001000110 = 1094;
+	public const int b10001000111 = 1095;
+	public const int b10001001000 = 1096;
+	public const int b10001001001 = 1097;
+	public const int b10001001010 = 1098;
+	public const int b10001001011 = 1099;
+	public const int b10001001100 = 1100;
+	public const int b10001001101 = 1101;
+	public const int b10001001110 = 1102;
+	public const int b10001001111 = 1103;
+	public const int b10001010000 = 1104;
+	public const int b10001010001 = 1105;
+	public const int b10001010010 = 1106;
+	public const int b10001010011 = 1107;
+	public const int b10001010100 = 1108;
+	public const int b10001010101 = 1109;
+	public const int b10001010110 = 1110;
+	public const int b10001010111 = 1111;
+	public const int b10001011000 = 1112;
+	public const int b10001011001 = 1113;
+	public const int b10001011010 = 1114;
+	public const int b10001011011 = 1115;
+	public const int b10001011100 = 1116;
+	public const int b10001011101 = 1117;
+	public const int b10001011110 = 1118;
+	public const int b10001011111 = 1119;
+	public const int b10001100000 = 1120;
+	public const int b10001100001 = 1121;
+	public const int b10001100010 = 1122;
+	public const int b10001100011 = 1123;
+	public const int b10001100100 = 1124;
+	public const int b10001100101 = 1125;
+	public const int b10001100110 = 1126;
+	public const int b10001100111 = 1127;
+	public const int b10001101000 = 1128;
+	public const int b10001101001 = 1129;
+	public const int b10001101010 = 1130;
+	public const int b10001101011 = 1131;
+	public const int b10001101100 = 1132;
+	public const int b10001101101 = 1133;
+	public const int b10001101110 = 1134;
+	public const int b10001101111 = 1135;
+	public const int b10001110000 = 1136;
+	public const int b10001110001 = 1137;
+	public const int b10001110010 = 1138;
+	public const int b10001110011 = 1139;
+	public const int b10001110100 = 1140;
+	public const int b10001110101 = 1141;
+	public const int b10001110110 = 1142;
+	public const int b10001110111 = 1143;
+	public const int b10001111000 = 1144;
+	public const int b10001111001 = 1145;
+	public const int b10001111010 = 1146;
+	public const int b10001111011 = 1147;
+	public const int b10001111100 = 1148;
+	public const int b10001111101 = 1149;
+	public const int b10001111110 = 1150;
+	public const int b10001111111 = 1151;
+	public const int b10010000000 = 1152;
+	public const int b10010000001 = 1153;
+	public const int b10010000010 = 1154;
+	public const int b10010000011 = 1155;
+	public const int b10010000100 = 1156;
+	public const int b10010000101 = 1157;
+	public const int b10010000110 = 1158;
+	public const int b10010000111 = 1159;
+	public const int b10010001000 = 1160;
+	public const int b10010001001 = 1161;
+	public const int b10010001010 = 1162;
+	public const int b10010001011 = 1163;
+	public const int b10010001100 = 1164;
+	public const int b10010001101 = 1165;
+	public const int b10010001110 = 1166;
+	public const int b10010001111 = 1167;
+	public const int b10010010000 = 1168;
+	public const int b10010010001 = 1169;
+	public const int b10010010010 = 1170;
+	public const int b10010010011 = 1171;
+	public const int b10010010100 = 1172;
+	public const int b10010010101 = 1173;
+	public const int b10010010110 = 1174;
+	public const int b10010010111 = 1175;
+	public const int b10010011000 = 1176;
+	public const int b10010011001 = 1177;
+	public const int b10010011010 = 1178;
+	public const int b10010011011 = 1179;
+	public const int b10010011100 = 1180;
+	public const int b10010011101 = 1181;
+	public const int b10010011110 = 1182;
+	public const int b10010011111 = 1183;
+	public const int b10010100000 = 1184;
+	public const int b10010100001 = 1185;
+	public const int b10010100010 = 1186;
+	public const int b10010100011 = 1187;
+	public const int b10010100100 = 1188;
+	public const int b10010100101 = 1189;
+	public const int b10010100110 = 1190;
+	public const int b10010100111 = 1191;
+	public const int b10010101000 = 1192;
+	public const int b10010101001 = 1193;
+	public const int b10010101010 = 1194;
+	public const int b10010101011 = 1195;
+	public const int b10010101100 = 1196;
+	public const int b10010101101 = 1197;
+	public const int b10010101110 = 1198;
+	public const int b10010101111 = 1199;
+	public const int b10010110000 = 1200;
+	public const int b10010110001 = 1201;
+	public const int b10010110010 = 1202;
+	public const int b10010110011 = 1203;
+	public const int b10010110100 = 1204;
+	public const int b10010110101 = 1205;
+	public const int b10010110110 = 1206;
+	public const int b10010110111 = 1207;
+	public const int b10010111000 = 1208;
+	public const int b10010111001 = 1209;
+	public const int b10010111010 = 1210;
+	public const int b10010111011 = 1211;
+	public const int b10010111100 = 1212;
+	public const int b10010111101 = 1213;
+	public const int b10010111110 = 1214;
+	public const int b10010111111 = 1215;
+	public const int b10011000000 = 1216;
+	public const int b10011000001 = 1217;
+	public const int b10011000010 = 1218;
+	public const int b10011000011 = 1219;
+	public const int b10011000100 = 1220;
+	public const int b10011000101 = 1221;
+	public const int b10011000110 = 1222;
+	public const int b10011000111 = 1223;
+	public const int b10011001000 = 1224;
+	public const int b10011001001 = 1225;
+	public const int b10011001010 = 1226;
+	public const int b10011001011 = 1227;
+	public const int b10011001100 = 1228;
+	public const int b10011001101 = 1229;
+	public const int b10011001110 = 1230;
+	public const int b10011001111 = 1231;
+	public const int b10011010000 = 1232;
+	public const int b10011010001 = 1233;
+	public const int b10011010010 = 1234;
+	public const int b10011010011 = 1235;
+	public const int b10011010100 = 1236;
+	public const int b10011010101 = 1237;
+	public const int b10011010110 = 1238;
+	public const int b10011010111 = 1239;
+	public const int b10011011000 = 1240;
+	public const int b10011011001 = 1241;
+	public const int b10011011010 = 1242;
+	public const int b10011011011 = 1243;
+	public const int b10011011100 = 1244;
+	public const int b10011011101 = 1245;
+	public const int b10011011110 = 1246;
+	public const int b10011011111 = 1247;
+	public const int b10011100000 = 1248;
+	public const int b10011100001 = 1249;
+	public const int b10011100010 = 1250;
+	public const int b10011100011 = 1251;
+	public const int b10011100100 = 1252;
+	public const int b10011100101 = 1253;
+	public const int b10011100110 = 1254;
+	public const int b10011100111 = 1255;
+	public const int b10011101000 = 1256;
+	public const int b10011101001 = 1257;
+	public const int b10011101010 = 1258;
+	public const int b10011101011 = 1259;
+	public const int b10011101100 = 1260;
+	public const int b10011101101 = 1261;
+	public const int b10011101110 = 1262;
+	public const int b10011101111 = 1263;
+	public const int b10011110000 = 1264;
+	public const int b10011110001 = 1265;
+	public const int b10011110010 = 1266;
+	public const int b10011110011 = 1267;
+	public const int b10011110100 = 1268;
+	public const int b10011110101 = 1269;
+	public const int b10011110110 = 1270;
+	public const int b10011110111 = 1271;
+	public const int b10011111000 = 1272;
+	public const int b10011111001 = 1273;
+	public const int b10011111010 = 1274;
+	public const int b10011111011 = 1275;
+	public const int b10011111100 = 1276;
+	public const int b10011111101 = 1277;
+	public const int b10011111110 = 1278;
+	public const int b10011111111 = 1279;
+	public const int b10100000000 = 1280;
+	public const int b10100000001 = 1281;
+	public const int b10100000010 = 1282;
+	public const int b10100000011 = 1283;
+	public const int b10100000100 = 1284;
+	public const int b10100000101 = 1285;
+	public const int b10100000110 = 1286;
+	public const int b10100000111 = 1287;
+	public const int b10100001000 = 1288;
+	public const int b10100001001 = 1289;
+	public const int b10100001010 = 1290;
+	public const int b10100001011 = 1291;
+	public const int b10100001100 = 1292;
+	public const int b10100001101 = 1293;
+	public const int b10100001110 = 1294;
+	public const int b10100001111 = 1295;
+	public const int b10100010000 = 1296;
+	public const int b10100010001 = 1297;
+	public const int b10100010010 = 1298;
+	public const int b10100010011 = 1299;
+	public const int b10100010100 = 1300;
+	public const int b10100010101 = 1301;
+	public const int b10100010110 = 1302;
+	public const int b10100010111 = 1303;
+	public const int b10100011000 = 1304;
+	public const int b10100011001 = 1305;
+	public const int b10100011010 = 1306;
+	public const int b10100011011 = 1307;
+	public const int b10100011100 = 1308;
+	public const int b10100011101 = 1309;
+	public const int b10100011110 = 1310;
+	public const int b10100011111 = 1311;
+	public const int b10100100000 = 1312;
+	public const int b10100100001 = 1313;
+	public const int b10100100010 = 1314;
+	public const int b10100100011 = 1315;
+	public const int b10100100100 = 1316;
+	public const int b10100100101 = 1317;
+	public const int b10100100110 = 1318;
+	public const int b10100100111 = 1319;
+	public const int b10100101000 = 1320;
+	public const int b10100101001 = 1321;
+	public const int b10100101010 = 1322;
+	public const int b10100101011 = 1323;
+	public const int b10100101100 = 1324;
+	public const int b10100101101 = 1325;
+	public const int b10100101110 = 1326;
+	public const int b10100101111 = 1327;
+	public const int b10100110000 = 1328;
+	public const int b10100110001 = 1329;
+	public const int b10100110010 = 1330;
+	public const int b10100110011 = 1331;
+	public const int b10100110100 = 1332;
+	public const int b10100110101 = 1333;
+	public const int b10100110110 = 1334;
+	public const int b10100110111 = 1335;
+	public const int b10100111000 = 1336;
+	public const int b10100111001 = 1337;
+	public const int b10100111010 = 1338;
+	public const int b10100111011 = 1339;
+	public const int b10100111100 = 1340;
+	public const int b10100111101 = 1341;
+	public const int b10100111110 = 1342;
+	public const int b10100111111 = 1343;
+	public const int b10101000000 = 1344;
+	public const int b10101000001 = 1345;
+	public const int b10101000010 = 1346;
+	public const int b10101000011 = 1347;
+	public const int b10101000100 = 1348;
+	public const int b10101000101 = 1349;
+	public const int b10101000110 = 1350;
+	public const int b10101000111 = 1351;
+	public const int b10101001000 = 1352;
+	public const int b10101001001 = 1353;
+	public const int b10101001010 = 1354;
+	public const int b10101001011 = 1355;
+	public const int b10101001100 = 1356;
+	public const int b10101001101 = 1357;
+	public const int b10101001110 = 1358;
+	public const int b10101001111 = 1359;
+	public const int b10101010000 = 1360;
+	public const int b10101010001 = 1361;
+	public const int b10101010010 = 1362;
+	public const int b10101010011 = 1363;
+	public const int b10101010100 = 1364;
+	public const int b10101010101 = 1365;
+	public const int b10101010110 = 1366;
+	public const int b10101010111 = 1367;
+	public const int b10101011000 = 1368;
+	public const int b10101011001 = 1369;
+	public const int b10101011010 = 1370;
+	public const int b10101011011 = 1371;
+	public const int b10101011100 = 1372;
+	public const int b10101011101 = 1373;
+	public const int b10101011110 = 1374;
+	public const int b10101011111 = 1375;
+	public const int b10101100000 = 1376;
+	public const int b10101100001 = 1377;
+	public const int b10101100010 = 1378;
+	public const int b10101100011 = 1379;
+	public const int b10101100100 = 1380;
+	public const int b10101100101 = 1381;
+	public const int b10101100110 = 1382;
+	public const int b10101100111 = 1383;
+	public const int b10101101000 = 1384;
+	public const int b10101101001 = 1385;
+	public const int b10101101010 = 1386;
+	public const int b10101101011 = 1387;
+	public const int b10101101100 = 1388;
+	public const int b10101101101 = 1389;
+	public const int b10101101110 = 1390;
+	public const int b10101101111 = 1391;
+	public const int b10101110000 = 1392;
+	public const int b10101110001 = 1393;
+	public const int b10101110010 = 1394;
+	public const int b10101110011 = 1395;
+	public const int b10101110100 = 1396;
+	public const int b10101110101 = 1397;
+	public const int b10101110110 = 1398;
+	public const int b10101110111 = 1399;
+	public const int b10101111000 = 1400;
+	public const int b10101111001 = 1401;
+	public const int b10101111010 = 1402;
+	public const int b10101111011 = 1403;
+	public const int b10101111100 = 1404;
+	public const int b10101111101 = 1405;
+	public const int b10101111110 = 1406;
+	public const int b10101111111 = 1407;
+	public const int b10110000000 = 1408;
+	public const int b10110000001 = 1409;
+	public const int b10110000010 = 1410;
+	public const int b10110000011 = 1411;
+	public const int b10110000100 = 1412;
+	public const int b10110000101 = 1413;
+	public const int b10110000110 = 1414;
+	public const int b10110000111 = 1415;
+	public const int b10110001000 = 1416;
+	public const int b10110001001 = 1417;
+	public const int b10110001010 = 1418;
+	public const int b10110001011 = 1419;
+	public const int b10110001100 = 1420;
+	public const int b10110001101 = 1421;
+	public const int b10110001110 = 1422;
+	public const int b10110001111 = 1423;
+	public const int b10110010000 = 1424;
+	public const int b10110010001 = 1425;
+	public const int b10110010010 = 1426;
+	public const int b10110010011 = 1427;
+	public const int b10110010100 = 1428;
+	public const int b10110010101 = 1429;
+	public const int b10110010110 = 1430;
+	public const int b10110010111 = 1431;
+	public const int b10110011000 = 1432;
+	public const int b10110011001 = 1433;
+	public const int b10110011010 = 1434;
+	public const int b10110011011 = 1435;
+	public const int b10110011100 = 1436;
+	public const int b10110011101 = 1437;
+	public const int b10110011110 = 1438;
+	public const int b10110011111 = 1439;
+	public const int b10110100000 = 1440;
+	public const int b10110100001 = 1441;
+	public const int b10110100010 = 1442;
+	public const int b10110100011 = 1443;
+	public const int b10110100100 = 1444;
+	public const int b10110100101 = 1445;
+	public const int b10110100110 = 1446;
+	public const int b10110100111 = 1447;
+	public const int b10110101000 = 1448;
+	public const int b10110101001 = 1449;
+	public const int b10110101010 = 1450;
+	public const int b10110101011 = 1451;
+	public const int b10110101100 = 1452;
+	public const int b10110101101 = 1453;
+	public const int b10110101110 = 1454;
+	public const int b10110101111 = 1455;
+	public const int b10110110000 = 1456;
+	public const int b10110110001 = 1457;
+	public const int b10110110010 = 1458;
+	public const int b10110110011 = 1459;
+	public const int b10110110100 = 1460;
+	public const int b10110110101 = 1461;
+	public const int b10110110110 = 1462;
+	public const int b10110110111 = 1463;
+	public const int b10110111000 = 1464;
+	public const int b10110111001 = 1465;
+	public const int b10110111010 = 1466;
+	public const int b10110111011 = 1467;
+	public const int b10110111100 = 1468;
+	public const int b10110111101 = 1469;
+	public const int b10110111110 = 1470;
+	public const int b10110111111 = 1471;
+	public const int b10111000000 = 1472;
+	public const int b10111000001 = 1473;
+	public const int b10111000010 = 1474;
+	public const int b10111000011 = 1475;
+	public const int b10111000100 = 1476;
+	public const int b10111000101 = 1477;
+	public const int b10111000110 = 1478;
+	public const int b10111000111 = 1479;
+	public const int b10111001000 = 1480;
+	public const int b10111001001 = 1481;
+	public const int b10111001010 = 1482;
+	public const int b10111001011 = 1483;
+	public const int b10111001100 = 1484;
+	public const int b10111001101 = 1485;
+	public const int b10111001110 = 1486;
+	public const int b10111001111 = 1487;
+	public const int b10111010000 = 1488;
+	public const int b10111010001 = 1489;
+	public const int b10111010010 = 1490;
+	public const int b10111010011 = 1491;
+	public const int b10111010100 = 1492;
+	public const int b10111010101 = 1493;
+	public const int b10111010110 = 1494;
+	public const int b10111010111 = 1495;
+	public const int b10111011000 = 1496;
+	public const int b10111011001 = 1497;
+	public const int b10111011010 = 1498;
+	public const int b10111011011 = 1499;
+	public const int b10111011100 = 1500;
+	public const int b10111011101 = 1501;
+	public const int b10111011110 = 1502;
+	public const int b10111011111 = 1503;
+	public const int b10111100000 = 1504;
+	public const int b10111100001 = 1505;
+	public const int b10111100010 = 1506;
+	public const int b10111100011 = 1507;
+	public const int b10111100100 = 1508;
+	public const int b10111100101 = 1509;
+	public const int b10111100110 = 1510;
+	public const int b10111100111 = 1511;
+	public const int b10111101000 = 1512;
+	public const int b10111101001 = 1513;
+	public const int b10111101010 = 1514;
+	public const int b10111101011 = 1515;
+	public const int b10111101100 = 1516;
+	public const int b10111101101 = 1517;
+	public const int b10111101110 = 1518;
+	public const int b10111101111 = 1519;
+	public const int b10111110000 = 1520;
+	public const int b10111110001 = 1521;
+	public const int b10111110010 = 1522;
+	public const int b10111110011 = 1523;
+	public const int b10111110100 = 1524;
+	public const int b10111110101 = 1525;
+	public const int b10111110110 = 1526;
+	public const int b10111110111 = 1527;
+	public const int b10111111000 = 1528;
+	public const int b10111111001 = 1529;
+	public const int b10111111010 = 1530;
+	public const int b10111111011 = 1531;
+	public const int b10111111100 = 1532;
+	public const int b10111111101 = 1533;
+	public const int b10111111110 = 1534;
+	public const int b10111111111 = 1535;
+	public const int b11000000000 = 1536;
+	public const int b11000000001 = 1537;
+	public const int b11000000010 = 1538;
+	public const int b11000000011 = 1539;
+	public const int b11000000100 = 1540;
+	public const int b11000000101 = 1541;
+	public const int b11000000110 = 1542;
+	public const int b11000000111 = 1543;
+	public const int b11000001000 = 1544;
+	public const int b11000001001 = 1545;
+	public const int b11000001010 = 1546;
+	public const int b11000001011 = 1547;
+	public const int b11000001100 = 1548;
+	public const int b11000001101 = 1549;
+	public const int b11000001110 = 1550;
+	public const int b11000001111 = 1551;
+	public const int b11000010000 = 1552;
+	public const int b11000010001 = 1553;
+	public const int b11000010010 = 1554;
+	public const int b11000010011 = 1555;
+	public const int b11000010100 = 1556;
+	public const int b11000010101 = 1557;
+	public const int b11000010110 = 1558;
+	public const int b11000010111 = 1559;
+	public const int b11000011000 = 1560;
+	public const int b11000011001 = 1561;
+	public const int b11000011010 = 1562;
+	public const int b11000011011 = 1563;
+	public const int b11000011100 = 1564;
+	public const int b11000011101 = 1565;
+	public const int b11000011110 = 1566;
+	public const int b11000011111 = 1567;
+	public const int b11000100000 = 1568;
+	public const int b11000100001 = 1569;
+	public const int b11000100010 = 1570;
+	public const int b11000100011 = 1571;
+	public const int b11000100100 = 1572;
+	public const int b11000100101 = 1573;
+	public const int b11000100110 = 1574;
+	public const int b11000100111 = 1575;
+	public const int b11000101000 = 1576;
+	public const int b11000101001 = 1577;
+	public const int b11000101010 = 1578;
+	public const int b11000101011 = 1579;
+	public const int b11000101100 = 1580;
+	public const int b11000101101 = 1581;
+	public const int b11000101110 = 1582;
+	public const int b11000101111 = 1583;
+	public const int b11000110000 = 1584;
+	public const int b11000110001 = 1585;
+	public const int b11000110010 = 1586;
+	public const int b11000110011 = 1587;
+	public const int b11000110100 = 1588;
+	public const int b11000110101 = 1589;
+	public const int b11000110110 = 1590;
+	public const int b11000110111 = 1591;
+	public const int b11000111000 = 1592;
+	public const int b11000111001 = 1593;
+	public const int b11000111010 = 1594;
+	public const int b11000111011 = 1595;
+	public const int b11000111100 = 1596;
+	public const int b11000111101 = 1597;
+	public const int b11000111110 = 1598;
+	public const int b11000111111 = 1599;
+	public const int b11001000000 = 1600;
+	public const int b11001000001 = 1601;
+	public const int b11001000010 = 1602;
+	public const int b11001000011 = 1603;
+	public const int b11001000100 = 1604;
+	public const int b11001000101 = 1605;
+	public const int b11001000110 = 1606;
+	public const int b11001000111 = 1607;
+	public const int b11001001000 = 1608;
+	public const int b11001001001 = 1609;
+	public const int b11001001010 = 1610;
+	public const int b11001001011 = 1611;
+	public const int b11001001100 = 1612;
+	public const int b11001001101 = 1613;
+	public const int b11001001110 = 1614;
+	public const int b11001001111 = 1615;
+	public const int b11001010000 = 1616;
+	public const int b11001010001 = 1617;
+	public const int b11001010010 = 1618;
+	public const int b11001010011 = 1619;
+	public const int b11001010100 = 1620;
+	public const int b11001010101 = 1621;
+	public const int b11001010110 = 1622;
+	public const int b11001010111 = 1623;
+	public const int b11001011000 = 1624;
+	public const int b11001011001 = 1625;
+	public const int b11001011010 = 1626;
+	public const int b11001011011 = 1627;
+	public const int b11001011100 = 1628;
+	public const int b11001011101 = 1629;
+	public const int b11001011110 = 1630;
+	public const int b11001011111 = 1631;
+	public const int b11001100000 = 1632;
+	public const int b11001100001 = 1633;
+	public const int b11001100010 = 1634;
+	public const int b11001100011 = 1635;
+	public const int b11001100100 = 1636;
+	public const int b11001100101 = 1637;
+	public const int b11001100110 = 1638;
+	public const int b11001100111 = 1639;
+	public const int b11001101000 = 1640;
+	public const int b11001101001 = 1641;
+	public const int b11001101010 = 1642;
+	public const int b11001101011 = 1643;
+	public const int b11001101100 = 1644;
+	public const int b11001101101 = 1645;
+	public const int b11001101110 = 1646;
+	public const int b11001101111 = 1647;
+	public const int b11001110000 = 1648;
+	public const int b11001110001 = 1649;
+	public const int b11001110010 = 1650;
+	public const int b11001110011 = 1651;
+	public const int b11001110100 = 1652;
+	public const int b11001110101 = 1653;
+	public const int b11001110110 = 1654;
+	public const int b11001110111 = 1655;
+	public const int b11001111000 = 1656;
+	public const int b11001111001 = 1657;
+	public const int b11001111010 = 1658;
+	public const int b11001111011 = 1659;
+	public const int b11001111100 = 1660;
+	public const int b11001111101 = 1661;
+	public const int b11001111110 = 1662;
+	public const int b11001111111 = 1663;
+	public const int b11010000000 = 1664;
+	public const int b11010000001 = 1665;
+	public const int b11010000010 = 1666;
+	public const int b11010000011 = 1667;
+	public const int b11010000100 = 1668;
+	public const int b11010000101 = 1669;
+	public const int b11010000110 = 1670;
+	public const int b11010000111 = 1671;
+	public const int b11010001000 = 1672;
+	public const int b11010001001 = 1673;
+	public const int b11010001010 = 1674;
+	public const int b11010001011 = 1675;
+	public const int b11010001100 = 1676;
+	public const int b11010001101 = 1677;
+	public const int b11010001110 = 1678;
+	public const int b11010001111 = 1679;
+	public const int b11010010000 = 1680;
+	public const int b11010010001 = 1681;
+	public const int b11010010010 = 1682;
+	public const int b11010010011 = 1683;
+	public const int b11010010100 = 1684;
+	public const int b11010010101 = 1685;
+	public const int b11010010110 = 1686;
+	public const int b11010010111 = 1687;
+	public const int b11010011000 = 1688;
+	public const int b11010011001 = 1689;
+	public const int b11010011010 = 1690;
+	public const int b11010011011 = 1691;
+	public const int b11010011100 = 1692;
+	public const int b11010011101 = 1693;
+	public const int b11010011110 = 1694;
+	public const int b11010011111 = 1695;
+	public const int b11010100000 = 1696;
+	public const int b11010100001 = 1697;
+	public const int b11010100010 = 1698;
+	public const int b11010100011 = 1699;
+	public const int b11010100100 = 1700;
+	public const int b11010100101 = 1701;
+	public const int b11010100110 = 1702;
+	public const int b11010100111 = 1703;
+	public const int b11010101000 = 1704;
+	public const int b11010101001 = 1705;
+	public const int b11010101010 = 1706;
+	public const int b11010101011 = 1707;
+	public const int b11010101100 = 1708;
+	public const int b11010101101 = 1709;
+	public const int b11010101110 = 1710;
+	public const int b11010101111 = 1711;
+	public const int b11010110000 = 1712;
+	public const int b11010110001 = 1713;
+	public const int b11010110010 = 1714;
+	public const int b11010110011 = 1715;
+	public const int b11010110100 = 1716;
+	public const int b11010110101 = 1717;
+	public const int b11010110110 = 1718;
+	public const int b11010110111 = 1719;
+	public const int b11010111000 = 1720;
+	public const int b11010111001 = 1721;
+	public const int b11010111010 = 1722;
+	public const int b11010111011 = 1723;
+	public const int b11010111100 = 1724;
+	public const int b11010111101 = 1725;
+	public const int b11010111110 = 1726;
+	public const int b11010111111 = 1727;
+	public const int b11011000000 = 1728;
+	public const int b11011000001 = 1729;
+	public const int b11011000010 = 1730;
+	public const int b11011000011 = 1731;
+	public const int b11011000100 = 1732;
+	public const int b11011000101 = 1733;
+	public const int b11011000110 = 1734;
+	public const int b11011000111 = 1735;
+	public const int b11011001000 = 1736;
+	public const int b11011001001 = 1737;
+	public const int b11011001010 = 1738;
+	public const int b11011001011 = 1739;
+	public const int b11011001100 = 1740;
+	public const int b11011001101 = 1741;
+	public const int b11011001110 = 1742;
+	public const int b11011001111 = 1743;
+	public const int b11011010000 = 1744;
+	public const int b11011010001 = 1745;
+	public const int b11011010010 = 1746;
+	public const int b11011010011 = 1747;
+	public const int b11011010100 = 1748;
+	public const int b11011010101 = 1749;
+	public const int b11011010110 = 1750;
+	public const int b11011010111 = 1751;
+	public const int b11011011000 = 1752;
+	public const int b11011011001 = 1753;
+	public const int b11011011010 = 1754;
+	public const int b11011011011 = 1755;
+	public const int b11011011100 = 1756;
+	public const int b11011011101 = 1757;
+	public const int b11011011110 = 1758;
+	public const int b11011011111 = 1759;
+	public const int b11011100000 = 1760;
+	public const int b11011100001 = 1761;
+	public const int b11011100010 = 1762;
+	public const int b11011100011 = 1763;
+	public const int b11011100100 = 1764;
+	public const int b11011100101 = 1765;
+	public const int b11011100110 = 1766;
+	public const int b11011100111 = 1767;
+	public const int b11011101000 = 1768;
+	public const int b11011101001 = 1769;
+	public const int b11011101010 = 1770;
+	public const int b11011101011 = 1771;
+	public const int b11011101100 = 1772;
+	public const int b11011101101 = 1773;
+	public const int b11011101110 = 1774;
+	public const int b11011101111 = 1775;
+	public const int b11011110000 = 1776;
+	public const int b11011110001 = 1777;
+	public const int b11011110010 = 1778;
+	public const int b11011110011 = 1779;
+	public const int b11011110100 = 1780;
+	public const int b11011110101 = 1781;
+	public const int b11011110110 = 1782;
+	public const int b11011110111 = 1783;
+	public const int b11011111000 = 1784;
+	public const int b11011111001 = 1785;
+	public const int b11011111010 = 1786;
+	public const int b11011111011 = 1787;
+	public const int b11011111100 = 1788;
+	public const int b11011111101 = 1789;
+	public const int b11011111110 = 1790;
+	public const int b11011111111 = 1791;
+	public const int b11100000000 = 1792;
+	public const int b11100000001 = 1793;
+	public const int b11100000010 = 1794;
+	public const int b11100000011 = 1795;
+	public const int b11100000100 = 1796;
+	public const int b11100000101 = 1797;
+	public const int b11100000110 = 1798;
+	public const int b11100000111 = 1799;
+	public const int b11100001000 = 1800;
+	public const int b11100001001 = 1801;
+	public const int b11100001010 = 1802;
+	public const int b11100001011 = 1803;
+	public const int b11100001100 = 1804;
+	public const int b11100001101 = 1805;
+	public const int b11100001110 = 1806;
+	public const int b11100001111 = 1807;
+	public const int b11100010000 = 1808;
+	public const int b11100010001 = 1809;
+	public const int b11100010010 = 1810;
+	public const int b11100010011 = 1811;
+	public const int b11100010100 = 1812;
+	public const int b11100010101 = 1813;
+	public const int b11100010110 = 1814;
+	public const int b11100010111 = 1815;
+	public const int b11100011000 = 1816;
+	public const int b11100011001 = 1817;
+	public const int b11100011010 = 1818;
+	public const int b11100011011 = 1819;
+	public const int b11100011100 = 1820;
+	public const int b11100011101 = 1821;
+	public const int b11100011110 = 1822;
+	public const int b11100011111 = 1823;
+	public const int b11100100000 = 1824;
+	public const int b11100100001 = 1825;
+	public const int b11100100010 = 1826;
+	public const int b11100100011 = 1827;
+	public const int b11100100100 = 1828;
+	public const int b11100100101 = 1829;
+	public const int b11100100110 = 1830;
+	public const int b11100100111 = 1831;
+	public const int b11100101000 = 1832;
+	public const int b11100101001 = 1833;
+	public const int b11100101010 = 1834;
+	public const int b11100101011 = 1835;
+	public const int b11100101100 = 1836;
+	public const int b11100101101 = 1837;
+	public const int b11100101110 = 1838;
+	public const int b11100101111 = 1839;
+	public const int b11100110000 = 1840;
+	public const int b11100110001 = 1841;
+	public const int b11100110010 = 1842;
+	public const int b11100110011 = 1843;
+	public const int b11100110100 = 1844;
+	public const int b11100110101 = 1845;
+	public const int b11100110110 = 1846;
+	public const int b11100110111 = 1847;
+	public const int b11100111000 = 1848;
+	public const int b11100111001 = 1849;
+	public const int b11100111010 = 1850;
+	public const int b11100111011 = 1851;
+	public const int b11100111100 = 1852;
+	public const int b11100111101 = 1853;
+	public const int b11100111110 = 1854;
+	public const int b11100111111 = 1855;
+	public const int b11101000000 = 1856;
+	public const int b11101000001 = 1857;
+	public const int b11101000010 = 1858;
+	public const int b11101000011 = 1859;
+	public const int b11101000100 = 1860;
+	public const int b11101000101 = 1861;
+	public const int b11101000110 = 1862;
+	public const int b11101000111 = 1863;
+	public const int b11101001000 = 1864;
+	public const int b11101001001 = 1865;
+	public const int b11101001010 = 1866;
+	public const int b11101001011 = 1867;
+	public const int b11101001100 = 1868;
+	public const int b11101001101 = 1869;
+	public const int b11101001110 = 1870;
+	public const int b11101001111 = 1871;
+	public const int b11101010000 = 1872;
+	public const int b11101010001 = 1873;
+	public const int b11101010010 = 1874;
+	public const int b11101010011 = 1875;
+	public const int b11101010100 = 1876;
+	public const int b11101010101 = 1877;
+	public const int b11101010110 = 1878;
+	public const int b11101010111 = 1879;
+	public const int b11101011000 = 1880;
+	public const int b11101011001 = 1881;
+	public const int b11101011010 = 1882;
+	public const int b11101011011 = 1883;
+	public const int b11101011100 = 1884;
+	public const int b11101011101 = 1885;
+	public const int b11101011110 = 1886;
+	public const int b11101011111 = 1887;
+	public const int b11101100000 = 1888;
+	public const int b11101100001 = 1889;
+	public const int b11101100010 = 1890;
+	public const int b11101100011 = 1891;
+	public const int b11101100100 = 1892;
+	public const int b11101100101 = 1893;
+	public const int b11101100110 = 1894;
+	public const int b11101100111 = 1895;
+	public const int b11101101000 = 1896;
+	public const int b11101101001 = 1897;
+	public const int b11101101010 = 1898;
+	public const int b11101101011 = 1899;
+	public const int b11101101100 = 1900;
+	public const int b11101101101 = 1901;
+	public const int b11101101110 = 1902;
+	public const int b11101101111 = 1903;
+	public const int b11101110000 = 1904;
+	public const int b11101110001 = 1905;
+	public const int b11101110010 = 1906;
+	public const int b11101110011 = 1907;
+	public const int b11101110100 = 1908;
+	public const int b11101110101 = 1909;
+	public const int b11101110110 = 1910;
+	public const int b11101110111 = 1911;
+	public const int b11101111000 = 1912;
+	public const int b11101111001 = 1913;
+	public const int b11101111010 = 1914;
+	public const int b11101111011 = 1915;
+	public const int b11101111100 = 1916;
+	public const int b11101111101 = 1917;
+	public const int b11101111110 = 1918;
+	public const int b11101111111 = 1919;
+	public const int b11110000000 = 1920;
+	public const int b11110000001 = 1921;
+	public const int b11110000010 = 1922;
+	public const int b11110000011 = 1923;
+	public const int b11110000100 = 1924;
+	public const int b11110000101 = 1925;
+	public const int b11110000110 = 1926;
+	public const int b11110000111 = 1927;
+	public const int b11110001000 = 1928;
+	public const int b11110001001 = 1929;
+	public const int b11110001010 = 1930;
+	public const int b11110001011 = 1931;
+	public const int b11110001100 = 1932;
+	public const int b11110001101 = 1933;
+	public const int b11110001110 = 1934;
+	public const int b11110001111 = 1935;
+	public const int b11110010000 = 1936;
+	public const int b11110010001 = 1937;
+	public const int b11110010010 = 1938;
+	public const int b11110010011 = 1939;
+	public const int b11110010100 = 1940;
+	public const int b11110010101 = 1941;
+	public const int b11110010110 = 1942;
+	public const int b11110010111 = 1943;
+	public const int b11110011000 = 1944;
+	public const int b11110011001 = 1945;
+	public const int b11110011010 = 1946;
+	public const int b11110011011 = 1947;
+	public const int b11110011100 = 1948;
+	public const int b11110011101 = 1949;
+	public const int b11110011110 = 1950;
+	public const int b11110011111 = 1951;
+	public const int b11110100000 = 1952;
+	public const int b11110100001 = 1953;
+	public const int b11110100010 = 1954;
+	public const int b11110100011 = 1955;
+	public const int b11110100100 = 1956;
+	public const int b11110100101 = 1957;
+	public const int b11110100110 = 1958;
+	public const int b11110100111 = 1959;
+	public const int b11110101000 = 1960;
+	public const int b11110101001 = 1961;
+	public const int b11110101010 = 1962;
+	public const int b11110101011 = 1963;
+	public const int b11110101100 = 1964;
+	public const int b11110101101 = 1965;
+	public const int b11110101110 = 1966;
+	public const int b11110101111 = 1967;
+	public const int b11110110000 = 1968;
+	public const int b11110110001 = 1969;
+	public const int b11110110010 = 1970;
+	public const int b11110110011 = 1971;
+	public const int b11110110100 = 1972;
+	public const int b11110110101 = 1973;
+	public const int b11110110110 = 1974;
+	public const int b11110110111 = 1975;
+	public const int b11110111000 = 1976;
+	public const int b11110111001 = 1977;
+	public const int b11110111010 = 1978;
+	public const int b11110111011 = 1979;
+	public const int b11110111100 = 1980;
+	public const int b11110111101 = 1981;
+	public const int b11110111110 = 1982;
+	public const int b11110111111 = 1983;
+	public const int b11111000000 = 1984;
+	public const int b11111000001 = 1985;
+	public const int b11111000010 = 1986;
+	public const int b11111000011 = 1987;
+	public const int b11111000100 = 1988;
+	public const int b11111000101 = 1989;
+	public const int b11111000110 = 1990;
+	public const int b11111000111 = 1991;
+	public const int b11111001000 = 1992;
+	public const int b11111001001 = 1993;
+	public const int b11111001010 = 1994;
+	public const int b11111001011 = 1995;
+	public const int b11111001100 = 1996;
+	public const int b11111001101 = 1997;
+	public const int b11111001110 = 1998;
+	public const int b11111001111 = 1999;
+	public const int b11111010000 = 2000;
+	public const int b11111010001 = 2001;
+	public const int b11111010010 = 2002;
+	public const int b11111010011 = 2003;
+	public const int b11111010100 = 2004;
+	public const int b11111010101 = 2005;
+	public const int b11111010110 = 2006;
+	public const int b11111010111 = 2007;
+	public const int b11111011000 = 2008;
+	public const int b11111011001 = 2009;
+	public const int b11111011010 = 2010;
+	public const int b11111011011 = 2011;
+	public const int b11111011100 = 2012;
+	public const int b11111011101 = 2013;
+	public const int b11111011110 = 2014;
+	public const int b11111011111 = 2015;
+	public const int b11111100000 = 2016;
+	public const int b11111100001 = 2017;
+	public const int b11111100010 = 2018;
+	public const int b11111100011 = 2019;
+	public const int b11111100100 = 2020;
+	public const int b11111100101 = 2021;
+	public const int b11111100110 = 2022;
+	public const int b11111100111 = 2023;
+	public const int b11111101000 = 2024;
+	public const int b11111101001 = 2025;
+	public const int b11111101010 = 2026;
+	public const int b11111101011 = 2027;
+	public const int b11111101100 = 2028;
+	public const int b11111101101 = 2029;
+	public const int b11111101110 = 2030;
+	public const int b11111101111 = 2031;
+	public const int b11111110000 = 2032;
+	public const int b11111110001 = 2033;
+	public const int b11111110010 = 2034;
+	public const int b11111110011 = 2035;
+	public const int b11111110100 = 2036;
+	public const int b11111110101 = 2037;
+	public const int b11111110110 = 2038;
+	public const int b11111110111 = 2039;
+	public const int b11111111000 = 2040;
+	public const int b11111111001 = 2041;
+	public const int b11111111010 = 2042;
+	public const int b11111111011 = 2043;
+	public const int b11111111100 = 2044;
+	public const int b11111111101 = 2045;
+	public const int b11111111110 = 2046;
+	public const int b11111111111 = 2047;
+	public const int b0000000000 = 0;
+	public const int b0000000001 = 1;
+	public const int b0000000010 = 2;
+	public const int b0000000011 = 3;
+	public const int b0000000100 = 4;
+	public const int b0000000101 = 5;
+	public const int b0000000110 = 6;
+	public const int b0000000111 = 7;
+	public const int b0000001000 = 8;
+	public const int b0000001001 = 9;
+	public const int b0000001010 = 10;
+	public const int b0000001011 = 11;
+	public const int b0000001100 = 12;
+	public const int b0000001101 = 13;
+	public const int b0000001110 = 14;
+	public const int b0000001111 = 15;
+	public const int b0000010000 = 16;
+	public const int b0000010001 = 17;
+	public const int b0000010010 = 18;
+	public const int b0000010011 = 19;
+	public const int b0000010100 = 20;
+	public const int b0000010101 = 21;
+	public const int b0000010110 = 22;
+	public const int b0000010111 = 23;
+	public const int b0000011000 = 24;
+	public const int b0000011001 = 25;
+	public const int b0000011010 = 26;
+	public const int b0000011011 = 27;
+	public const int b0000011100 = 28;
+	public const int b0000011101 = 29;
+	public const int b0000011110 = 30;
+	public const int b0000011111 = 31;
+	public const int b0000100000 = 32;
+	public const int b0000100001 = 33;
+	public const int b0000100010 = 34;
+	public const int b0000100011 = 35;
+	public const int b0000100100 = 36;
+	public const int b0000100101 = 37;
+	public const int b0000100110 = 38;
+	public const int b0000100111 = 39;
+	public const int b0000101000 = 40;
+	public const int b0000101001 = 41;
+	public const int b0000101010 = 42;
+	public const int b0000101011 = 43;
+	public const int b0000101100 = 44;
+	public const int b0000101101 = 45;
+	public const int b0000101110 = 46;
+	public const int b0000101111 = 47;
+	public const int b0000110000 = 48;
+	public const int b0000110001 = 49;
+	public const int b0000110010 = 50;
+	public const int b0000110011 = 51;
+	public const int b0000110100 = 52;
+	public const int b0000110101 = 53;
+	public const int b0000110110 = 54;
+	public const int b0000110111 = 55;
+	public const int b0000111000 = 56;
+	public const int b0000111001 = 57;
+	public const int b0000111010 = 58;
+	public const int b0000111011 = 59;
+	public const int b0000111100 = 60;
+	public const int b0000111101 = 61;
+	public const int b0000111110 = 62;
+	public const int b0000111111 = 63;
+	public const int b0001000000 = 64;
+	public const int b0001000001 = 65;
+	public const int b0001000010 = 66;
+	public const int b0001000011 = 67;
+	public const int b0001000100 = 68;
+	public const int b0001000101 = 69;
+	public const int b0001000110 = 70;
+	public const int b0001000111 = 71;
+	public const int b0001001000 = 72;
+	public const int b0001001001 = 73;
+	public const int b0001001010 = 74;
+	public const int b0001001011 = 75;
+	public const int b0001001100 = 76;
+	public const int b0001001101 = 77;
+	public const int b0001001110 = 78;
+	public const int b0001001111 = 79;
+	public const int b0001010000 = 80;
+	public const int b0001010001 = 81;
+	public const int b0001010010 = 82;
+	public const int b0001010011 = 83;
+	public const int b0001010100 = 84;
+	public const int b0001010101 = 85;
+	public const int b0001010110 = 86;
+	public const int b0001010111 = 87;
+	public const int b0001011000 = 88;
+	public const int b0001011001 = 89;
+	public const int b0001011010 = 90;
+	public const int b0001011011 = 91;
+	public const int b0001011100 = 92;
+	public const int b0001011101 = 93;
+	public const int b0001011110 = 94;
+	public const int b0001011111 = 95;
+	public const int b0001100000 = 96;
+	public const int b0001100001 = 97;
+	public const int b0001100010 = 98;
+	public const int b0001100011 = 99;
+	public const int b0001100100 = 100;
+	public const int b0001100101 = 101;
+	public const int b0001100110 = 102;
+	public const int b0001100111 = 103;
+	public const int b0001101000 = 104;
+	public const int b0001101001 = 105;
+	public const int b0001101010 = 106;
+	public const int b0001101011 = 107;
+	public const int b0001101100 = 108;
+	public const int b0001101101 = 109;
+	public const int b0001101110 = 110;
+	public const int b0001101111 = 111;
+	public const int b0001110000 = 112;
+	public const int b0001110001 = 113;
+	public const int b0001110010 = 114;
+	public const int b0001110011 = 115;
+	public const int b0001110100 = 116;
+	public const int b0001110101 = 117;
+	public const int b0001110110 = 118;
+	public const int b0001110111 = 119;
+	public const int b0001111000 = 120;
+	public const int b0001111001 = 121;
+	public const int b0001111010 = 122;
+	public const int b0001111011 = 123;
+	public const int b0001111100 = 124;
+	public const int b0001111101 = 125;
+	public const int b0001111110 = 126;
+	public const int b0001111111 = 127;
+	public const int b0010000000 = 128;
+	public const int b0010000001 = 129;
+	public const int b0010000010 = 130;
+	public const int b0010000011 = 131;
+	public const int b0010000100 = 132;
+	public const int b0010000101 = 133;
+	public const int b0010000110 = 134;
+	public const int b0010000111 = 135;
+	public const int b0010001000 = 136;
+	public const int b0010001001 = 137;
+	public const int b0010001010 = 138;
+	public const int b0010001011 = 139;
+	public const int b0010001100 = 140;
+	public const int b0010001101 = 141;
+	public const int b0010001110 = 142;
+	public const int b0010001111 = 143;
+	public const int b0010010000 = 144;
+	public const int b0010010001 = 145;
+	public const int b0010010010 = 146;
+	public const int b0010010011 = 147;
+	public const int b0010010100 = 148;
+	public const int b0010010101 = 149;
+	public const int b0010010110 = 150;
+	public const int b0010010111 = 151;
+	public const int b0010011000 = 152;
+	public const int b0010011001 = 153;
+	public const int b0010011010 = 154;
+	public const int b0010011011 = 155;
+	public const int b0010011100 = 156;
+	public const int b0010011101 = 157;
+	public const int b0010011110 = 158;
+	public const int b0010011111 = 159;
+	public const int b0010100000 = 160;
+	public const int b0010100001 = 161;
+	public const int b0010100010 = 162;
+	public const int b0010100011 = 163;
+	public const int b0010100100 = 164;
+	public const int b0010100101 = 165;
+	public const int b0010100110 = 166;
+	public const int b0010100111 = 167;
+	public const int b0010101000 = 168;
+	public const int b0010101001 = 169;
+	public const int b0010101010 = 170;
+	public const int b0010101011 = 171;
+	public const int b0010101100 = 172;
+	public const int b0010101101 = 173;
+	public const int b0010101110 = 174;
+	public const int b0010101111 = 175;
+	public const int b0010110000 = 176;
+	public const int b0010110001 = 177;
+	public const int b0010110010 = 178;
+	public const int b0010110011 = 179;
+	public const int b0010110100 = 180;
+	public const int b0010110101 = 181;
+	public const int b0010110110 = 182;
+	public const int b0010110111 = 183;
+	public const int b0010111000 = 184;
+	public const int b0010111001 = 185;
+	public const int b0010111010 = 186;
+	public const int b0010111011 = 187;
+	public const int b0010111100 = 188;
+	public const int b0010111101 = 189;
+	public const int b0010111110 = 190;
+	public const int b0010111111 = 191;
+	public const int b0011000000 = 192;
+	public const int b0011000001 = 193;
+	public const int b0011000010 = 194;
+	public const int b0011000011 = 195;
+	public const int b0011000100 = 196;
+	public const int b0011000101 = 197;
+	public const int b0011000110 = 198;
+	public const int b0011000111 = 199;
+	public const int b0011001000 = 200;
+	public const int b0011001001 = 201;
+	public const int b0011001010 = 202;
+	public const int b0011001011 = 203;
+	public const int b0011001100 = 204;
+	public const int b0011001101 = 205;
+	public const int b0011001110 = 206;
+	public const int b0011001111 = 207;
+	public const int b0011010000 = 208;
+	public const int b0011010001 = 209;
+	public const int b0011010010 = 210;
+	public const int b0011010011 = 211;
+	public const int b0011010100 = 212;
+	public const int b0011010101 = 213;
+	public const int b0011010110 = 214;
+	public const int b0011010111 = 215;
+	public const int b0011011000 = 216;
+	public const int b0011011001 = 217;
+	public const int b0011011010 = 218;
+	public const int b0011011011 = 219;
+	public const int b0011011100 = 220;
+	public const int b0011011101 = 221;
+	public const int b0011011110 = 222;
+	public const int b0011011111 = 223;
+	public const int b0011100000 = 224;
+	public const int b0011100001 = 225;
+	public const int b0011100010 = 226;
+	public const int b0011100011 = 227;
+	public const int b0011100100 = 228;
+	public const int b0011100101 = 229;
+	public const int b0011100110 = 230;
+	public const int b0011100111 = 231;
+	public const int b0011101000 = 232;
+	public const int b0011101001 = 233;
+	public const int b0011101010 = 234;
+	public const int b0011101011 = 235;
+	public const int b0011101100 = 236;
+	public const int b0011101101 = 237;
+	public const int b0011101110 = 238;
+	public const int b0011101111 = 239;
+	public const int b0011110000 = 240;
+	public const int b0011110001 = 241;
+	public const int b0011110010 = 242;
+	public const int b0011110011 = 243;
+	public const int b0011110100 = 244;
+	public const int b0011110101 = 245;
+	public const int b0011110110 = 246;
+	public const int b0011110111 = 247;
+	public const int b0011111000 = 248;
+	public const int b0011111001 = 249;
+	public const int b0011111010 = 250;
+	public const int b0011111011 = 251;
+	public const int b0011111100 = 252;
+	public const int b0011111101 = 253;
+	public const int b0011111110 = 254;
+	public const int b0011111111 = 255;
+	public const int b0100000000 = 256;
+	public const int b0100000001 = 257;
+	public const int b0100000010 = 258;
+	public const int b0100000011 = 259;
+	public const int b0100000100 = 260;
+	public const int b0100000101 = 261;
+	public const int b0100000110 = 262;
+	public const int b0100000111 = 263;
+	public const int b0100001000 = 264;
+	public const int b0100001001 = 265;
+	public const int b0100001010 = 266;
+	public const int b0100001011 = 267;
+	public const int b0100001100 = 268;
+	public const int b0100001101 = 269;
+	public const int b0100001110 = 270;
+	public const int b0100001111 = 271;
+	public const int b0100010000 = 272;
+	public const int b0100010001 = 273;
+	public const int b0100010010 = 274;
+	public const int b0100010011 = 275;
+	public const int b0100010100 = 276;
+	public const int b0100010101 = 277;
+	public const int b0100010110 = 278;
+	public const int b0100010111 = 279;
+	public const int b0100011000 = 280;
+	public const int b0100011001 = 281;
+	public const int b0100011010 = 282;
+	public const int b0100011011 = 283;
+	public const int b0100011100 = 284;
+	public const int b0100011101 = 285;
+	public const int b0100011110 = 286;
+	public const int b0100011111 = 287;
+	public const int b0100100000 = 288;
+	public const int b0100100001 = 289;
+	public const int b0100100010 = 290;
+	public const int b0100100011 = 291;
+	public const int b0100100100 = 292;
+	public const int b0100100101 = 293;
+	public const int b0100100110 = 294;
+	public const int b0100100111 = 295;
+	public const int b0100101000 = 296;
+	public const int b0100101001 = 297;
+	public const int b0100101010 = 298;
+	public const int b0100101011 = 299;
+	public const int b0100101100 = 300;
+	public const int b0100101101 = 301;
+	public const int b0100101110 = 302;
+	public const int b0100101111 = 303;
+	public const int b0100110000 = 304;
+	public const int b0100110001 = 305;
+	public const int b0100110010 = 306;
+	public const int b0100110011 = 307;
+	public const int b0100110100 = 308;
+	public const int b0100110101 = 309;
+	public const int b0100110110 = 310;
+	public const int b0100110111 = 311;
+	public const int b0100111000 = 312;
+	public const int b0100111001 = 313;
+	public const int b0100111010 = 314;
+	public const int b0100111011 = 315;
+	public const int b0100111100 = 316;
+	public const int b0100111101 = 317;
+	public const int b0100111110 = 318;
+	public const int b0100111111 = 319;
+	public const int b0101000000 = 320;
+	public const int b0101000001 = 321;
+	public const int b0101000010 = 322;
+	public const int b0101000011 = 323;
+	public const int b0101000100 = 324;
+	public const int b0101000101 = 325;
+	public const int b0101000110 = 326;
+	public const int b0101000111 = 327;
+	public const int b0101001000 = 328;
+	public const int b0101001001 = 329;
+	public const int b0101001010 = 330;
+	public const int b0101001011 = 331;
+	public const int b0101001100 = 332;
+	public const int b0101001101 = 333;
+	public const int b0101001110 = 334;
+	public const int b0101001111 = 335;
+	public const int b0101010000 = 336;
+	public const int b0101010001 = 337;
+	public const int b0101010010 = 338;
+	public const int b0101010011 = 339;
+	public const int b0101010100 = 340;
+	public const int b0101010101 = 341;
+	public const int b0101010110 = 342;
+	public const int b0101010111 = 343;
+	public const int b0101011000 = 344;
+	public const int b0101011001 = 345;
+	public const int b0101011010 = 346;
+	public const int b0101011011 = 347;
+	public const int b0101011100 = 348;
+	public const int b0101011101 = 349;
+	public const int b0101011110 = 350;
+	public const int b0101011111 = 351;
+	public const int b0101100000 = 352;
+	public const int b0101100001 = 353;
+	public const int b0101100010 = 354;
+	public const int b0101100011 = 355;
+	public const int b0101100100 = 356;
+	public const int b0101100101 = 357;
+	public const int b0101100110 = 358;
+	public const int b0101100111 = 359;
+	public const int b0101101000 = 360;
+	public const int b0101101001 = 361;
+	public const int b0101101010 = 362;
+	public const int b0101101011 = 363;
+	public const int b0101101100 = 364;
+	public const int b0101101101 = 365;
+	public const int b0101101110 = 366;
+	public const int b0101101111 = 367;
+	public const int b0101110000 = 368;
+	public const int b0101110001 = 369;
+	public const int b0101110010 = 370;
+	public const int b0101110011 = 371;
+	public const int b0101110100 = 372;
+	public const int b0101110101 = 373;
+	public const int b0101110110 = 374;
+	public const int b0101110111 = 375;
+	public const int b0101111000 = 376;
+	public const int b0101111001 = 377;
+	public const int b0101111010 = 378;
+	public const int b0101111011 = 379;
+	public const int b0101111100 = 380;
+	public const int b0101111101 = 381;
+	public const int b0101111110 = 382;
+	public const int b0101111111 = 383;
+	public const int b0110000000 = 384;
+	public const int b0110000001 = 385;
+	public const int b0110000010 = 386;
+	public const int b0110000011 = 387;
+	public const int b0110000100 = 388;
+	public const int b0110000101 = 389;
+	public const int b0110000110 = 390;
+	public const int b0110000111 = 391;
+	public const int b0110001000 = 392;
+	public const int b0110001001 = 393;
+	public const int b0110001010 = 394;
+	public const int b0110001011 = 395;
+	public const int b0110001100 = 396;
+	public const int b0110001101 = 397;
+	public const int b0110001110 = 398;
+	public const int b0110001111 = 399;
+	public const int b0110010000 = 400;
+	public const int b0110010001 = 401;
+	public const int b0110010010 = 402;
+	public const int b0110010011 = 403;
+	public const int b0110010100 = 404;
+	public const int b0110010101 = 405;
+	public const int b0110010110 = 406;
+	public const int b0110010111 = 407;
+	public const int b0110011000 = 408;
+	public const int b0110011001 = 409;
+	public const int b0110011010 = 410;
+	public const int b0110011011 = 411;
+	public const int b0110011100 = 412;
+	public const int b0110011101 = 413;
+	public const int b0110011110 = 414;
+	public const int b0110011111 = 415;
+	public const int b0110100000 = 416;
+	public const int b0110100001 = 417;
+	public const int b0110100010 = 418;
+	public const int b0110100011 = 419;
+	public const int b0110100100 = 420;
+	public const int b0110100101 = 421;
+	public const int b0110100110 = 422;
+	public const int b0110100111 = 423;
+	public const int b0110101000 = 424;
+	public const int b0110101001 = 425;
+	public const int b0110101010 = 426;
+	public const int b0110101011 = 427;
+	public const int b0110101100 = 428;
+	public const int b0110101101 = 429;
+	public const int b0110101110 = 430;
+	public const int b0110101111 = 431;
+	public const int b0110110000 = 432;
+	public const int b0110110001 = 433;
+	public const int b0110110010 = 434;
+	public const int b0110110011 = 435;
+	public const int b0110110100 = 436;
+	public const int b0110110101 = 437;
+	public const int b0110110110 = 438;
+	public const int b0110110111 = 439;
+	public const int b0110111000 = 440;
+	public const int b0110111001 = 441;
+	public const int b0110111010 = 442;
+	public const int b0110111011 = 443;
+	public const int b0110111100 = 444;
+	public const int b0110111101 = 445;
+	public const int b0110111110 = 446;
+	public const int b0110111111 = 447;
+	public const int b0111000000 = 448;
+	public const int b0111000001 = 449;
+	public const int b0111000010 = 450;
+	public const int b0111000011 = 451;
+	public const int b0111000100 = 452;
+	public const int b0111000101 = 453;
+	public const int b0111000110 = 454;
+	public const int b0111000111 = 455;
+	public const int b0111001000 = 456;
+	public const int b0111001001 = 457;
+	public const int b0111001010 = 458;
+	public const int b0111001011 = 459;
+	public const int b0111001100 = 460;
+	public const int b0111001101 = 461;
+	public const int b0111001110 = 462;
+	public const int b0111001111 = 463;
+	public const int b0111010000 = 464;
+	public const int b0111010001 = 465;
+	public const int b0111010010 = 466;
+	public const int b0111010011 = 467;
+	public const int b0111010100 = 468;
+	public const int b0111010101 = 469;
+	public const int b0111010110 = 470;
+	public const int b0111010111 = 471;
+	public const int b0111011000 = 472;
+	public const int b0111011001 = 473;
+	public const int b0111011010 = 474;
+	public const int b0111011011 = 475;
+	public const int b0111011100 = 476;
+	public const int b0111011101 = 477;
+	public const int b0111011110 = 478;
+	public const int b0111011111 = 479;
+	public const int b0111100000 = 480;
+	public const int b0111100001 = 481;
+	public const int b0111100010 = 482;
+	public const int b0111100011 = 483;
+	public const int b0111100100 = 484;
+	public const int b0111100101 = 485;
+	public const int b0111100110 = 486;
+	public const int b0111100111 = 487;
+	public const int b0111101000 = 488;
+	public const int b0111101001 = 489;
+	public const int b0111101010 = 490;
+	public const int b0111101011 = 491;
+	public const int b0111101100 = 492;
+	public const int b0111101101 = 493;
+	public const int b0111101110 = 494;
+	public const int b0111101111 = 495;
+	public const int b0111110000 = 496;
+	public const int b0111110001 = 497;
+	public const int b0111110010 = 498;
+	public const int b0111110011 = 499;
+	public const int b0111110100 = 500;
+	public const int b0111110101 = 501;
+	public const int b0111110110 = 502;
+	public const int b0111110111 = 503;
+	public const int b0111111000 = 504;
+	public const int b0111111001 = 505;
+	public const int b0111111010 = 506;
+	public const int b0111111011 = 507;
+	public const int b0111111100 = 508;
+	public const int b0111111101 = 509;
+	public const int b0111111110 = 510;
+	public const int b0111111111 = 511;
+	public const int b1000000000 = 512;
+	public const int b1000000001 = 513;
+	public const int b1000000010 = 514;
+	public const int b1000000011 = 515;
+	public const int b1000000100 = 516;
+	public const int b1000000101 = 517;
+	public const int b1000000110 = 518;
+	public const int b1000000111 = 519;
+	public const int b1000001000 = 520;
+	public const int b1000001001 = 521;
+	public const int b1000001010 = 522;
+	public const int b1000001011 = 523;
+	public const int b1000001100 = 524;
+	public const int b1000001101 = 525;
+	public const int b1000001110 = 526;
+	public const int b1000001111 = 527;
+	public const int b1000010000 = 528;
+	public const int b1000010001 = 529;
+	public const int b1000010010 = 530;
+	public const int b1000010011 = 531;
+	public const int b1000010100 = 532;
+	public const int b1000010101 = 533;
+	public const int b1000010110 = 534;
+	public const int b1000010111 = 535;
+	public const int b1000011000 = 536;
+	public const int b1000011001 = 537;
+	public const int b1000011010 = 538;
+	public const int b1000011011 = 539;
+	public const int b1000011100 = 540;
+	public const int b1000011101 = 541;
+	public const int b1000011110 = 542;
+	public const int b1000011111 = 543;
+	public const int b1000100000 = 544;
+	public const int b1000100001 = 545;
+	public const int b1000100010 = 546;
+	public const int b1000100011 = 547;
+	public const int b1000100100 = 548;
+	public const int b1000100101 = 549;
+	public const int b1000100110 = 550;
+	public const int b1000100111 = 551;
+	public const int b1000101000 = 552;
+	public const int b1000101001 = 553;
+	public const int b1000101010 = 554;
+	public const int b1000101011 = 555;
+	public const int b1000101100 = 556;
+	public const int b1000101101 = 557;
+	public const int b1000101110 = 558;
+	public const int b1000101111 = 559;
+	public const int b1000110000 = 560;
+	public const int b1000110001 = 561;
+	public const int b1000110010 = 562;
+	public const int b1000110011 = 563;
+	public const int b1000110100 = 564;
+	public const int b1000110101 = 565;
+	public const int b1000110110 = 566;
+	public const int b1000110111 = 567;
+	public const int b1000111000 = 568;
+	public const int b1000111001 = 569;
+	public const int b1000111010 = 570;
+	public const int b1000111011 = 571;
+	public const int b1000111100 = 572;
+	public const int b1000111101 = 573;
+	public const int b1000111110 = 574;
+	public const int b1000111111 = 575;
+	public const int b1001000000 = 576;
+	public const int b1001000001 = 577;
+	public const int b1001000010 = 578;
+	public const int b1001000011 = 579;
+	public const int b1001000100 = 580;
+	public const int b1001000101 = 581;
+	public const int b1001000110 = 582;
+	public const int b1001000111 = 583;
+	public const int b1001001000 = 584;
+	public const int b1001001001 = 585;
+	public const int b1001001010 = 586;
+	public const int b1001001011 = 587;
+	public const int b1001001100 = 588;
+	public const int b1001001101 = 589;
+	public const int b1001001110 = 590;
+	public const int b1001001111 = 591;
+	public const int b1001010000 = 592;
+	public const int b1001010001 = 593;
+	public const int b1001010010 = 594;
+	public const int b1001010011 = 595;
+	public const int b1001010100 = 596;
+	public const int b1001010101 = 597;
+	public const int b1001010110 = 598;
+	public const int b1001010111 = 599;
+	public const int b1001011000 = 600;
+	public const int b1001011001 = 601;
+	public const int b1001011010 = 602;
+	public const int b1001011011 = 603;
+	public const int b1001011100 = 604;
+	public const int b1001011101 = 605;
+	public const int b1001011110 = 606;
+	public const int b1001011111 = 607;
+	public const int b1001100000 = 608;
+	public const int b1001100001 = 609;
+	public const int b1001100010 = 610;
+	public const int b1001100011 = 611;
+	public const int b1001100100 = 612;
+	public const int b1001100101 = 613;
+	public const int b1001100110 = 614;
+	public const int b1001100111 = 615;
+	public const int b1001101000 = 616;
+	public const int b1001101001 = 617;
+	public const int b1001101010 = 618;
+	public const int b1001101011 = 619;
+	public const int b1001101100 = 620;
+	public const int b1001101101 = 621;
+	public const int b1001101110 = 622;
+	public const int b1001101111 = 623;
+	public const int b1001110000 = 624;
+	public const int b1001110001 = 625;
+	public const int b1001110010 = 626;
+	public const int b1001110011 = 627;
+	public const int b1001110100 = 628;
+	public const int b1001110101 = 629;
+	public const int b1001110110 = 630;
+	public const int b1001110111 = 631;
+	public const int b1001111000 = 632;
+	public const int b1001111001 = 633;
+	public const int b1001111010 = 634;
+	public const int b1001111011 = 635;
+	public const int b1001111100 = 636;
+	public const int b1001111101 = 637;
+	public const int b1001111110 = 638;
+	public const int b1001111111 = 639;
+	public const int b1010000000 = 640;
+	public const int b1010000001 = 641;
+	public const int b1010000010 = 642;
+	public const int b1010000011 = 643;
+	public const int b1010000100 = 644;
+	public const int b1010000101 = 645;
+	public const int b1010000110 = 646;
+	public const int b1010000111 = 647;
+	public const int b1010001000 = 648;
+	public const int b1010001001 = 649;
+	public const int b1010001010 = 650;
+	public const int b1010001011 = 651;
+	public const int b1010001100 = 652;
+	public const int b1010001101 = 653;
+	public const int b1010001110 = 654;
+	public const int b1010001111 = 655;
+	public const int b1010010000 = 656;
+	public const int b1010010001 = 657;
+	public const int b1010010010 = 658;
+	public const int b1010010011 = 659;
+	public const int b1010010100 = 660;
+	public const int b1010010101 = 661;
+	public const int b1010010110 = 662;
+	public const int b1010010111 = 663;
+	public const int b1010011000 = 664;
+	public const int b1010011001 = 665;
+	public const int b1010011010 = 666;
+	public const int b1010011011 = 667;
+	public const int b1010011100 = 668;
+	public const int b1010011101 = 669;
+	public const int b1010011110 = 670;
+	public const int b1010011111 = 671;
+	public const int b1010100000 = 672;
+	public const int b1010100001 = 673;
+	public const int b1010100010 = 674;
+	public const int b1010100011 = 675;
+	public const int b1010100100 = 676;
+	public const int b1010100101 = 677;
+	public const int b1010100110 = 678;
+	public const int b1010100111 = 679;
+	public const int b1010101000 = 680;
+	public const int b1010101001 = 681;
+	public const int b1010101010 = 682;
+	public const int b1010101011 = 683;
+	public const int b1010101100 = 684;
+	public const int b1010101101 = 685;
+	public const int b1010101110 = 686;
+	public const int b1010101111 = 687;
+	public const int b1010110000 = 688;
+	public const int b1010110001 = 689;
+	public const int b1010110010 = 690;
+	public const int b1010110011 = 691;
+	public const int b1010110100 = 692;
+	public const int b1010110101 = 693;
+	public const int b1010110110 = 694;
+	public const int b1010110111 = 695;
+	public const int b1010111000 = 696;
+	public const int b1010111001 = 697;
+	public const int b1010111010 = 698;
+	public const int b1010111011 = 699;
+	public const int b1010111100 = 700;
+	public const int b1010111101 = 701;
+	public const int b1010111110 = 702;
+	public const int b1010111111 = 703;
+	public const int b1011000000 = 704;
+	public const int b1011000001 = 705;
+	public const int b1011000010 = 706;
+	public const int b1011000011 = 707;
+	public const int b1011000100 = 708;
+	public const int b1011000101 = 709;
+	public const int b1011000110 = 710;
+	public const int b1011000111 = 711;
+	public const int b1011001000 = 712;
+	public const int b1011001001 = 713;
+	public const int b1011001010 = 714;
+	public const int b1011001011 = 715;
+	public const int b1011001100 = 716;
+	public const int b1011001101 = 717;
+	public const int b1011001110 = 718;
+	public const int b1011001111 = 719;
+	public const int b1011010000 = 720;
+	public const int b1011010001 = 721;
+	public const int b1011010010 = 722;
+	public const int b1011010011 = 723;
+	public const int b1011010100 = 724;
+	public const int b1011010101 = 725;
+	public const int b1011010110 = 726;
+	public const int b1011010111 = 727;
+	public const int b1011011000 = 728;
+	public const int b1011011001 = 729;
+	public const int b1011011010 = 730;
+	public const int b1011011011 = 731;
+	public const int b1011011100 = 732;
+	public const int b1011011101 = 733;
+	public const int b1011011110 = 734;
+	public const int b1011011111 = 735;
+	public const int b1011100000 = 736;
+	public const int b1011100001 = 737;
+	public const int b1011100010 = 738;
+	public const int b1011100011 = 739;
+	public const int b1011100100 = 740;
+	public const int b1011100101 = 741;
+	public const int b1011100110 = 742;
+	public const int b1011100111 = 743;
+	public const int b1011101000 = 744;
+	public const int b1011101001 = 745;
+	public const int b1011101010 = 746;
+	public const int b1011101011 = 747;
+	public const int b1011101100 = 748;
+	public const int b1011101101 = 749;
+	public const int b1011101110 = 750;
+	public const int b1011101111 = 751;
+	public const int b1011110000 = 752;
+	public const int b1011110001 = 753;
+	public const int b1011110010 = 754;
+	public const int b1011110011 = 755;
+	public const int b1011110100 = 756;
+	public const int b1011110101 = 757;
+	public const int b1011110110 = 758;
+	public const int b1011110111 = 759;
+	public const int b1011111000 = 760;
+	public const int b1011111001 = 761;
+	public const int b1011111010 = 762;
+	public const int b1011111011 = 763;
+	public const int b1011111100 = 764;
+	public const int b1011111101 = 765;
+	public const int b1011111110 = 766;
+	public const int b1011111111 = 767;
+	public const int b1100000000 = 768;
+	public const int b1100000001 = 769;
+	public const int b1100000010 = 770;
+	public const int b1100000011 = 771;
+	public const int b1100000100 = 772;
+	public const int b1100000101 = 773;
+	public const int b1100000110 = 774;
+	public const int b1100000111 = 775;
+	public const int b1100001000 = 776;
+	public const int b1100001001 = 777;
+	public const int b1100001010 = 778;
+	public const int b1100001011 = 779;
+	public const int b1100001100 = 780;
+	public const int b1100001101 = 781;
+	public const int b1100001110 = 782;
+	public const int b1100001111 = 783;
+	public const int b1100010000 = 784;
+	public const int b1100010001 = 785;
+	public const int b1100010010 = 786;
+	public const int b1100010011 = 787;
+	public const int b1100010100 = 788;
+	public const int b1100010101 = 789;
+	public const int b1100010110 = 790;
+	public const int b1100010111 = 791;
+	public const int b1100011000 = 792;
+	public const int b1100011001 = 793;
+	public const int b1100011010 = 794;
+	public const int b1100011011 = 795;
+	public const int b1100011100 = 796;
+	public const int b1100011101 = 797;
+	public const int b1100011110 = 798;
+	public const int b1100011111 = 799;
+	public const int b1100100000 = 800;
+	public const int b1100100001 = 801;
+	public const int b1100100010 = 802;
+	public const int b1100100011 = 803;
+	public const int b1100100100 = 804;
+	public const int b1100100101 = 805;
+	public const int b1100100110 = 806;
+	public const int b1100100111 = 807;
+	public const int b1100101000 = 808;
+	public const int b1100101001 = 809;
+	public const int b1100101010 = 810;
+	public const int b1100101011 = 811;
+	public const int b1100101100 = 812;
+	public const int b1100101101 = 813;
+	public const int b1100101110 = 814;
+	public const int b1100101111 = 815;
+	public const int b1100110000 = 816;
+	public const int b1100110001 = 817;
+	public const int b1100110010 = 818;
+	public const int b1100110011 = 819;
+	public const int b1100110100 = 820;
+	public const int b1100110101 = 821;
+	public const int b1100110110 = 822;
+	public const int b1100110111 = 823;
+	public const int b1100111000 = 824;
+	public const int b1100111001 = 825;
+	public const int b1100111010 = 826;
+	public const int b1100111011 = 827;
+	public const int b1100111100 = 828;
+	public const int b1100111101 = 829;
+	public const int b1100111110 = 830;
+	public const int b1100111111 = 831;
+	public const int b1101000000 = 832;
+	public const int b1101000001 = 833;
+	public const int b1101000010 = 834;
+	public const int b1101000011 = 835;
+	public const int b1101000100 = 836;
+	public const int b1101000101 = 837;
+	public const int b1101000110 = 838;
+	public const int b1101000111 = 839;
+	public const int b1101001000 = 840;
+	public const int b1101001001 = 841;
+	public const int b1101001010 = 842;
+	public const int b1101001011 = 843;
+	public const int b1101001100 = 844;
+	public const int b1101001101 = 845;
+	public const int b1101001110 = 846;
+	public const int b1101001111 = 847;
+	public const int b1101010000 = 848;
+	public const int b1101010001 = 849;
+	public const int b1101010010 = 850;
+	public const int b1101010011 = 851;
+	public const int b1101010100 = 852;
+	public const int b1101010101 = 853;
+	public const int b1101010110 = 854;
+	public const int b1101010111 = 855;
+	public const int b1101011000 = 856;
+	public const int b1101011001 = 857;
+	public const int b1101011010 = 858;
+	public const int b1101011011 = 859;
+	public const int b1101011100 = 860;
+	public const int b1101011101 = 861;
+	public const int b1101011110 = 862;
+	public const int b1101011111 = 863;
+	public const int b1101100000 = 864;
+	public const int b1101100001 = 865;
+	public const int b1101100010 = 866;
+	public const int b1101100011 = 867;
+	public const int b1101100100 = 868;
+	public const int b1101100101 = 869;
+	public const int b1101100110 = 870;
+	public const int b1101100111 = 871;
+	public const int b1101101000 = 872;
+	public const int b1101101001 = 873;
+	public const int b1101101010 = 874;
+	public const int b1101101011 = 875;
+	public const int b1101101100 = 876;
+	public const int b1101101101 = 877;
+	public const int b1101101110 = 878;
+	public const int b1101101111 = 879;
+	public const int b1101110000 = 880;
+	public const int b1101110001 = 881;
+	public const int b1101110010 = 882;
+	public const int b1101110011 = 883;
+	public const int b1101110100 = 884;
+	public const int b1101110101 = 885;
+	public const int b1101110110 = 886;
+	public const int b1101110111 = 887;
+	public const int b1101111000 = 888;
+	public const int b1101111001 = 889;
+	public const int b1101111010 = 890;
+	public const int b1101111011 = 891;
+	public const int b1101111100 = 892;
+	public const int b1101111101 = 893;
+	public const int b1101111110 = 894;
+	public const int b1101111111 = 895;
+	public const int b1110000000 = 896;
+	public const int b1110000001 = 897;
+	public const int b1110000010 = 898;
+	public const int b1110000011 = 899;
+	public const int b1110000100 = 900;
+	public const int b1110000101 = 901;
+	public const int b1110000110 = 902;
+	public const int b1110000111 = 903;
+	public const int b1110001000 = 904;
+	public const int b1110001001 = 905;
+	public const int b1110001010 = 906;
+	public const int b1110001011 = 907;
+	public const int b1110001100 = 908;
+	public const int b1110001101 = 909;
+	public const int b1110001110 = 910;
+	public const int b1110001111 = 911;
+	public const int b1110010000 = 912;
+	public const int b1110010001 = 913;
+	public const int b1110010010 = 914;
+	public const int b1110010011 = 915;
+	public const int b1110010100 = 916;
+	public const int b1110010101 = 917;
+	public const int b1110010110 = 918;
+	public const int b1110010111 = 919;
+	public const int b1110011000 = 920;
+	public const int b1110011001 = 921;
+	public const int b1110011010 = 922;
+	public const int b1110011011 = 923;
+	public const int b1110011100 = 924;
+	public const int b1110011101 = 925;
+	public const int b1110011110 = 926;
+	public const int b1110011111 = 927;
+	public const int b1110100000 = 928;
+	public const int b1110100001 = 929;
+	public const int b1110100010 = 930;
+	public const int b1110100011 = 931;
+	public const int b1110100100 = 932;
+	public const int b1110100101 = 933;
+	public const int b1110100110 = 934;
+	public const int b1110100111 = 935;
+	public const int b1110101000 = 936;
+	public const int b1110101001 = 937;
+	public const int b1110101010 = 938;
+	public const int b1110101011 = 939;
+	public const int b1110101100 = 940;
+	public const int b1110101101 = 941;
+	public const int b1110101110 = 942;
+	public const int b1110101111 = 943;
+	public const int b1110110000 = 944;
+	public const int b1110110001 = 945;
+	public const int b1110110010 = 946;
+	public const int b1110110011 = 947;
+	public const int b1110110100 = 948;
+	public const int b1110110101 = 949;
+	public const int b1110110110 = 950;
+	public const int b1110110111 = 951;
+	public const int b1110111000 = 952;
+	public const int b1110111001 = 953;
+	public const int b1110111010 = 954;
+	public const int b1110111011 = 955;
+	public const int b1110111100 = 956;
+	public const int b1110111101 = 957;
+	public const int b1110111110 = 958;
+	public const int b1110111111 = 959;
+	public const int b1111000000 = 960;
+	public const int b1111000001 = 961;
+	public const int b1111000010 = 962;
+	public const int b1111000011 = 963;
+	public const int b1111000100 = 964;
+	public const int b1111000101 = 965;
+	public const int b1111000110 = 966;
+	public const int b1111000111 = 967;
+	public const int b1111001000 = 968;
+	public const int b1111001001 = 969;
+	public const int b1111001010 = 970;
+	public const int b1111001011 = 971;
+	public const int b1111001100 = 972;
+	public const int b1111001101 = 973;
+	public const int b1111001110 = 974;
+	public const int b1111001111 = 975;
+	public const int b1111010000 = 976;
+	public const int b1111010001 = 977;
+	public const int b1111010010 = 978;
+	public const int b1111010011 = 979;
+	public const int b1111010100 = 980;
+	public const int b1111010101 = 981;
+	public const int b1111010110 = 982;
+	public const int b1111010111 = 983;
+	public const int b1111011000 = 984;
+	public const int b1111011001 = 985;
+	public const int b1111011010 = 986;
+	public const int b1111011011 = 987;
+	public const int b1111011100 = 988;
+	public const int b1111011101 = 989;
+	public const int b1111011110 = 990;
+	public const int b1111011111 = 991;
+	public const int b1111100000 = 992;
+	public const int b1111100001 = 993;
+	public const int b1111100010 = 994;
+	public const int b1111100011 = 995;
+	public const int b1111100100 = 996;
+	public const int b1111100101 = 997;
+	public const int b1111100110 = 998;
+	public const int b1111100111 = 999;
+	public const int b1111101000 = 1000;
+	public const int b1111101001 = 1001;
+	public const int b1111101010 = 1002;
+	public const int b1111101011 = 1003;
+	public const int b1111101100 = 1004;
+	public const int b1111101101 = 1005;
+	public const int b1111101110 = 1006;
+	public const int b1111101111 = 1007;
+	public const int b1111110000 = 1008;
+	public const int b1111110001 = 1009;
+	public const int b1111110010 = 1010;
+	public const int b1111110011 = 1011;
+	public const int b1111110100 = 1012;
+	public const int b1111110101 = 1013;
+	public const int b1111110110 = 1014;
+	public const int b1111110111 = 1015;
+	public const int b1111111000 = 1016;
+	public const int b1111111001 = 1017;
+	public const int b1111111010 = 1018;
+	public const int b1111111011 = 1019;
+	public const int b1111111100 = 1020;
+	public const int b1111111101 = 1021;
+	public const int b1111111110 = 1022;
+	public const int b1111111111 = 1023;
+	public const int b000000000 = 0;
+	public const int b000000001 = 1;
+	public const int b000000010 = 2;
+	public const int b000000011 = 3;
+	public const int b000000100 = 4;
+	public const int b000000101 = 5;
+	public const int b000000110 = 6;
+	public const int b000000111 = 7;
+	public const int b000001000 = 8;
+	public const int b000001001 = 9;
+	public const int b000001010 = 10;
+	public const int b000001011 = 11;
+	public const int b000001100 = 12;
+	public const int b000001101 = 13;
+	public const int b000001110 = 14;
+	public const int b000001111 = 15;
+	public const int b000010000 = 16;
+	public const int b000010001 = 17;
+	public const int b000010010 = 18;
+	public const int b000010011 = 19;
+	public const int b000010100 = 20;
+	public const int b000010101 = 21;
+	public const int b000010110 = 22;
+	public const int b000010111 = 23;
+	public const int b000011000 = 24;
+	public const int b000011001 = 25;
+	public const int b000011010 = 26;
+	public const int b000011011 = 27;
+	public const int b000011100 = 28;
+	public const int b000011101 = 29;
+	public const int b000011110 = 30;
+	public const int b000011111 = 31;
+	public const int b000100000 = 32;
+	public const int b000100001 = 33;
+	public const int b000100010 = 34;
+	public const int b000100011 = 35;
+	public const int b000100100 = 36;
+	public const int b000100101 = 37;
+	public const int b000100110 = 38;
+	public const int b000100111 = 39;
+	public const int b000101000 = 40;
+	public const int b000101001 = 41;
+	public const int b000101010 = 42;
+	public const int b000101011 = 43;
+	public const int b000101100 = 44;
+	public const int b000101101 = 45;
+	public const int b000101110 = 46;
+	public const int b000101111 = 47;
+	public const int b000110000 = 48;
+	public const int b000110001 = 49;
+	public const int b000110010 = 50;
+	public const int b000110011 = 51;
+	public const int b000110100 = 52;
+	public const int b000110101 = 53;
+	public const int b000110110 = 54;
+	public const int b000110111 = 55;
+	public const int b000111000 = 56;
+	public const int b000111001 = 57;
+	public const int b000111010 = 58;
+	public const int b000111011 = 59;
+	public const int b000111100 = 60;
+	public const int b000111101 = 61;
+	public const int b000111110 = 62;
+	public const int b000111111 = 63;
+	public const int b001000000 = 64;
+	public const int b001000001 = 65;
+	public const int b001000010 = 66;
+	public const int b001000011 = 67;
+	public const int b001000100 = 68;
+	public const int b001000101 = 69;
+	public const int b001000110 = 70;
+	public const int b001000111 = 71;
+	public const int b001001000 = 72;
+	public const int b001001001 = 73;
+	public const int b001001010 = 74;
+	public const int b001001011 = 75;
+	public const int b001001100 = 76;
+	public const int b001001101 = 77;
+	public const int b001001110 = 78;
+	public const int b001001111 = 79;
+	public const int b001010000 = 80;
+	public const int b001010001 = 81;
+	public const int b001010010 = 82;
+	public const int b001010011 = 83;
+	public const int b001010100 = 84;
+	public const int b001010101 = 85;
+	public const int b001010110 = 86;
+	public const int b001010111 = 87;
+	public const int b001011000 = 88;
+	public const int b001011001 = 89;
+	public const int b001011010 = 90;
+	public const int b001011011 = 91;
+	public const int b001011100 = 92;
+	public const int b001011101 = 93;
+	public const int b001011110 = 94;
+	public const int b001011111 = 95;
+	public const int b001100000 = 96;
+	public const int b001100001 = 97;
+	public const int b001100010 = 98;
+	public const int b001100011 = 99;
+	public const int b001100100 = 100;
+	public const int b001100101 = 101;
+	public const int b001100110 = 102;
+	public const int b001100111 = 103;
+	public const int b001101000 = 104;
+	public const int b001101001 = 105;
+	public const int b001101010 = 106;
+	public const int b001101011 = 107;
+	public const int b001101100 = 108;
+	public const int b001101101 = 109;
+	public const int b001101110 = 110;
+	public const int b001101111 = 111;
+	public const int b001110000 = 112;
+	public const int b001110001 = 113;
+	public const int b001110010 = 114;
+	public const int b001110011 = 115;
+	public const int b001110100 = 116;
+	public const int b001110101 = 117;
+	public const int b001110110 = 118;
+	public const int b001110111 = 119;
+	public const int b001111000 = 120;
+	public const int b001111001 = 121;
+	public const int b001111010 = 122;
+	public const int b001111011 = 123;
+	public const int b001111100 = 124;
+	public const int b001111101 = 125;
+	public const int b001111110 = 126;
+	public const int b001111111 = 127;
+	public const int b010000000 = 128;
+	public const int b010000001 = 129;
+	public const int b010000010 = 130;
+	public const int b010000011 = 131;
+	public const int b010000100 = 132;
+	public const int b010000101 = 133;
+	public const int b010000110 = 134;
+	public const int b010000111 = 135;
+	public const int b010001000 = 136;
+	public const int b010001001 = 137;
+	public const int b010001010 = 138;
+	public const int b010001011 = 139;
+	public const int b010001100 = 140;
+	public const int b010001101 = 141;
+	public const int b010001110 = 142;
+	public const int b010001111 = 143;
+	public const int b010010000 = 144;
+	public const int b010010001 = 145;
+	public const int b010010010 = 146;
+	public const int b010010011 = 147;
+	public const int b010010100 = 148;
+	public const int b010010101 = 149;
+	public const int b010010110 = 150;
+	public const int b010010111 = 151;
+	public const int b010011000 = 152;
+	public const int b010011001 = 153;
+	public const int b010011010 = 154;
+	public const int b010011011 = 155;
+	public const int b010011100 = 156;
+	public const int b010011101 = 157;
+	public const int b010011110 = 158;
+	public const int b010011111 = 159;
+	public const int b010100000 = 160;
+	public const int b010100001 = 161;
+	public const int b010100010 = 162;
+	public const int b010100011 = 163;
+	public const int b010100100 = 164;
+	public const int b010100101 = 165;
+	public const int b010100110 = 166;
+	public const int b010100111 = 167;
+	public const int b010101000 = 168;
+	public const int b010101001 = 169;
+	public const int b010101010 = 170;
+	public const int b010101011 = 171;
+	public const int b010101100 = 172;
+	public const int b010101101 = 173;
+	public const int b010101110 = 174;
+	public const int b010101111 = 175;
+	public const int b010110000 = 176;
+	public const int b010110001 = 177;
+	public const int b010110010 = 178;
+	public const int b010110011 = 179;
+	public const int b010110100 = 180;
+	public const int b010110101 = 181;
+	public const int b010110110 = 182;
+	public const int b010110111 = 183;
+	public const int b010111000 = 184;
+	public const int b010111001 = 185;
+	public const int b010111010 = 186;
+	public const int b010111011 = 187;
+	public const int b010111100 = 188;
+	public const int b010111101 = 189;
+	public const int b010111110 = 190;
+	public const int b010111111 = 191;
+	public const int b011000000 = 192;
+	public const int b011000001 = 193;
+	public const int b011000010 = 194;
+	public const int b011000011 = 195;
+	public const int b011000100 = 196;
+	public const int b011000101 = 197;
+	public const int b011000110 = 198;
+	public const int b011000111 = 199;
+	public const int b011001000 = 200;
+	public const int b011001001 = 201;
+	public const int b011001010 = 202;
+	public const int b011001011 = 203;
+	public const int b011001100 = 204;
+	public const int b011001101 = 205;
+	public const int b011001110 = 206;
+	public const int b011001111 = 207;
+	public const int b011010000 = 208;
+	public const int b011010001 = 209;
+	public const int b011010010 = 210;
+	public const int b011010011 = 211;
+	public const int b011010100 = 212;
+	public const int b011010101 = 213;
+	public const int b011010110 = 214;
+	public const int b011010111 = 215;
+	public const int b011011000 = 216;
+	public const int b011011001 = 217;
+	public const int b011011010 = 218;
+	public const int b011011011 = 219;
+	public const int b011011100 = 220;
+	public const int b011011101 = 221;
+	public const int b011011110 = 222;
+	public const int b011011111 = 223;
+	public const int b011100000 = 224;
+	public const int b011100001 = 225;
+	public const int b011100010 = 226;
+	public const int b011100011 = 227;
+	public const int b011100100 = 228;
+	public const int b011100101 = 229;
+	public const int b011100110 = 230;
+	public const int b011100111 = 231;
+	public const int b011101000 = 232;
+	public const int b011101001 = 233;
+	public const int b011101010 = 234;
+	public const int b011101011 = 235;
+	public const int b011101100 = 236;
+	public const int b011101101 = 237;
+	public const int b011101110 = 238;
+	public const int b011101111 = 239;
+	public const int b011110000 = 240;
+	public const int b011110001 = 241;
+	public const int b011110010 = 242;
+	public const int b011110011 = 243;
+	public const int b011110100 = 244;
+	public const int b011110101 = 245;
+	public const int b011110110 = 246;
+	public const int b011110111 = 247;
+	public const int b011111000 = 248;
+	public const int b011111001 = 249;
+	public const int b011111010 = 250;
+	public const int b011111011 = 251;
+	public const int b011111100 = 252;
+	public const int b011111101 = 253;
+	public const int b011111110 = 254;
+	public const int b011111111 = 255;
+	public const int b100000000 = 256;
+	public const int b100000001 = 257;
+	public const int b100000010 = 258;
+	public const int b100000011 = 259;
+	public const int b100000100 = 260;
+	public const int b100000101 = 261;
+	public const int b100000110 = 262;
+	public const int b100000111 = 263;
+	public const int b100001000 = 264;
+	public const int b100001001 = 265;
+	public const int b100001010 = 266;
+	public const int b100001011 = 267;
+	public const int b100001100 = 268;
+	public const int b100001101 = 269;
+	public const int b100001110 = 270;
+	public const int b100001111 = 271;
+	public const int b100010000 = 272;
+	public const int b100010001 = 273;
+	public const int b100010010 = 274;
+	public const int b100010011 = 275;
+	public const int b100010100 = 276;
+	public const int b100010101 = 277;
+	public const int b100010110 = 278;
+	public const int b100010111 = 279;
+	public const int b100011000 = 280;
+	public const int b100011001 = 281;
+	public const int b100011010 = 282;
+	public const int b100011011 = 283;
+	public const int b100011100 = 284;
+	public const int b100011101 = 285;
+	public const int b100011110 = 286;
+	public const int b100011111 = 287;
+	public const int b100100000 = 288;
+	public const int b100100001 = 289;
+	public const int b100100010 = 290;
+	public const int b100100011 = 291;
+	public const int b100100100 = 292;
+	public const int b100100101 = 293;
+	public const int b100100110 = 294;
+	public const int b100100111 = 295;
+	public const int b100101000 = 296;
+	public const int b100101001 = 297;
+	public const int b100101010 = 298;
+	public const int b100101011 = 299;
+	public const int b100101100 = 300;
+	public const int b100101101 = 301;
+	public const int b100101110 = 302;
+	public const int b100101111 = 303;
+	public const int b100110000 = 304;
+	public const int b100110001 = 305;
+	public const int b100110010 = 306;
+	public const int b100110011 = 307;
+	public const int b100110100 = 308;
+	public const int b100110101 = 309;
+	public const int b100110110 = 310;
+	public const int b100110111 = 311;
+	public const int b100111000 = 312;
+	public const int b100111001 = 313;
+	public const int b100111010 = 314;
+	public const int b100111011 = 315;
+	public const int b100111100 = 316;
+	public const int b100111101 = 317;
+	public const int b100111110 = 318;
+	public const int b100111111 = 319;
+	public const int b101000000 = 320;
+	public const int b101000001 = 321;
+	public const int b101000010 = 322;
+	public const int b101000011 = 323;
+	public const int b101000100 = 324;
+	public const int b101000101 = 325;
+	public const int b101000110 = 326;
+	public const int b101000111 = 327;
+	public const int b101001000 = 328;
+	public const int b101001001 = 329;
+	public const int b101001010 = 330;
+	public const int b101001011 = 331;
+	public const int b101001100 = 332;
+	public const int b101001101 = 333;
+	public const int b101001110 = 334;
+	public const int b101001111 = 335;
+	public const int b101010000 = 336;
+	public const int b101010001 = 337;
+	public const int b101010010 = 338;
+	public const int b101010011 = 339;
+	public const int b101010100 = 340;
+	public const int b101010101 = 341;
+	public const int b101010110 = 342;
+	public const int b101010111 = 343;
+	public const int b101011000 = 344;
+	public const int b101011001 = 345;
+	public const int b101011010 = 346;
+	public const int b101011011 = 347;
+	public const int b101011100 = 348;
+	public const int b101011101 = 349;
+	public const int b101011110 = 350;
+	public const int b101011111 = 351;
+	public const int b101100000 = 352;
+	public const int b101100001 = 353;
+	public const int b101100010 = 354;
+	public const int b101100011 = 355;
+	public const int b101100100 = 356;
+	public const int b101100101 = 357;
+	public const int b101100110 = 358;
+	public const int b101100111 = 359;
+	public const int b101101000 = 360;
+	public const int b101101001 = 361;
+	public const int b101101010 = 362;
+	public const int b101101011 = 363;
+	public const int b101101100 = 364;
+	public const int b101101101 = 365;
+	public const int b101101110 = 366;
+	public const int b101101111 = 367;
+	public const int b101110000 = 368;
+	public const int b101110001 = 369;
+	public const int b101110010 = 370;
+	public const int b101110011 = 371;
+	public const int b101110100 = 372;
+	public const int b101110101 = 373;
+	public const int b101110110 = 374;
+	public const int b101110111 = 375;
+	public const int b101111000 = 376;
+	public const int b101111001 = 377;
+	public const int b101111010 = 378;
+	public const int b101111011 = 379;
+	public const int b101111100 = 380;
+	public const int b101111101 = 381;
+	public const int b101111110 = 382;
+	public const int b101111111 = 383;
+	public const int b110000000 = 384;
+	public const int b110000001 = 385;
+	public const int b110000010 = 386;
+	public const int b110000011 = 387;
+	public const int b110000100 = 388;
+	public const int b110000101 = 389;
+	public const int b110000110 = 390;
+	public const int b110000111 = 391;
+	public const int b110001000 = 392;
+	public const int b110001001 = 393;
+	public const int b110001010 = 394;
+	public const int b110001011 = 395;
+	public const int b110001100 = 396;
+	public const int b110001101 = 397;
+	public const int b110001110 = 398;
+	public const int b110001111 = 399;
+	public const int b110010000 = 400;
+	public const int b110010001 = 401;
+	public const int b110010010 = 402;
+	public const int b110010011 = 403;
+	public const int b110010100 = 404;
+	public const int b110010101 = 405;
+	public const int b110010110 = 406;
+	public const int b110010111 = 407;
+	public const int b110011000 = 408;
+	public const int b110011001 = 409;
+	public const int b110011010 = 410;
+	public const int b110011011 = 411;
+	public const int b110011100 = 412;
+	public const int b110011101 = 413;
+	public const int b110011110 = 414;
+	public const int b110011111 = 415;
+	public const int b110100000 = 416;
+	public const int b110100001 = 417;
+	public const int b110100010 = 418;
+	public const int b110100011 = 419;
+	public const int b110100100 = 420;
+	public const int b110100101 = 421;
+	public const int b110100110 = 422;
+	public const int b110100111 = 423;
+	public const int b110101000 = 424;
+	public const int b110101001 = 425;
+	public const int b110101010 = 426;
+	public const int b110101011 = 427;
+	public const int b110101100 = 428;
+	public const int b110101101 = 429;
+	public const int b110101110 = 430;
+	public const int b110101111 = 431;
+	public const int b110110000 = 432;
+	public const int b110110001 = 433;
+	public const int b110110010 = 434;
+	public const int b110110011 = 435;
+	public const int b110110100 = 436;
+	public const int b110110101 = 437;
+	public const int b110110110 = 438;
+	public const int b110110111 = 439;
+	public const int b110111000 = 440;
+	public const int b110111001 = 441;
+	public const int b110111010 = 442;
+	public const int b110111011 = 443;
+	public const int b110111100 = 444;
+	public const int b110111101 = 445;
+	public const int b110111110 = 446;
+	public const int b110111111 = 447;
+	public const int b111000000 = 448;
+	public const int b111000001 = 449;
+	public const int b111000010 = 450;
+	public const int b111000011 = 451;
+	public const int b111000100 = 452;
+	public const int b111000101 = 453;
+	public const int b111000110 = 454;
+	public const int b111000111 = 455;
+	public const int b111001000 = 456;
+	public const int b111001001 = 457;
+	public const int b111001010 = 458;
+	public const int b111001011 = 459;
+	public const int b111001100 = 460;
+	public const int b111001101 = 461;
+	public const int b111001110 = 462;
+	public const int b111001111 = 463;
+	public const int b111010000 = 464;
+	public const int b111010001 = 465;
+	public const int b111010010 = 466;
+	public const int b111010011 = 467;
+	public const int b111010100 = 468;
+	public const int b111010101 = 469;
+	public const int b111010110 = 470;
+	public const int b111010111 = 471;
+	public const int b111011000 = 472;
+	public const int b111011001 = 473;
+	public const int b111011010 = 474;
+	public const int b111011011 = 475;
+	public const int b111011100 = 476;
+	public const int b111011101 = 477;
+	public const int b111011110 = 478;
+	public const int b111011111 = 479;
+	public const int b111100000 = 480;
+	public const int b111100001 = 481;
+	public const int b111100010 = 482;
+	public const int b111100011 = 483;
+	public const int b111100100 = 484;
+	public const int b111100101 = 485;
+	public const int b111100110 = 486;
+	public const int b111100111 = 487;
+	public const int b111101000 = 488;
+	public const int b111101001 = 489;
+	public const int b111101010 = 490;
+	public const int b111101011 = 491;
+	public const int b111101100 = 492;
+	public const int b111101101 = 493;
+	public const int b111101110 = 494;
+	public const int b111101111 = 495;
+	public const int b111110000 = 496;
+	public const int b111110001 = 497;
+	public const int b111110010 = 498;
+	public const int b111110011 = 499;
+	public const int b111110100 = 500;
+	public const int b111110101 = 501;
+	public const int b111110110 = 502;
+	public const int b111110111 = 503;
+	public const int b111111000 = 504;
+	public const int b111111001 = 505;
+	public const int b111111010 = 506;
+	public const int b111111011 = 507;
+	public const int b111111100 = 508;
+	public const int b111111101 = 509;
+	public const int b111111110 = 510;
+	public const int b111111111 = 511;
+	public const int b00000000 = 0;
+	public const int b00000001 = 1;
+	public const int b00000010 = 2;
+	public const int b00000011 = 3;
+	public const int b00000100 = 4;
+	public const int b00000101 = 5;
+	public const int b00000110 = 6;
+	public const int b00000111 = 7;
+	public const int b00001000 = 8;
+	public const int b00001001 = 9;
+	public const int b00001010 = 10;
+	public const int b00001011 = 11;
+	public const int b00001100 = 12;
+	public const int b00001101 = 13;
+	public const int b00001110 = 14;
+	public const int b00001111 = 15;
+	public const int b00010000 = 16;
+	public const int b00010001 = 17;
+	public const int b00010010 = 18;
+	public const int b00010011 = 19;
+	public const int b00010100 = 20;
+	public const int b00010101 = 21;
+	public const int b00010110 = 22;
+	public const int b00010111 = 23;
+	public const int b00011000 = 24;
+	public const int b00011001 = 25;
+	public const int b00011010 = 26;
+	public const int b00011011 = 27;
+	public const int b00011100 = 28;
+	public const int b00011101 = 29;
+	public const int b00011110 = 30;
+	public const int b00011111 = 31;
+	public const int b00100000 = 32;
+	public const int b00100001 = 33;
+	public const int b00100010 = 34;
+	public const int b00100011 = 35;
+	public const int b00100100 = 36;
+	public const int b00100101 = 37;
+	public const int b00100110 = 38;
+	public const int b00100111 = 39;
+	public const int b00101000 = 40;
+	public const int b00101001 = 41;
+	public const int b00101010 = 42;
+	public const int b00101011 = 43;
+	public const int b00101100 = 44;
+	public const int b00101101 = 45;
+	public const int b00101110 = 46;
+	public const int b00101111 = 47;
+	public const int b00110000 = 48;
+	public const int b00110001 = 49;
+	public const int b00110010 = 50;
+	public const int b00110011 = 51;
+	public const int b00110100 = 52;
+	public const int b00110101 = 53;
+	public const int b00110110 = 54;
+	public const int b00110111 = 55;
+	public const int b00111000 = 56;
+	public const int b00111001 = 57;
+	public const int b00111010 = 58;
+	public const int b00111011 = 59;
+	public const int b00111100 = 60;
+	public const int b00111101 = 61;
+	public const int b00111110 = 62;
+	public const int b00111111 = 63;
+	public const int b01000000 = 64;
+	public const int b01000001 = 65;
+	public const int b01000010 = 66;
+	public const int b01000011 = 67;
+	public const int b01000100 = 68;
+	public const int b01000101 = 69;
+	public const int b01000110 = 70;
+	public const int b01000111 = 71;
+	public const int b01001000 = 72;
+	public const int b01001001 = 73;
+	public const int b01001010 = 74;
+	public const int b01001011 = 75;
+	public const int b01001100 = 76;
+	public const int b01001101 = 77;
+	public const int b01001110 = 78;
+	public const int b01001111 = 79;
+	public const int b01010000 = 80;
+	public const int b01010001 = 81;
+	public const int b01010010 = 82;
+	public const int b01010011 = 83;
+	public const int b01010100 = 84;
+	public const int b01010101 = 85;
+	public const int b01010110 = 86;
+	public const int b01010111 = 87;
+	public const int b01011000 = 88;
+	public const int b01011001 = 89;
+	public const int b01011010 = 90;
+	public const int b01011011 = 91;
+	public const int b01011100 = 92;
+	public const int b01011101 = 93;
+	public const int b01011110 = 94;
+	public const int b01011111 = 95;
+	public const int b01100000 = 96;
+	public const int b01100001 = 97;
+	public const int b01100010 = 98;
+	public const int b01100011 = 99;
+	public const int b01100100 = 100;
+	public const int b01100101 = 101;
+	public const int b01100110 = 102;
+	public const int b01100111 = 103;
+	public const int b01101000 = 104;
+	public const int b01101001 = 105;
+	public const int b01101010 = 106;
+	public const int b01101011 = 107;
+	public const int b01101100 = 108;
+	public const int b01101101 = 109;
+	public const int b01101110 = 110;
+	public const int b01101111 = 111;
+	public const int b01110000 = 112;
+	public const int b01110001 = 113;
+	public const int b01110010 = 114;
+	public const int b01110011 = 115;
+	public const int b01110100 = 116;
+	public const int b01110101 = 117;
+	public const int b01110110 = 118;
+	public const int b01110111 = 119;
+	public const int b01111000 = 120;
+	public const int b01111001 = 121;
+	public const int b01111010 = 122;
+	public const int b01111011 = 123;
+	public const int b01111100 = 124;
+	public const int b01111101 = 125;
+	public const int b01111110 = 126;
+	public const int b01111111 = 127;
+	public const int b10000000 = 128;
+	public const int b10000001 = 129;
+	public const int b10000010 = 130;
+	public const int b10000011 = 131;
+	public const int b10000100 = 132;
+	public const int b10000101 = 133;
+	public const int b10000110 = 134;
+	public const int b10000111 = 135;
+	public const int b10001000 = 136;
+	public const int b10001001 = 137;
+	public const int b10001010 = 138;
+	public const int b10001011 = 139;
+	public const int b10001100 = 140;
+	public const int b10001101 = 141;
+	public const int b10001110 = 142;
+	public const int b10001111 = 143;
+	public const int b10010000 = 144;
+	public const int b10010001 = 145;
+	public const int b10010010 = 146;
+	public const int b10010011 = 147;
+	public const int b10010100 = 148;
+	public const int b10010101 = 149;
+	public const int b10010110 = 150;
+	public const int b10010111 = 151;
+	public const int b10011000 = 152;
+	public const int b10011001 = 153;
+	public const int b10011010 = 154;
+	public const int b10011011 = 155;
+	public const int b10011100 = 156;
+	public const int b10011101 = 157;
+	public const int b10011110 = 158;
+	public const int b10011111 = 159;
+	public const int b10100000 = 160;
+	public const int b10100001 = 161;
+	public const int b10100010 = 162;
+	public const int b10100011 = 163;
+	public const int b10100100 = 164;
+	public const int b10100101 = 165;
+	public const int b10100110 = 166;
+	public const int b10100111 = 167;
+	public const int b10101000 = 168;
+	public const int b10101001 = 169;
+	public const int b10101010 = 170;
+	public const int b10101011 = 171;
+	public const int b10101100 = 172;
+	public const int b10101101 = 173;
+	public const int b10101110 = 174;
+	public const int b10101111 = 175;
+	public const int b10110000 = 176;
+	public const int b10110001 = 177;
+	public const int b10110010 = 178;
+	public const int b10110011 = 179;
+	public const int b10110100 = 180;
+	public const int b10110101 = 181;
+	public const int b10110110 = 182;
+	public const int b10110111 = 183;
+	public const int b10111000 = 184;
+	public const int b10111001 = 185;
+	public const int b10111010 = 186;
+	public const int b10111011 = 187;
+	public const int b10111100 = 188;
+	public const int b10111101 = 189;
+	public const int b10111110 = 190;
+	public const int b10111111 = 191;
+	public const int b11000000 = 192;
+	public const int b11000001 = 193;
+	public const int b11000010 = 194;
+	public const int b11000011 = 195;
+	public const int b11000100 = 196;
+	public const int b11000101 = 197;
+	public const int b11000110 = 198;
+	public const int b11000111 = 199;
+	public const int b11001000 = 200;
+	public const int b11001001 = 201;
+	public const int b11001010 = 202;
+	public const int b11001011 = 203;
+	public const int b11001100 = 204;
+	public const int b11001101 = 205;
+	public const int b11001110 = 206;
+	public const int b11001111 = 207;
+	public const int b11010000 = 208;
+	public const int b11010001 = 209;
+	public const int b11010010 = 210;
+	public const int b11010011 = 211;
+	public const int b11010100 = 212;
+	public const int b11010101 = 213;
+	public const int b11010110 = 214;
+	public const int b11010111 = 215;
+	public const int b11011000 = 216;
+	public const int b11011001 = 217;
+	public const int b11011010 = 218;
+	public const int b11011011 = 219;
+	public const int b11011100 = 220;
+	public const int b11011101 = 221;
+	public const int b11011110 = 222;
+	public const int b11011111 = 223;
+	public const int b11100000 = 224;
+	public const int b11100001 = 225;
+	public const int b11100010 = 226;
+	public const int b11100011 = 227;
+	public const int b11100100 = 228;
+	public const int b11100101 = 229;
+	public const int b11100110 = 230;
+	public const int b11100111 = 231;
+	public const int b11101000 = 232;
+	public const int b11101001 = 233;
+	public const int b11101010 = 234;
+	public const int b11101011 = 235;
+	public const int b11101100 = 236;
+	public const int b11101101 = 237;
+	public const int b11101110 = 238;
+	public const int b11101111 = 239;
+	public const int b11110000 = 240;
+	public const int b11110001 = 241;
+	public const int b11110010 = 242;
+	public const int b11110011 = 243;
+	public const int b11110100 = 244;
+	public const int b11110101 = 245;
+	public const int b11110110 = 246;
+	public const int b11110111 = 247;
+	public const int b11111000 = 248;
+	public const int b11111001 = 249;
+	public const int b11111010 = 250;
+	public const int b11111011 = 251;
+	public const int b11111100 = 252;
+	public const int b11111101 = 253;
+	public const int b11111110 = 254;
+	public const int b11111111 = 255;
+	public const int b0000000 = 0;
+	public const int b0000001 = 1;
+	public const int b0000010 = 2;
+	public const int b0000011 = 3;
+	public const int b0000100 = 4;
+	public const int b0000101 = 5;
+	public const int b0000110 = 6;
+	public const int b0000111 = 7;
+	public const int b0001000 = 8;
+	public const int b0001001 = 9;
+	public const int b0001010 = 10;
+	public const int b0001011 = 11;
+	public const int b0001100 = 12;
+	public const int b0001101 = 13;
+	public const int b0001110 = 14;
+	public const int b0001111 = 15;
+	public const int b0010000 = 16;
+	public const int b0010001 = 17;
+	public const int b0010010 = 18;
+	public const int b0010011 = 19;
+	public const int b0010100 = 20;
+	public const int b0010101 = 21;
+	public const int b0010110 = 22;
+	public const int b0010111 = 23;
+	public const int b0011000 = 24;
+	public const int b0011001 = 25;
+	public const int b0011010 = 26;
+	public const int b0011011 = 27;
+	public const int b0011100 = 28;
+	public const int b0011101 = 29;
+	public const int b0011110 = 30;
+	public const int b0011111 = 31;
+	public const int b0100000 = 32;
+	public const int b0100001 = 33;
+	public const int b0100010 = 34;
+	public const int b0100011 = 35;
+	public const int b0100100 = 36;
+	public const int b0100101 = 37;
+	public const int b0100110 = 38;
+	public const int b0100111 = 39;
+	public const int b0101000 = 40;
+	public const int b0101001 = 41;
+	public const int b0101010 = 42;
+	public const int b0101011 = 43;
+	public const int b0101100 = 44;
+	public const int b0101101 = 45;
+	public const int b0101110 = 46;
+	public const int b0101111 = 47;
+	public const int b0110000 = 48;
+	public const int b0110001 = 49;
+	public const int b0110010 = 50;
+	public const int b0110011 = 51;
+	public const int b0110100 = 52;
+	public const int b0110101 = 53;
+	public const int b0110110 = 54;
+	public const int b0110111 = 55;
+	public const int b0111000 = 56;
+	public const int b0111001 = 57;
+	public const int b0111010 = 58;
+	public const int b0111011 = 59;
+	public const int b0111100 = 60;
+	public const int b0111101 = 61;
+	public const int b0111110 = 62;
+	public const int b0111111 = 63;
+	public const int b1000000 = 64;
+	public const int b1000001 = 65;
+	public const int b1000010 = 66;
+	public const int b1000011 = 67;
+	public const int b1000100 = 68;
+	public const int b1000101 = 69;
+	public const int b1000110 = 70;
+	public const int b1000111 = 71;
+	public const int b1001000 = 72;
+	public const int b1001001 = 73;
+	public const int b1001010 = 74;
+	public const int b1001011 = 75;
+	public const int b1001100 = 76;
+	public const int b1001101 = 77;
+	public const int b1001110 = 78;
+	public const int b1001111 = 79;
+	public const int b1010000 = 80;
+	public const int b1010001 = 81;
+	public const int b1010010 = 82;
+	public const int b1010011 = 83;
+	public const int b1010100 = 84;
+	public const int b1010101 = 85;
+	public const int b1010110 = 86;
+	public const int b1010111 = 87;
+	public const int b1011000 = 88;
+	public const int b1011001 = 89;
+	public const int b1011010 = 90;
+	public const int b1011011 = 91;
+	public const int b1011100 = 92;
+	public const int b1011101 = 93;
+	public const int b1011110 = 94;
+	public const int b1011111 = 95;
+	public const int b1100000 = 96;
+	public const int b1100001 = 97;
+	public const int b1100010 = 98;
+	public const int b1100011 = 99;
+	public const int b1100100 = 100;
+	public const int b1100101 = 101;
+	public const int b1100110 = 102;
+	public const int b1100111 = 103;
+	public const int b1101000 = 104;
+	public const int b1101001 = 105;
+	public const int b1101010 = 106;
+	public const int b1101011 = 107;
+	public const int b1101100 = 108;
+	public const int b1101101 = 109;
+	public const int b1101110 = 110;
+	public const int b1101111 = 111;
+	public const int b1110000 = 112;
+	public const int b1110001 = 113;
+	public const int b1110010 = 114;
+	public const int b1110011 = 115;
+	public const int b1110100 = 116;
+	public const int b1110101 = 117;
+	public const int b1110110 = 118;
+	public const int b1110111 = 119;
+	public const int b1111000 = 120;
+	public const int b1111001 = 121;
+	public const int b1111010 = 122;
+	public const int b1111011 = 123;
+	public const int b1111100 = 124;
+	public const int b1111101 = 125;
+	public const int b1111110 = 126;
+	public const int b1111111 = 127;
+	public const int b000000 = 0;
+	public const int b000001 = 1;
+	public const int b000010 = 2;
+	public const int b000011 = 3;
+	public const int b000100 = 4;
+	public const int b000101 = 5;
+	public const int b000110 = 6;
+	public const int b000111 = 7;
+	public const int b001000 = 8;
+	public const int b001001 = 9;
+	public const int b001010 = 10;
+	public const int b001011 = 11;
+	public const int b001100 = 12;
+	public const int b001101 = 13;
+	public const int b001110 = 14;
+	public const int b001111 = 15;
+	public const int b010000 = 16;
+	public const int b010001 = 17;
+	public const int b010010 = 18;
+	public const int b010011 = 19;
+	public const int b010100 = 20;
+	public const int b010101 = 21;
+	public const int b010110 = 22;
+	public const int b010111 = 23;
+	public const int b011000 = 24;
+	public const int b011001 = 25;
+	public const int b011010 = 26;
+	public const int b011011 = 27;
+	public const int b011100 = 28;
+	public const int b011101 = 29;
+	public const int b011110 = 30;
+	public const int b011111 = 31;
+	public const int b100000 = 32;
+	public const int b100001 = 33;
+	public const int b100010 = 34;
+	public const int b100011 = 35;
+	public const int b100100 = 36;
+	public const int b100101 = 37;
+	public const int b100110 = 38;
+	public const int b100111 = 39;
+	public const int b101000 = 40;
+	public const int b101001 = 41;
+	public const int b101010 = 42;
+	public const int b101011 = 43;
+	public const int b101100 = 44;
+	public const int b101101 = 45;
+	public const int b101110 = 46;
+	public const int b101111 = 47;
+	public const int b110000 = 48;
+	public const int b110001 = 49;
+	public const int b110010 = 50;
+	public const int b110011 = 51;
+	public const int b110100 = 52;
+	public const int b110101 = 53;
+	public const int b110110 = 54;
+	public const int b110111 = 55;
+	public const int b111000 = 56;
+	public const int b111001 = 57;
+	public const int b111010 = 58;
+	public const int b111011 = 59;
+	public const int b111100 = 60;
+	public const int b111101 = 61;
+	public const int b111110 = 62;
+	public const int b111111 = 63;
+	public const int b00000 = 0;
+	public const int b00001 = 1;
+	public const int b00010 = 2;
+	public const int b00011 = 3;
+	public const int b00100 = 4;
+	public const int b00101 = 5;
+	public const int b00110 = 6;
+	public const int b00111 = 7;
+	public const int b01000 = 8;
+	public const int b01001 = 9;
+	public const int b01010 = 10;
+	public const int b01011 = 11;
+	public const int b01100 = 12;
+	public const int b01101 = 13;
+	public const int b01110 = 14;
+	public const int b01111 = 15;
+	public const int b10000 = 16;
+	public const int b10001 = 17;
+	public const int b10010 = 18;
+	public const int b10011 = 19;
+	public const int b10100 = 20;
+	public const int b10101 = 21;
+	public const int b10110 = 22;
+	public const int b10111 = 23;
+	public const int b11000 = 24;
+	public const int b11001 = 25;
+	public const int b11010 = 26;
+	public const int b11011 = 27;
+	public const int b11100 = 28;
+	public const int b11101 = 29;
+	public const int b11110 = 30;
+	public const int b11111 = 31;
+	public const int b0000 = 0;
+	public const int b0001 = 1;
+	public const int b0010 = 2;
+	public const int b0011 = 3;
+	public const int b0100 = 4;
+	public const int b0101 = 5;
+	public const int b0110 = 6;
+	public const int b0111 = 7;
+	public const int b1000 = 8;
+	public const int b1001 = 9;
+	public const int b1010 = 10;
+	public const int b1011 = 11;
+	public const int b1100 = 12;
+	public const int b1101 = 13;
+	public const int b1110 = 14;
+	public const int b1111 = 15;
+	public const int b000 = 0;
+	public const int b001 = 1;
+	public const int b010 = 2;
+	public const int b011 = 3;
+	public const int b100 = 4;
+	public const int b101 = 5;
+	public const int b110 = 6;
+	public const int b111 = 7;
+	public const int b00 = 0;
+	public const int b01 = 1;
+	public const int b10 = 2;
+	public const int b11 = 3;
+	public const int b0 = 0;
+	public const int b1 = 1;
+	public static uint BIT0(uint val) { return (val >> 0) & 1; }
+	public static uint BIT1(uint val) { return (val >> 1) & 1; }
+	public static uint BIT2(uint val) { return (val >> 2) & 1; }
+	public static uint BIT3(uint val) { return (val >> 3) & 1; }
+	public static uint BIT4(uint val) { return (val >> 4) & 1; }
+	public static uint BIT5(uint val) { return (val >> 5) & 1; }
+	public static uint BIT6(uint val) { return (val >> 6) & 1; }
+	public static uint BIT7(uint val) { return (val >> 7) & 1; }
+	public static uint BIT8(uint val) { return (val >> 8) & 1; }
+	public static uint BIT9(uint val) { return (val >> 9) & 1; }
+	public static uint BIT10(uint val) { return (val >> 10) & 1; }
+	public static uint BIT11(uint val) { return (val >> 11) & 1; }
+	public static uint BIT12(uint val) { return (val >> 12) & 1; }
+	public static uint BIT13(uint val) { return (val >> 13) & 1; }
+	public static uint BIT14(uint val) { return (val >> 14) & 1; }
+	public static uint BIT15(uint val) { return (val >> 15) & 1; }
+	public static uint BIT16(uint val) { return (val >> 16) & 1; }
+	public static uint BIT17(uint val) { return (val >> 17) & 1; }
+	public static uint BIT18(uint val) { return (val >> 18) & 1; }
+	public static uint BIT19(uint val) { return (val >> 19) & 1; }
+	public static uint BIT20(uint val) { return (val >> 20) & 1; }
+	public static uint BIT21(uint val) { return (val >> 21) & 1; }
+	public static uint BIT22(uint val) { return (val >> 22) & 1; }
+	public static uint BIT23(uint val) { return (val >> 23) & 1; }
+	public static uint BIT24(uint val) { return (val >> 24) & 1; }
+	public static uint BIT25(uint val) { return (val >> 25) & 1; }
+	public static uint BIT26(uint val) { return (val >> 26) & 1; }
+	public static uint BIT27(uint val) { return (val >> 27) & 1; }
+	public static uint BIT28(uint val) { return (val >> 28) & 1; }
+	public static uint BIT29(uint val) { return (val >> 29) & 1; }
+	public static uint BIT30(uint val) { return (val >> 30) & 1; }
+	public static uint BIT31(uint val) { return (val >> 31) & 1; }
+	public static uint BIT32(ulong val) { return (uint)((val >> 32) & 1); }
+	public static uint BIT33(ulong val) { return (uint)((val >> 33) & 1); }
+	public static uint BIT34(ulong val) { return (uint)((val >> 34) & 1); }
+	public static uint BIT35(ulong val) { return (uint)((val >> 35) & 1); }
+	public static uint BIT36(ulong val) { return (uint)((val >> 36) & 1); }
+	public static uint BIT37(ulong val) { return (uint)((val >> 37) & 1); }
+	public static uint BIT38(ulong val) { return (uint)((val >> 38) & 1); }
+	public static uint BIT39(ulong val) { return (uint)((val >> 39) & 1); }
+	public static uint BIT40(ulong val) { return (uint)((val >> 40) & 1); }
+	public static uint BIT41(ulong val) { return (uint)((val >> 41) & 1); }
+	public static uint BIT42(ulong val) { return (uint)((val >> 42) & 1); }
+	public static uint BIT43(ulong val) { return (uint)((val >> 43) & 1); }
+	public static uint BIT44(ulong val) { return (uint)((val >> 44) & 1); }
+	public static uint BIT45(ulong val) { return (uint)((val >> 45) & 1); }
+	public static uint BIT46(ulong val) { return (uint)((val >> 46) & 1); }
+	public static uint BIT47(ulong val) { return (uint)((val >> 47) & 1); }
+	public static uint BIT48(ulong val) { return (uint)((val >> 48) & 1); }
+	public static uint BIT49(ulong val) { return (uint)((val >> 49) & 1); }
+	public static uint BIT50(ulong val) { return (uint)((val >> 50) & 1); }
+	public static uint BIT51(ulong val) { return (uint)((val >> 51) & 1); }
+	public static uint BIT52(ulong val) { return (uint)((val >> 52) & 1); }
+	public static uint BIT53(ulong val) { return (uint)((val >> 53) & 1); }
+	public static uint BIT54(ulong val) { return (uint)((val >> 54) & 1); }
+	public static uint BIT55(ulong val) { return (uint)((val >> 55) & 1); }
+	public static uint BIT56(ulong val) { return (uint)((val >> 56) & 1); }
+	public static uint BIT57(ulong val) { return (uint)((val >> 57) & 1); }
+	public static uint BIT58(ulong val) { return (uint)((val >> 58) & 1); }
+	public static uint BIT59(ulong val) { return (uint)((val >> 59) & 1); }
+	public static uint BIT60(ulong val) { return (uint)((val >> 60) & 1); }
+	public static uint BIT61(ulong val) { return (uint)((val >> 61) & 1); }
+	public static uint BIT62(ulong val) { return (uint)((val >> 62) & 1); }
+	public static uint BIT63(ulong val) { return (uint)((val >> 63) & 1); }
+	public static uint BITN(int which, uint val) { return (val >> which) & 1; }
+	public static uint BITN(int which, ulong val) { return (uint)((val >> which) & 1); }
+}
+
+partial class _
+{
+	public static uint BitCount(uint val)
+	{
+		val -= ((val >> 1) & 0x55555555);
+		val = (((val >> 2) & 0x33333333) + (val & 0x33333333));
+		val = (((val >> 4) + val) & 0x0f0f0f0f);
+		return ((val * 0x01010101) >> 24);
+	}
+}
diff --git a/BizHawk.Emulation/CPUs/ARM/decoder/decoder.cs b/BizHawk.Emulation/CPUs/ARM/decoder/decoder.cs
new file mode 100644
index 0000000000..8c37faddf0
--- /dev/null
+++ b/BizHawk.Emulation/CPUs/ARM/decoder/decoder.cs
@@ -0,0 +1,179 @@
+using System;
+using System.Linq;
+using System.Text.RegularExpressions;
+using System.Collections.Generic;
+
+public class BS
+{
+	public BS(string str)
+	{
+		ca = str.ToCharArray();
+		Array.Reverse(ca);
+	}
+	char[] ca;
+	public static bool operator ==(uint lhs, BS rhs) { return rhs == lhs; }
+	public static bool operator !=(uint lhs, BS rhs) { return rhs != lhs; }
+	public static bool operator ==(int lhs, BS rhs) { return rhs == (uint)lhs; }
+	public static bool operator !=(int lhs, BS rhs) { return rhs != (uint)lhs; }
+	public static bool operator ==(BS lhs, int rhs) { return (uint)rhs == lhs; }
+	public static bool operator !=(BS lhs, int rhs) { return (uint)rhs != lhs; }
+	public static bool operator ==(BS lhs, uint rhs)
+	{
+		foreach (char c in lhs.ca)
+		{
+			uint bit = rhs & 1;
+			switch (c)
+			{
+				case '0': if (bit != 0) return false; break;
+				case '1': if (bit != 1) return false; break;
+			}
+			rhs >>= 1;
+		}
+		if(rhs != 0) return false;
+		return true;
+	}
+	public static bool operator !=(BS lhs, uint rhs) { return !(lhs == rhs); }
+	public override bool Equals(object obj)
+	{
+		if (obj is uint) return this == (uint)obj;
+		if (obj is int) return this == (int)obj;
+		if (obj is BS) throw new InvalidOperationException();
+		return false;
+	}
+	public override int GetHashCode()
+	{
+		return ca.GetHashCode();
+	}
+}
+
+class Decoder
+{
+	bool constructed = false;
+	public void Ensure(Action constructor)
+	{
+		if (constructed) return;
+		constructed = true;
+		constructor();
+		Compile();
+	}
+
+	//public Decoder(params object[] args)
+	//{
+	//    if(args.Length %2 != 0) throw new ArgumentException("need odd params to Decoder");
+		
+	//    for(int i=0;i<args.Length/2;i++)
+	//    {
+	//        string str = (string)args[i * 2];
+	//        object o = args[i * 2 + 1];
+	//        if (o is int)
+	//            Declare(str, (int)o);
+	//        else AddRule(str, (Action)o);
+	//    }
+	//}
+
+	class Rule
+	{
+		public Rule(string program,Action action)
+		{
+			this.program = program;
+			this.action = action;
+		}
+		public string program;
+		public Action action;
+	}
+	public void AddRule(string rule, Action action)
+	{
+		rules.Add(new Rule(rule,action));
+	}
+	public Decoder r(string rule, Action action)
+	{
+		AddRule(rule, action);
+		return this;
+	}
+
+	List<Rule> rules = new List<Rule>();
+
+	class Variable
+	{
+		public Variable(string name, int bits)
+		{
+			this.name = name;
+			this.bits = bits;
+		}
+		public string name;
+		public int bits;
+	}
+	List<Variable> variables = new List<Variable>();
+
+	public void Declare(string name, int bits)
+	{
+		variables.Add(new Variable(name, bits));
+	}
+	public Decoder d(string name, int bits)
+	{
+		Declare(name, bits);
+		return this;
+	}
+
+	static Regex rxBits = new Regex(@"(\#([01xX]*))", RegexOptions.Compiled);
+	bool compiled = false;
+
+	public void Compile()
+	{
+		if (compiled) return;
+		compiled = true;
+		int numbits = 0;
+		ScriptEngine se = new ScriptEngine();
+		foreach (Variable v in variables) numbits += v.bits;
+		int cases = 1 << numbits;
+		for (uint i = 0; i < cases; i++)
+		{
+			//split apart key
+			uint itemp = i;
+			for (int j = 0; j < variables.Count; j++)
+			{
+				Variable v = variables[j];
+				uint x = (uint)(itemp & ((1 << v.bits)-1));
+				itemp >>= v.bits;
+				se.variables[v.name] = x;
+			}
+
+			//default table value is an exception
+			table[i] = () => { throw new InvalidOperationException("auto-decoder fail (missing case)"); };
+
+			foreach (Rule rule in rules)
+			{
+				string program = rule.program;
+				foreach (Match m in rxBits.Matches(program))
+					program = program.Replace(m.Value, "new BS(\"" + m.Groups[2].Value + "\")");
+				object o = se.Eval(program);
+				bool? b = o as bool?;
+				if(!b.HasValue) throw new InvalidOperationException();
+				if (b.Value)
+				{
+					table[i] = rule.action;
+				}
+			}
+		}
+
+		se.Dispose();
+	}
+
+	//TODO - make overloads for different param number (array create overhead will be high)
+	public void Evaluate(params uint[] args)
+	{
+		Compile();
+		uint key = 0;
+		for (int i = variables.Count-1; i >= 0; i--)
+		{
+			Variable v = variables[i];
+			key <<= v.bits;
+			if (args[i] > (1 << v.bits))
+				throw new ArgumentException();
+			key |= args[i];
+		}
+		table[key]();
+	}
+
+	Dictionary<uint, Action> table = new Dictionary<uint, Action>();
+}
\ No newline at end of file
diff --git a/BizHawk.Emulation/CPUs/ARM/decoder/scripting.cs b/BizHawk.Emulation/CPUs/ARM/decoder/scripting.cs
new file mode 100644
index 0000000000..ed30fe771d
--- /dev/null
+++ b/BizHawk.Emulation/CPUs/ARM/decoder/scripting.cs
@@ -0,0 +1,136 @@
+using System;
+using System.Text;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.InteropServices;
+
+using Microsoft.JScript;
+using Microsoft.JScript.Vsa;
+using Microsoft.Vsa;
+
+#pragma warning disable 0618
+
+class ScriptEngine : IDisposable
+{
+	string[] commonNamespaces =
+		{
+		"System"
+		};
+
+	string[] commonAssemblies =
+		{
+		"mscorlib.dll",
+		"System.dll",
+		System.Reflection.Assembly.GetExecutingAssembly().Location
+		};
+
+
+	VsaEngine engine;
+	//Microsoft.JScript.GlobalScope jscriptGlobalScope = null;
+
+	public Dictionary<string, object> variables = new Dictionary<string, object>();
+
+	class MySite : Microsoft.Vsa.BaseVsaSite
+	{
+		ScriptEngine se;
+		public MySite(ScriptEngine se)
+		{
+			this.se = se;
+		}
+		public override object GetGlobalInstance(string name)
+		{
+			return se.variables[name];
+		}
+	}
+
+	public ScriptEngine()
+	{
+		InitializeJScriptDotNetEngine();
+	}
+
+	public void Dispose()
+	{
+		UninitializeJScriptDotNetEngine();
+	}
+
+	bool hasVariables = false;
+	public object Eval(string script)
+	{
+		if (!hasVariables)
+		{
+			hasVariables = true;
+			foreach (KeyValuePair<string, object> kvp in variables)
+			{
+				IVsaGlobalItem globItem = (IVsaGlobalItem)engine.Items.CreateItem(kvp.Key, VsaItemType.AppGlobal, VsaItemFlag.None);
+				globItem.TypeString = kvp.Value.GetType().FullName;
+			}
+			engine.CompileEmpty();
+			engine.RunEmpty();
+		}
+
+		StringBuilder sb = new StringBuilder();
+		foreach (KeyValuePair<string, object> kvp in variables)
+			sb.AppendFormat("{0} = {1};\n",kvp.Key,kvp.Value);
+		sb.AppendLine(script);
+		
+		object o = Microsoft.JScript.Eval.JScriptEvaluate(sb.ToString(), engine);
+
+		return o;
+	}
+
+	private void UninitializeJScriptDotNetEngine()
+	{
+
+		//if (jscriptGlobalScope != null)
+
+		//    jscriptGlobalScope.engine.Close();
+
+		//jscriptGlobalScope = null;
+		if(engine != null)
+			engine.Close();
+		engine = null;
+	}
+
+	private void InitializeJScriptDotNetEngine()
+	{
+
+		if (engine == null)
+		{
+
+			try
+			{
+				engine = new VsaEngine();
+				engine.InitVsaEngine("blah://x",new MySite(this));
+				foreach (string str in commonAssemblies)
+				{
+					IVsaReferenceItem reference = (IVsaReferenceItem)engine.Items.CreateItem(str, VsaItemType.Reference, VsaItemFlag.None);
+					reference.AssemblyName = str;
+				}
+
+
+			}
+
+			catch { }
+
+			foreach (string ns in commonNamespaces)
+			{
+
+				try
+				{
+
+					if ((ns != null) && (ns != String.Empty))
+
+						Microsoft.JScript.Import.JScriptImport(ns, engine);
+
+				}
+
+				catch { }
+
+			}
+
+		}
+
+	}
+}
+
+